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