-
Notifications
You must be signed in to change notification settings - Fork 2
/
schema.resolvers.go
139 lines (118 loc) · 3.67 KB
/
schema.resolvers.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
package graph
// This file will be automatically regenerated based on the schema, any resolver implementations
// will be copied through when generating and any unknown code will be moved to the end.
import (
"context"
"fmt"
"github.com/jjauzion/ws-backend/internal/auth"
"time"
"github.com/google/uuid"
"github.com/jjauzion/ws-backend/db"
"go.uber.org/zap"
)
func (r *mutationResolver) CreateUser(ctx context.Context, input NewUser) (*User, error) {
dbu, err := r.Auth.UserFromContext(ctx, auth.OptOnlyAdmin)
if err != nil {
return nil, err
}
r.Log.Debug("create user...", zap.String("user_id", dbu.ID))
newUser := db.User{
ID: uuid.New().String(),
Admin: false,
Email: input.Email,
CreatedAt: time.Now(),
}
err = r.Dbal.CreateUser(ctx, newUser)
if err != nil {
if err == db.ErrTooManyHits {
return nil, fmt.Errorf("user already exist")
}
r.Log.Warn("create user: ", zap.Error(err))
return nil, err
}
return UserFromDBModel(newUser).Ptr(), nil
}
func (r *mutationResolver) CreateTask(ctx context.Context, input NewTask) (*Task, error) {
dbu, err := r.Auth.UserFromContext(ctx, auth.OptAuthenticatedUser)
if err != nil {
return nil, err
}
r.Log.Debug("create tasks...", zap.String("user_id", dbu.ID))
user := UserFromDBModel(dbu)
newJob := db.Job{
DockerImage: input.DockerImage,
Dataset: *input.Dataset,
Env: input.Env,
}
newTask := db.Task{
ID: uuid.New().String(),
UserId: user.ID,
CreatedAt: time.Now(),
StartedAt: time.Unix(0, 0),
EndedAt: time.Unix(0, 0),
Status: db.StatusNotStarted,
Job: newJob,
}
if err = r.Dbal.CreateTask(ctx, newTask); err != nil {
return nil, err
}
r.Log.Info("task created", zap.String("id", newTask.ID))
return TaskFromDBModel(newTask).Ptr(), nil
}
func (r *queryResolver) ListTasks(ctx context.Context) ([]*Task, error) {
user, err := r.Auth.UserFromContext(ctx, auth.OptAuthenticatedUser)
if err != nil {
return nil, err
}
r.Log.Debug("list tasks...", zap.String("user_id", user.ID))
r.Log.Debug("user authenticated", zap.String("user_email", user.Email))
res, err := r.Dbal.GetTasksByUserID(ctx, user.ID)
if err != nil {
r.Log.Warn("cannot get tasks", zap.String("user_id", user.ID), zap.Error(err))
return nil, err
}
tasks := Tasks{}
for _, re := range res {
tasks = append(tasks, TaskFromDBModel(re).Ptr())
}
r.Log.Info("list tasks success",
zap.Int("tasks found", len(tasks)),
zap.String("user_email", user.Email))
r.Log.Debug("list tasks returned details", zap.Array("tasks", tasks))
return tasks, nil
}
func (r *queryResolver) Login(ctx context.Context, id string, pwd string) (LoginRes, error) {
user, err := r.Auth.UserFromContext(ctx, auth.OptAllowAll)
if err != nil {
return nil, err
}
r.Log.Debug("login...", zap.String("id", id))
user, err = r.Dbal.GetUserByEmail(ctx, id)
if err != nil {
r.Log.Debug("")
return Error{
Code: 403,
Message: "wrong username or/and password",
}, err
}
token, err := r.Auth.GenerateToken(user.ID)
if err != nil {
r.Log.Error("cannot generate token", zap.String("user_id", user.ID), zap.Error(err))
return Error{
Code: 13,
Message: "internal error",
}, err
}
r.Log.Info("user successfully authenticated, token returned", zap.String("email", user.Email))
return Token{
Username: user.Email,
Token: token,
UserID: user.ID,
}, nil
}
// Mutation returns MutationResolver implementation.
func (r *Resolver) Mutation() MutationResolver { return &mutationResolver{r} }
// Query returns QueryResolver implementation.
func (r *Resolver) Query() QueryResolver { return &queryResolver{r} }
type mutationResolver struct{ *Resolver }
type queryResolver struct{ *Resolver }