BlueGit

timfa bluegit

Files

bluegit / internal / server / issues.go

issues.go

feat: lees .bluegit-sjablonen en klikbare takenlijsten
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
79722e46 History
issues.go 21.7 KiB Download Raw
1package server
2
3import (
4 "context"
5 "html/template"
6 "net/http"
7 "regexp"
8 "sort"
9 "strconv"
10 "strings"
11
12 "gitlab.com/Timfa/bluegit/internal/access"
13 "gitlab.com/Timfa/bluegit/internal/gitrepo"
14 "gitlab.com/Timfa/bluegit/internal/i18n"
15 "gitlab.com/Timfa/bluegit/internal/markdown"
16 "gitlab.com/Timfa/bluegit/internal/store"
17 "gitlab.com/Timfa/bluegit/internal/webhook"
18)
19
20// IssueBoard is de gegevensset voor de issuepagina's.
21type IssueBoard struct {
22 List []IssueRow
23 One *IssueRow
24 Notes []IssueNoteRow
25 Labels []IssueChoice
26 Milestones []store.Milestone
27 People []IssueChoice
28 State string
29 Query string
30 Label string
31 Assignee string
32 Milestone string
33 Due string
34 FormTitle string
35 FormBody string
36 Confidential bool
37 CanCreate bool
38 CanTriage bool
39 CanEdit bool
40 CanClose bool
41 CanReopen bool
42 CanDelete bool
43 Relate int64
44 Related []IssueRow
45 Tpls []string
46 Tpl string
47}
48
49// IssueChoice is een label of persoon in een formulier.
50type IssueChoice struct {
51 Name string
52 Color string
53 On bool
54}
55
56// IssueRow is één issue in een lijst of op de detailpagina.
57type IssueRow struct {
58 Number int64
59 Title string
60 Status string
61 Author string
62 Confidential bool
63 Milestone string
64 Due string
65 When string
66 Assignees string
67 Labels []store.Label
68 HTML template.HTML
69}
70
71// IssueNoteRow is een gerenderde reactie.
72type IssueNoteRow struct {
73 Author string
74 When string
75 HTML template.HTML
76}
77
78var (
79 closeIssueRe = regexp.MustCompile(`(?i)(?:^|[\s:])((?:close[sd]?|fix(?:e[sd])?|resolve[sd]?|implement(?:s|ed)?))\s+#(\d+)\b`)
80 fenceRe = regexp.MustCompile("(?s)```.*?```")
81 inlineCodeRe = regexp.MustCompile("`[^`\n]*`")
82)
83
84func (s *Server) issuesPage(w http.ResponseWriter, r *http.Request) {
85 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
86 if !ok {
87 return
88 }
89 v := s.repoView(w, r, repo, role, "tab.issues")
90 v.Title = s.tr(r, "tab.issues")
91 v.Page = "issues"
92 v.Wide = true
93 b := s.issueBoard(r, repo, role, u)
94 state := r.URL.Query().Get("state")
95 if state != "closed" && state != "all" {
96 state = "open"
97 }
98 b.State = state
99 b.Query = strings.TrimSpace(r.URL.Query().Get("q"))
100 b.Label = strings.TrimSpace(r.URL.Query().Get("label"))
101 b.Assignee = strings.TrimSpace(r.URL.Query().Get("assignee"))
102 list, err := s.Store.ListIssues(r.Context(), repo.ID, store.IssueFilter{
103 State: b.State, Query: b.Query, Label: b.Label, Assignee: b.Assignee,
104 ViewerID: u.ID, Triage: role.CanTriageIssue(),
105 })
106 if err != nil {
107 s.fail(w, r, err)
108 return
109 }
110 for _, iss := range list {
111 b.List = append(b.List, s.issueRow(r, repo, iss))
112 }
113 v.Issues = b
114 s.render(w, "issues", v)
115}
116
117func (s *Server) newIssue(w http.ResponseWriter, r *http.Request) {
118 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
119 if !ok {
120 return
121 }
122 if u.ID == 0 || !role.CanCreateIssue() {
123 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
124 return
125 }
126 v := s.repoView(w, r, repo, role, "issue.new")
127 v.Title = s.tr(r, "issue.new")
128 v.Page = "issuenew"
129 v.Wide = true
130 b := s.issueBoard(r, repo, role, u)
131 s.prefillIssue(r, repo, u, role, b)
132 s.fillTpl(r, repo, "issue", &b.FormBody, &b.Tpl, &b.Tpls)
133 v.Issues = b
134 s.render(w, "issuenew", v)
135}
136
137func (s *Server) createIssue(w http.ResponseWriter, r *http.Request) {
138 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
139 if !ok || !s.csrfOK(w, r) {
140 return
141 }
142 back := repoURL(repo) + "/-/issues/new"
143 if u.ID == 0 || !role.CanCreateIssue() {
144 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
145 return
146 }
147 in := store.NewIssue{
148 Title: r.FormValue("title"),
149 Description: r.FormValue("description"),
150 Confidential: r.FormValue("confidential") == "1",
151 }
152 base := quickBase{Confidential: in.Confidential}
153 if triagePosted(r) {
154 if !role.CanTriageIssue() {
155 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
156 return
157 }
158 var err error
159 in.LabelIDs, in.AssigneeIDs, in.MilestoneID, in.DueOn, err = s.triageInput(r, repo)
160 if err != nil {
161 s.redirect(w, r, back, "", s.trErr(r, err))
162 return
163 }
164 base.Labels = r.Form["label"]
165 base.Assignees = r.Form["assignee"]
166 base.Milestone = r.FormValue("milestone")
167 base.Due = in.DueOn
168 }
169 q, err := s.foldQuick(r.Context(), repo, in.Description, role.CanTriageIssue(), true, base)
170 if err != nil {
171 s.redirect(w, r, back, "", s.trErr(r, err))
172 return
173 }
174 in.Description = q.Body
175 if q.Labels {
176 in.LabelIDs = q.LabelIDs
177 }
178 if q.Assignees {
179 in.AssigneeIDs = q.AssigneeIDs
180 }
181 if q.Meta {
182 in.MilestoneID = q.MilestoneID
183 in.DueOn = q.Due
184 in.Confidential = q.Confidential
185 }
186 iss, err := s.Store.CreateIssue(r.Context(), repo.ID, u.ID, in)
187 if err != nil {
188 s.redirect(w, r, back, "", s.trErr(r, err))
189 return
190 }
191 if rel, _ := strconv.ParseInt(r.FormValue("relate"), 10, 64); rel > 0 {
192 if other, err := s.Store.IssueByNumber(r.Context(), repo.ID, rel); err == nil && issueVisible(other, u, role) {
193 _ = s.Store.LinkIssues(r.Context(), repo.ID, iss.ID, other.ID)
194 }
195 }
196 s.issueHook(repo, iss.Number, u.Username, "opened", "")
197 s.redirect(w, r, issuePath(repo, iss.Number), s.tr(r, "flash.issueCreated"), "")
198}
199
200func (s *Server) showIssue(w http.ResponseWriter, r *http.Request) {
201 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
202 if !ok {
203 return
204 }
205 iss, ok := s.loadVisibleIssue(w, r, repo, u, role)
206 if !ok {
207 return
208 }
209 v := s.repoView(w, r, repo, role, "#"+strconv.FormatInt(iss.Number, 10))
210 v.Title = "#" + strconv.FormatInt(iss.Number, 10) + " " + iss.Title
211 v.Page = "issue"
212 v.Wide = true
213 b := s.issueBoard(r, repo, role, u)
214 row := s.issueRow(r, repo, iss)
215 canText := u.ID != 0 && (u.ID == iss.AuthorID || role.CanTriageIssue())
216 row.HTML = template.HTML(markdown.RenderTasks(iss.Description, "", "", "/"+repo.FullPath(), s.taskOpt(r, v.CSRF, repo, "issue", strconv.FormatInt(iss.Number, 10), canText)))
217 b.One = &row
218 b.Confidential = iss.Confidential
219 b.Milestone = iss.Milestone
220 b.Due = iss.DueOn
221 b.FormTitle = iss.Title
222 b.FormBody = iss.Description
223 b.CanEdit = u.ID != 0 && (u.ID == iss.AuthorID || role.CanTriageIssue())
224 b.CanClose = iss.Status == "open" && b.CanEdit
225 b.CanReopen = iss.Status == "closed" && b.CanEdit
226 b.Labels = markChoices(b.Labels, labelNames(iss.Labels))
227 b.People = markChoices(b.People, iss.Assignees)
228 notes, _ := s.Store.ListIssueNotes(r.Context(), iss.ID)
229 for _, n := range notes {
230 b.Notes = append(b.Notes, IssueNoteRow{
231 Author: n.Author,
232 When: i18n.FormatDate(s.langOf(r), n.CreatedAt),
233 HTML: template.HTML(markdown.RenderTasks(n.Body, "", "", "/"+repo.FullPath(), s.taskOpt(r, v.CSRF, repo, "issue-note", strconv.FormatInt(n.ID, 10), u.ID != 0 && u.ID == n.AuthorID))),
234 })
235 }
236 related, _ := s.Store.RelatedIssues(r.Context(), repo.ID, iss.ID)
237 for _, other := range related {
238 if issueVisible(other, u, role) {
239 b.Related = append(b.Related, s.issueRow(r, repo, other))
240 }
241 }
242 v.Issues = b
243 s.render(w, "issue", v)
244}
245
246func (s *Server) postIssue(w http.ResponseWriter, r *http.Request) {
247 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
248 if !ok || !s.csrfOK(w, r) {
249 return
250 }
251 iss, ok := s.loadVisibleIssue(w, r, repo, u, role)
252 if !ok {
253 return
254 }
255 back := issuePath(repo, iss.Number)
256 if u.ID == 0 {
257 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
258 return
259 }
260 switch r.FormValue("action") {
261 case "note":
262 if !role.CanCreateIssue() {
263 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
264 return
265 }
266 q, err := s.foldQuick(r.Context(), repo, r.FormValue("body"), role.CanTriageIssue(), false, quickFromIssue(iss))
267 if err != nil {
268 s.redirect(w, r, back, "", s.trErr(r, err))
269 return
270 }
271 if err := s.persistQuick(r.Context(), repo, iss.ID, q); err != nil {
272 s.redirect(w, r, back, "", s.trErr(r, err))
273 return
274 }
275 if strings.TrimSpace(q.Body) == "" {
276 if !q.touched() {
277 s.redirect(w, r, back, "", s.tr(r, "err.issueNote"))
278 return
279 }
280 s.issueHook(repo, iss.Number, u.Username, "updated", "")
281 s.redirect(w, r, back, s.tr(r, "flash.issueUpdated"), "")
282 return
283 }
284 if _, err := s.Store.AddIssueNote(r.Context(), repo.ID, iss.ID, u.ID, q.Body); err != nil {
285 s.redirect(w, r, back, "", s.trErr(r, err))
286 return
287 }
288 s.issueHook(repo, iss.Number, u.Username, "commented", strings.TrimSpace(q.Body))
289 s.redirect(w, r, back, s.tr(r, "flash.note"), "")
290 case "close", "reopen":
291 if u.ID != iss.AuthorID && !role.CanTriageIssue() {
292 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
293 return
294 }
295 status := "closed"
296 flash := "flash.issueClosed"
297 action := "closed"
298 if r.FormValue("action") == "reopen" {
299 status, flash, action = "open", "flash.issueReopened", "reopened"
300 }
301 changed, err := s.Store.SetIssueState(r.Context(), iss.ID, status)
302 if err != nil {
303 s.redirect(w, r, back, "", s.trErr(r, err))
304 return
305 }
306 if changed {
307 s.issueHook(repo, iss.Number, u.Username, action, "")
308 }
309 s.redirect(w, r, back, s.tr(r, flash), "")
310 case "update":
311 if u.ID != iss.AuthorID && !role.CanTriageIssue() {
312 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
313 return
314 }
315 q, err := s.foldQuick(r.Context(), repo, r.FormValue("description"), role.CanTriageIssue(), false, quickFromIssue(iss))
316 if err != nil {
317 s.redirect(w, r, back, "", s.trErr(r, err))
318 return
319 }
320 if err := s.Store.UpdateIssueText(r.Context(), iss.ID, r.FormValue("title"), q.Body); err != nil {
321 s.redirect(w, r, back, "", s.trErr(r, err))
322 return
323 }
324 if err := s.persistQuick(r.Context(), repo, iss.ID, q); err != nil {
325 s.redirect(w, r, back, "", s.trErr(r, err))
326 return
327 }
328 s.issueHook(repo, iss.Number, u.Username, "updated", "")
329 s.redirect(w, r, back, s.tr(r, "flash.issueUpdated"), "")
330 case "meta":
331 if !role.CanTriageIssue() {
332 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
333 return
334 }
335 labels, assignees, milestoneID, due, err := s.triageInput(r, repo)
336 if err != nil {
337 s.redirect(w, r, back, "", s.trErr(r, err))
338 return
339 }
340 if err := s.Store.SetIssueLabels(r.Context(), repo.ID, iss.ID, labels); err != nil {
341 s.redirect(w, r, back, "", s.trErr(r, err))
342 return
343 }
344 if err := s.Store.SetIssueAssignees(r.Context(), repo.ID, iss.ID, assignees); err != nil {
345 s.redirect(w, r, back, "", s.trErr(r, err))
346 return
347 }
348 if err := s.Store.SetIssueMeta(r.Context(), repo.ID, iss.ID, milestoneID, r.FormValue("confidential") == "1", due); err != nil {
349 s.redirect(w, r, back, "", s.trErr(r, err))
350 return
351 }
352 s.issueHook(repo, iss.Number, u.Username, "updated", "")
353 s.redirect(w, r, back, s.tr(r, "flash.issueUpdated"), "")
354 case "delete":
355 if !role.CanManageSettings() {
356 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
357 return
358 }
359 if err := s.Store.DeleteIssue(r.Context(), repo.ID, iss.ID); err != nil {
360 s.redirect(w, r, back, "", s.trErr(r, err))
361 return
362 }
363 s.redirect(w, r, repoURL(repo)+"/-/issues", s.tr(r, "flash.issueDeleted"), "")
364 default:
365 http.Error(w, s.tr(r, "err.badForm"), http.StatusBadRequest)
366 }
367}
368
369func (s *Server) createIssueLabel(w http.ResponseWriter, r *http.Request) {
370 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
371 if !ok || !s.csrfOK(w, r) {
372 return
373 }
374 if u.ID == 0 || !role.CanManageSettings() {
375 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
376 return
377 }
378 back := repoURL(repo) + "/-/issues"
379 if _, err := s.Store.UpsertLabel(r.Context(), repo.ID, r.FormValue("name"), r.FormValue("color")); err != nil {
380 s.redirect(w, r, back, "", s.trErr(r, err))
381 return
382 }
383 s.redirect(w, r, back, s.tr(r, "flash.label"), "")
384}
385
386func (s *Server) createIssueMilestone(w http.ResponseWriter, r *http.Request) {
387 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
388 if !ok || !s.csrfOK(w, r) {
389 return
390 }
391 if u.ID == 0 || !role.CanManageSettings() {
392 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
393 return
394 }
395 back := repoURL(repo) + "/-/issues"
396 if _, err := s.Store.UpsertMilestone(r.Context(), repo.ID, r.FormValue("title"), r.FormValue("due_on")); err != nil {
397 s.redirect(w, r, back, "", s.trErr(r, err))
398 return
399 }
400 s.redirect(w, r, back, s.tr(r, "flash.milestone"), "")
401}
402
403func (s *Server) loadVisibleIssue(w http.ResponseWriter, r *http.Request, repo store.Repo, u store.User, role access.Role) (store.Issue, bool) {
404 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
405 if err != nil || n < 1 {
406 http.NotFound(w, r)
407 return store.Issue{}, false
408 }
409 iss, err := s.Store.IssueByNumber(r.Context(), repo.ID, n)
410 if err != nil || !issueVisible(iss, u, role) {
411 http.NotFound(w, r)
412 return store.Issue{}, false
413 }
414 return iss, true
415}
416
417func (s *Server) issueBoard(r *http.Request, repo store.Repo, role access.Role, u store.User) *IssueBoard {
418 labels, _ := s.Store.ListLabels(r.Context(), repo.ID)
419 miles, _ := s.Store.ListMilestones(r.Context(), repo.ID)
420 b := &IssueBoard{
421 Labels: []IssueChoice{},
422 Milestones: miles,
423 People: []IssueChoice{},
424 CanCreate: u.ID != 0 && role.CanCreateIssue(),
425 CanTriage: role.CanTriageIssue(),
426 CanDelete: role.CanManageSettings(),
427 }
428 if b.Milestones == nil {
429 b.Milestones = []store.Milestone{}
430 }
431 for _, l := range labels {
432 b.Labels = append(b.Labels, IssueChoice{Name: l.Name, Color: l.Color})
433 }
434 for _, p := range s.issueCandidates(r.Context(), repo) {
435 b.People = append(b.People, IssueChoice{Name: p.Username})
436 }
437 return b
438}
439
440func (s *Server) issueRow(r *http.Request, repo store.Repo, iss store.Issue) IssueRow {
441 return IssueRow{
442 Number: iss.Number, Title: iss.Title, Status: iss.Status, Author: iss.Author,
443 Confidential: iss.Confidential, Milestone: iss.Milestone, Due: iss.DueOn,
444 When: i18n.FormatDate(s.langOf(r), iss.CreatedAt), Assignees: strings.Join(iss.Assignees, ", "),
445 Labels: iss.Labels, HTML: template.HTML(markdown.Render(iss.Description, "", "", "/"+repo.FullPath())),
446 }
447}
448
449func (s *Server) prefillIssue(r *http.Request, repo store.Repo, u store.User, role access.Role, b *IssueBoard) {
450 if rel, err := strconv.ParseInt(r.URL.Query().Get("relate"), 10, 64); err == nil && rel > 0 {
451 if iss, err := s.Store.IssueByNumber(r.Context(), repo.ID, rel); err == nil && issueVisible(iss, u, role) {
452 b.Relate = rel
453 }
454 }
455 if r.URL.Query().Get("from") != "mr" {
456 return
457 }
458 n, err := strconv.ParseInt(r.URL.Query().Get("mr"), 10, 64)
459 if err != nil || n < 1 {
460 return
461 }
462 mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)
463 if err != nil {
464 return
465 }
466 ref := "!" + strconv.FormatInt(n, 10)
467 b.FormBody = ref
468 noteID, _ := strconv.ParseInt(r.URL.Query().Get("note"), 10, 64)
469 if noteID == 0 {
470 return
471 }
472 notes, err := s.Store.ListNotes(r.Context(), mr.ID)
473 if err != nil {
474 return
475 }
476 for _, note := range notes {
477 if note.ID == noteID {
478 b.FormBody = strings.TrimSpace(note.Body) + "\n\n" + ref
479 return
480 }
481 }
482}
483
484func (s *Server) issueCandidates(ctx context.Context, repo store.Repo) []store.Member {
485 seen := map[string]store.Member{}
486 add := func(list []store.Member) {
487 for _, m := range list {
488 if m.Pending || m.UserID == 0 || m.Username == "" {
489 continue
490 }
491 seen[m.Username] = m
492 }
493 }
494 if repo.OwnerKind == "user" {
495 if u, err := s.Store.UserByID(ctx, repo.OwnerID); err == nil {
496 seen[u.Username] = store.Member{UserID: u.ID, Username: u.Username, Role: access.RoleMaintainer}
497 }
498 }
499 if members, err := s.Store.ListMembers(ctx, "repo", repo.ID); err == nil {
500 add(members)
501 }
502 if repo.OwnerKind == "group" {
503 if members, err := s.Store.ListMembers(ctx, "group", repo.OwnerID); err == nil {
504 add(members)
505 }
506 }
507 out := make([]store.Member, 0, len(seen))
508 for _, m := range seen {
509 out = append(out, m)
510 }
511 sort.Slice(out, func(i, j int) bool { return out[i].Username < out[j].Username })
512 return out
513}
514
515func (s *Server) triageInput(r *http.Request, repo store.Repo) (labels, assignees []int64, milestoneID int64, due string, err error) {
516 labels, err = s.resolveLabels(r.Context(), repo.ID, r.Form["label"])
517 if err != nil {
518 return nil, nil, 0, "", err
519 }
520 assignees, err = s.resolveAssignees(r.Context(), repo, r.Form["assignee"])
521 if err != nil {
522 return nil, nil, 0, "", err
523 }
524 milestoneID, err = s.resolveMilestone(r.Context(), repo.ID, r.FormValue("milestone"))
525 if err != nil {
526 return nil, nil, 0, "", err
527 }
528 due = strings.TrimSpace(r.FormValue("due_on"))
529 if err := store.ValidDue(due); err != nil {
530 return nil, nil, 0, "", err
531 }
532 return labels, assignees, milestoneID, due, nil
533}
534
535func (s *Server) resolveLabels(ctx context.Context, repoID int64, names []string) ([]int64, error) {
536 ids := []int64{}
537 seen := map[int64]bool{}
538 for _, name := range names {
539 name = strings.TrimSpace(name)
540 if name == "" {
541 continue
542 }
543 if err := store.ValidLabelName(name); err != nil {
544 return nil, err
545 }
546 lab, err := s.Store.LabelByName(ctx, repoID, name)
547 if err != nil {
548 return nil, i18n.E("err.labelMissing", name)
549 }
550 if seen[lab.ID] {
551 continue
552 }
553 seen[lab.ID] = true
554 ids = append(ids, lab.ID)
555 }
556 return ids, nil
557}
558
559func (s *Server) resolveAssignees(ctx context.Context, repo store.Repo, names []string) ([]int64, error) {
560 cand := map[string]int64{}
561 for _, m := range s.issueCandidates(ctx, repo) {
562 cand[m.Username] = m.UserID
563 }
564 ids := []int64{}
565 seen := map[int64]bool{}
566 for _, name := range names {
567 name = strings.ToLower(strings.TrimSpace(strings.TrimPrefix(name, "@")))
568 if name == "" {
569 continue
570 }
571 id, ok := cand[name]
572 if !ok {
573 return nil, i18n.E("err.assignee", name)
574 }
575 if seen[id] {
576 continue
577 }
578 seen[id] = true
579 ids = append(ids, id)
580 }
581 return ids, nil
582}
583
584func (s *Server) resolveMilestone(ctx context.Context, repoID int64, title string) (int64, error) {
585 title = strings.TrimSpace(title)
586 if title == "" {
587 return 0, nil
588 }
589 m, err := s.Store.MilestoneByTitle(ctx, repoID, title)
590 if err != nil {
591 return 0, i18n.E("err.milestone")
592 }
593 return m.ID, nil
594}
595
596func (s *Server) issueHook(repo store.Repo, number int64, actor, action, comment string) {
597 if s.Store == nil {
598 return
599 }
600 iss, err := s.Store.IssueByNumber(context.Background(), repo.ID, number)
601 if err != nil {
602 return
603 }
604 num := strconv.FormatInt(iss.Number, 10)
605 page := strings.TrimRight(s.Cfg.BaseURL, "/") + issuePath(repo, iss.Number)
606 key := "hook.issueOpened"
607 switch action {
608 case "updated":
609 key = "hook.issueUpdated"
610 case "closed":
611 key = "hook.issueClosed"
612 case "reopened":
613 key = "hook.issueReopened"
614 case "commented":
615 key = "hook.issueComment"
616 }
617 summary := i18n.T(i18n.EN, key, num)
618 if action != "commented" {
619 summary = i18n.T(i18n.EN, key, num, iss.Title)
620 }
621 s.Dispatch(repo.ID, webhook.Event{
622 Type: webhook.EventIssue, Project: repo.FullPath(), Actor: actor,
623 Summary: summary, URL: page, Comment: comment,
624 Issue: &webhook.IssueInfo{
625 ID: iss.Number, Title: iss.Title, Description: iss.Description,
626 Status: iss.Status, Confidential: iss.Confidential, Author: iss.Author,
627 Assignees: iss.Assignees, Labels: labelNames(iss.Labels),
628 Milestone: iss.Milestone, DueDate: iss.DueOn, Action: action, URL: page,
629 },
630 })
631}
632
633func (s *Server) closeIssueNumbers(ctx context.Context, repo store.Repo, actor store.User, numbers []int64) {
634 if s.Store == nil {
635 return
636 }
637 for _, n := range numbers {
638 iss, err := s.Store.IssueByNumber(ctx, repo.ID, n)
639 if err != nil || iss.Status == "closed" {
640 continue
641 }
642 changed, err := s.Store.SetIssueState(ctx, iss.ID, "closed")
643 if err != nil || !changed {
644 continue
645 }
646 s.issueHook(repo, n, actor.Username, "closed", "")
647 }
648}
649
650func (s *Server) mergeCloseTexts(r *http.Request, repo store.Repo, mr store.MergeRequest) []string {
651 texts := []string{mr.Description}
652 if s.StoragePath() == "" {
653 return texts
654 }
655 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
656 commits, err := gitrepo.RangeLog(r.Context(), s.Git, dir, mr.TargetBranch, mr.SourceBranch)
657 if err != nil {
658 return texts
659 }
660 for i, c := range commits {
661 if i >= 50 {
662 break
663 }
664 texts = append(texts, commitText(c))
665 }
666 return texts
667}
668
669func (s *Server) closeIssuesOnPush(repo store.Repo, user store.User, before, after string) {
670 if s.Store == nil || s.StoragePath() == "" {
671 return
672 }
673 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
674 commits, err := gitrepo.RangeLog(context.Background(), s.Git, dir, before, after)
675 if err != nil {
676 return
677 }
678 var texts []string
679 for i, c := range commits {
680 if i >= 50 {
681 break
682 }
683 texts = append(texts, commitText(c))
684 }
685 s.closeIssueNumbers(context.Background(), repo, user, closingNumbers(texts...))
686}
687
688func closingNumbers(texts ...string) []int64 {
689 seen := map[int64]bool{}
690 var out []int64
691 for _, text := range texts {
692 text = fenceRe.ReplaceAllString(text, " ")
693 text = inlineCodeRe.ReplaceAllString(text, " ")
694 for _, m := range closeIssueRe.FindAllStringSubmatch(text, -1) {
695 n, err := strconv.ParseInt(m[2], 10, 64)
696 if err != nil || n < 1 || seen[n] {
697 continue
698 }
699 seen[n] = true
700 out = append(out, n)
701 }
702 }
703 return out
704}
705
706func issueVisible(iss store.Issue, u store.User, role access.Role) bool {
707 if !iss.Confidential {
708 return true
709 }
710 if role.CanTriageIssue() {
711 return true
712 }
713 return u.ID != 0 && u.ID == iss.AuthorID
714}
715
716func triagePosted(r *http.Request) bool {
717 if r.Form == nil {
718 return false
719 }
720 _, label := r.Form["label"]
721 _, assignee := r.Form["assignee"]
722 _, milestone := r.Form["milestone"]
723 _, due := r.Form["due_on"]
724 return label || assignee || milestone || due
725}
726
727func markChoices(list []IssueChoice, selected []string) []IssueChoice {
728 on := map[string]bool{}
729 for _, name := range selected {
730 on[name] = true
731 }
732 for i := range list {
733 list[i].On = on[list[i].Name]
734 }
735 return list
736}
737
738func labelNames(labels []store.Label) []string {
739 out := []string{}
740 for _, l := range labels {
741 out = append(out, l.Name)
742 }
743 return out
744}
745
746func issuePath(repo store.Repo, n int64) string {
747 return repoURL(repo) + "/-/issues/" + strconv.FormatInt(n, 10)
748}
749
750func (s *Server) fail(w http.ResponseWriter, r *http.Request, err error) {
751 http.Error(w, s.trErr(r, err), http.StatusInternalServerError)
752}