1package resolvers
2
3import (
4 "context"
5 "time"
6
7 "github.com/MichaelMure/git-bug/api/auth"
8 "github.com/MichaelMure/git-bug/api/graphql/graph"
9 "github.com/MichaelMure/git-bug/api/graphql/models"
10 "github.com/MichaelMure/git-bug/cache"
11 "github.com/MichaelMure/git-bug/entities/bug"
12 "github.com/MichaelMure/git-bug/entity"
13 "github.com/MichaelMure/git-bug/util/text"
14)
15
16var _ graph.MutationResolver = &mutationResolver{}
17
18type mutationResolver struct {
19 cache *cache.MultiRepoCache
20}
21
22func (r mutationResolver) getRepo(ref *string) (*cache.RepoCache, error) {
23 if ref != nil {
24 return r.cache.ResolveRepo(*ref)
25 }
26
27 return r.cache.DefaultRepo()
28}
29
30func (r mutationResolver) getBug(repoRef *string, bugPrefix string) (*cache.RepoCache, *cache.BugCache, error) {
31 repo, err := r.getRepo(repoRef)
32 if err != nil {
33 return nil, nil, err
34 }
35
36 b, err := repo.ResolveBugPrefix(bugPrefix)
37 if err != nil {
38 return nil, nil, err
39 }
40 return repo, b, nil
41}
42
43func (r mutationResolver) NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error) {
44 repo, err := r.getRepo(input.RepoRef)
45 if err != nil {
46 return nil, err
47 }
48
49 author, err := auth.UserFromCtx(ctx, repo)
50 if err != nil {
51 return nil, err
52 }
53
54 b, op, err := repo.NewBugRaw(author,
55 time.Now().Unix(),
56 text.CleanupOneLine(input.Title),
57 text.Cleanup(input.Message),
58 input.Files,
59 nil)
60 if err != nil {
61 return nil, err
62 }
63
64 return &models.NewBugPayload{
65 ClientMutationID: input.ClientMutationID,
66 Bug: models.NewLoadedBug(b.Snapshot()),
67 Operation: op,
68 }, nil
69}
70
71func (r mutationResolver) AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error) {
72 repo, b, err := r.getBug(input.RepoRef, input.Prefix)
73 if err != nil {
74 return nil, err
75 }
76
77 author, err := auth.UserFromCtx(ctx, repo)
78 if err != nil {
79 return nil, err
80 }
81
82 op, err := b.AddCommentRaw(author,
83 time.Now().Unix(),
84 text.Cleanup(input.Message),
85 input.Files,
86 nil)
87 if err != nil {
88 return nil, err
89 }
90
91 err = b.Commit()
92 if err != nil {
93 return nil, err
94 }
95
96 return &models.AddCommentPayload{
97 ClientMutationID: input.ClientMutationID,
98 Bug: models.NewLoadedBug(b.Snapshot()),
99 Operation: op,
100 }, nil
101}
102
103func (r mutationResolver) AddCommentAndClose(ctx context.Context, input models.AddCommentAndCloseBugInput) (*models.AddCommentAndCloseBugPayload, error) {
104 repo, b, err := r.getBug(input.RepoRef, input.Prefix)
105 if err != nil {
106 return nil, err
107 }
108
109 author, err := auth.UserFromCtx(ctx, repo)
110 if err != nil {
111 return nil, err
112 }
113
114 opAddComment, err := b.AddCommentRaw(author,
115 time.Now().Unix(),
116 text.Cleanup(input.Message),
117 input.Files,
118 nil)
119 if err != nil {
120 return nil, err
121 }
122
123 opClose, err := b.CloseRaw(author, time.Now().Unix(), nil)
124 if err != nil {
125 return nil, err
126 }
127
128 err = b.Commit()
129 if err != nil {
130 return nil, err
131 }
132
133 return &models.AddCommentAndCloseBugPayload{
134 ClientMutationID: input.ClientMutationID,
135 Bug: models.NewLoadedBug(b.Snapshot()),
136 CommentOperation: opAddComment,
137 StatusOperation: opClose,
138 }, nil
139}
140
141func (r mutationResolver) AddCommentAndReopen(ctx context.Context, input models.AddCommentAndReopenBugInput) (*models.AddCommentAndReopenBugPayload, error) {
142 repo, b, err := r.getBug(input.RepoRef, input.Prefix)
143 if err != nil {
144 return nil, err
145 }
146
147 author, err := auth.UserFromCtx(ctx, repo)
148 if err != nil {
149 return nil, err
150 }
151
152 opAddComment, err := b.AddCommentRaw(author,
153 time.Now().Unix(),
154 text.Cleanup(input.Message),
155 input.Files,
156 nil)
157 if err != nil {
158 return nil, err
159 }
160
161 opReopen, err := b.OpenRaw(author, time.Now().Unix(), nil)
162 if err != nil {
163 return nil, err
164 }
165
166 err = b.Commit()
167 if err != nil {
168 return nil, err
169 }
170
171 return &models.AddCommentAndReopenBugPayload{
172 ClientMutationID: input.ClientMutationID,
173 Bug: models.NewLoadedBug(b.Snapshot()),
174 CommentOperation: opAddComment,
175 StatusOperation: opReopen,
176 }, nil
177}
178
179func (r mutationResolver) EditComment(ctx context.Context, input models.EditCommentInput) (*models.EditCommentPayload, error) {
180 repo, b, err := r.getBug(input.RepoRef, input.Prefix)
181 if err != nil {
182 return nil, err
183 }
184
185 author, err := auth.UserFromCtx(ctx, repo)
186 if err != nil {
187 return nil, err
188 }
189
190 op, err := b.EditCommentRaw(
191 author,
192 time.Now().Unix(),
193 entity.Id(input.Target),
194 text.Cleanup(input.Message),
195 nil,
196 )
197 if err != nil {
198 return nil, err
199 }
200
201 err = b.Commit()
202 if err != nil {
203 return nil, err
204 }
205
206 return &models.EditCommentPayload{
207 ClientMutationID: input.ClientMutationID,
208 Bug: models.NewLoadedBug(b.Snapshot()),
209 Operation: op,
210 }, nil
211}
212
213func (r mutationResolver) ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error) {
214 repo, b, err := r.getBug(input.RepoRef, input.Prefix)
215 if err != nil {
216 return nil, err
217 }
218
219 author, err := auth.UserFromCtx(ctx, repo)
220 if err != nil {
221 return nil, err
222 }
223
224 results, op, err := b.ChangeLabelsRaw(
225 author,
226 time.Now().Unix(),
227 text.CleanupOneLineArray(input.Added),
228 text.CleanupOneLineArray(input.Removed),
229 nil,
230 )
231 if err != nil {
232 return nil, err
233 }
234
235 err = b.Commit()
236 if err != nil {
237 return nil, err
238 }
239
240 resultsPtr := make([]*bug.LabelChangeResult, len(results))
241 for i, result := range results {
242 resultsPtr[i] = &result
243 }
244
245 return &models.ChangeLabelPayload{
246 ClientMutationID: input.ClientMutationID,
247 Bug: models.NewLoadedBug(b.Snapshot()),
248 Operation: op,
249 Results: resultsPtr,
250 }, nil
251}
252
253func (r mutationResolver) OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error) {
254 repo, b, err := r.getBug(input.RepoRef, input.Prefix)
255 if err != nil {
256 return nil, err
257 }
258
259 author, err := auth.UserFromCtx(ctx, repo)
260 if err != nil {
261 return nil, err
262 }
263
264 op, err := b.OpenRaw(author, time.Now().Unix(), nil)
265 if err != nil {
266 return nil, err
267 }
268
269 err = b.Commit()
270 if err != nil {
271 return nil, err
272 }
273
274 return &models.OpenBugPayload{
275 ClientMutationID: input.ClientMutationID,
276 Bug: models.NewLoadedBug(b.Snapshot()),
277 Operation: op,
278 }, nil
279}
280
281func (r mutationResolver) CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error) {
282 repo, b, err := r.getBug(input.RepoRef, input.Prefix)
283 if err != nil {
284 return nil, err
285 }
286
287 author, err := auth.UserFromCtx(ctx, repo)
288 if err != nil {
289 return nil, err
290 }
291
292 op, err := b.CloseRaw(author, time.Now().Unix(), nil)
293 if err != nil {
294 return nil, err
295 }
296
297 err = b.Commit()
298 if err != nil {
299 return nil, err
300 }
301
302 return &models.CloseBugPayload{
303 ClientMutationID: input.ClientMutationID,
304 Bug: models.NewLoadedBug(b.Snapshot()),
305 Operation: op,
306 }, nil
307}
308
309func (r mutationResolver) SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error) {
310 repo, b, err := r.getBug(input.RepoRef, input.Prefix)
311 if err != nil {
312 return nil, err
313 }
314
315 author, err := auth.UserFromCtx(ctx, repo)
316 if err != nil {
317 return nil, err
318 }
319
320 op, err := b.SetTitleRaw(
321 author,
322 time.Now().Unix(),
323 text.CleanupOneLine(input.Title),
324 nil,
325 )
326 if err != nil {
327 return nil, err
328 }
329
330 err = b.Commit()
331 if err != nil {
332 return nil, err
333 }
334
335 return &models.SetTitlePayload{
336 ClientMutationID: input.ClientMutationID,
337 Bug: models.NewLoadedBug(b.Snapshot()),
338 Operation: op,
339 }, nil
340}