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/bug"
11 "github.com/MichaelMure/git-bug/cache"
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) EditComment(ctx context.Context, input models.EditCommentInput) (*models.EditCommentPayload, 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 op, err := b.EditCommentRaw(
153 author,
154 time.Now().Unix(),
155 entity.Id(input.Target),
156 text.Cleanup(input.Message),
157 nil,
158 )
159 if err != nil {
160 return nil, err
161 }
162
163 err = b.Commit()
164 if err != nil {
165 return nil, err
166 }
167
168 return &models.EditCommentPayload{
169 ClientMutationID: input.ClientMutationID,
170 Bug: models.NewLoadedBug(b.Snapshot()),
171 Operation: op,
172 }, nil
173}
174
175func (r mutationResolver) ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error) {
176 repo, b, err := r.getBug(input.RepoRef, input.Prefix)
177 if err != nil {
178 return nil, err
179 }
180
181 author, err := auth.UserFromCtx(ctx, repo)
182 if err != nil {
183 return nil, err
184 }
185
186 results, op, err := b.ChangeLabelsRaw(
187 author,
188 time.Now().Unix(),
189 text.CleanupOneLineArray(input.Added),
190 text.CleanupOneLineArray(input.Removed),
191 nil,
192 )
193 if err != nil {
194 return nil, err
195 }
196
197 err = b.Commit()
198 if err != nil {
199 return nil, err
200 }
201
202 resultsPtr := make([]*bug.LabelChangeResult, len(results))
203 for i, result := range results {
204 resultsPtr[i] = &result
205 }
206
207 return &models.ChangeLabelPayload{
208 ClientMutationID: input.ClientMutationID,
209 Bug: models.NewLoadedBug(b.Snapshot()),
210 Operation: op,
211 Results: resultsPtr,
212 }, nil
213}
214
215func (r mutationResolver) OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error) {
216 repo, b, err := r.getBug(input.RepoRef, input.Prefix)
217 if err != nil {
218 return nil, err
219 }
220
221 author, err := auth.UserFromCtx(ctx, repo)
222 if err != nil {
223 return nil, err
224 }
225
226 op, err := b.OpenRaw(author, time.Now().Unix(), nil)
227 if err != nil {
228 return nil, err
229 }
230
231 err = b.Commit()
232 if err != nil {
233 return nil, err
234 }
235
236 return &models.OpenBugPayload{
237 ClientMutationID: input.ClientMutationID,
238 Bug: models.NewLoadedBug(b.Snapshot()),
239 Operation: op,
240 }, nil
241}
242
243func (r mutationResolver) CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error) {
244 repo, b, err := r.getBug(input.RepoRef, input.Prefix)
245 if err != nil {
246 return nil, err
247 }
248
249 author, err := auth.UserFromCtx(ctx, repo)
250 if err != nil {
251 return nil, err
252 }
253
254 op, err := b.CloseRaw(author, time.Now().Unix(), nil)
255 if err != nil {
256 return nil, err
257 }
258
259 err = b.Commit()
260 if err != nil {
261 return nil, err
262 }
263
264 return &models.CloseBugPayload{
265 ClientMutationID: input.ClientMutationID,
266 Bug: models.NewLoadedBug(b.Snapshot()),
267 Operation: op,
268 }, nil
269}
270
271func (r mutationResolver) SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error) {
272 repo, b, err := r.getBug(input.RepoRef, input.Prefix)
273 if err != nil {
274 return nil, err
275 }
276
277 author, err := auth.UserFromCtx(ctx, repo)
278 if err != nil {
279 return nil, err
280 }
281
282 op, err := b.SetTitleRaw(
283 author,
284 time.Now().Unix(),
285 text.CleanupOneLine(input.Title),
286 nil,
287 )
288 if err != nil {
289 return nil, err
290 }
291
292 err = b.Commit()
293 if err != nil {
294 return nil, err
295 }
296
297 return &models.SetTitlePayload{
298 ClientMutationID: input.ClientMutationID,
299 Bug: models.NewLoadedBug(b.Snapshot()),
300 Operation: op,
301 }, nil
302}