BlueGit

timfa bluegit

Files

bluegit / internal / server / issues.go

issues.go

feat: toon rijke linkkaarten voor openbare pagina's
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
0741fde9 History
issues.go 21.8 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 if err == nil && iss.Confidential && isCrawler(r) {
412 s.writeLockedCard(w, r)
413 } else {
414 http.NotFound(w, r)
415 }
416 return store.Issue{}, false
417 }
418 return iss, true
419}
420
421func (s *Server) issueBoard(r *http.Request, repo store.Repo, role access.Role, u store.User) *IssueBoard {
422 labels, _ := s.Store.ListLabels(r.Context(), repo.ID)
423 miles, _ := s.Store.ListMilestones(r.Context(), repo.ID)
424 b := &IssueBoard{
425 Labels: []IssueChoice{},
426 Milestones: miles,
427 People: []IssueChoice{},
428 CanCreate: u.ID != 0 && role.CanCreateIssue(),
429 CanTriage: role.CanTriageIssue(),
430 CanDelete: role.CanManageSettings(),
431 }
432 if b.Milestones == nil {
433 b.Milestones = []store.Milestone{}
434 }
435 for _, l := range labels {
436 b.Labels = append(b.Labels, IssueChoice{Name: l.Name, Color: l.Color})
437 }
438 for _, p := range s.issueCandidates(r.Context(), repo) {
439 b.People = append(b.People, IssueChoice{Name: p.Username})
440 }
441 return b
442}
443
444func (s *Server) issueRow(r *http.Request, repo store.Repo, iss store.Issue) IssueRow {
445 return IssueRow{
446 Number: iss.Number, Title: iss.Title, Status: iss.Status, Author: iss.Author,
447 Confidential: iss.Confidential, Milestone: iss.Milestone, Due: iss.DueOn,
448 When: i18n.FormatDate(s.langOf(r), iss.CreatedAt), Assignees: strings.Join(iss.Assignees, ", "),
449 Labels: iss.Labels, HTML: template.HTML(markdown.Render(iss.Description, "", "", "/"+repo.FullPath())),
450 }
451}
452
453func (s *Server) prefillIssue(r *http.Request, repo store.Repo, u store.User, role access.Role, b *IssueBoard) {
454 if rel, err := strconv.ParseInt(r.URL.Query().Get("relate"), 10, 64); err == nil && rel > 0 {
455 if iss, err := s.Store.IssueByNumber(r.Context(), repo.ID, rel); err == nil && issueVisible(iss, u, role) {
456 b.Relate = rel
457 }
458 }
459 if r.URL.Query().Get("from") != "mr" {
460 return
461 }
462 n, err := strconv.ParseInt(r.URL.Query().Get("mr"), 10, 64)
463 if err != nil || n < 1 {
464 return
465 }
466 mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)
467 if err != nil {
468 return
469 }
470 ref := "!" + strconv.FormatInt(n, 10)
471 b.FormBody = ref
472 noteID, _ := strconv.ParseInt(r.URL.Query().Get("note"), 10, 64)
473 if noteID == 0 {
474 return
475 }
476 notes, err := s.Store.ListNotes(r.Context(), mr.ID)
477 if err != nil {
478 return
479 }
480 for _, note := range notes {
481 if note.ID == noteID {
482 b.FormBody = strings.TrimSpace(note.Body) + "\n\n" + ref
483 return
484 }
485 }
486}
487
488func (s *Server) issueCandidates(ctx context.Context, repo store.Repo) []store.Member {
489 seen := map[string]store.Member{}
490 add := func(list []store.Member) {
491 for _, m := range list {
492 if m.Pending || m.UserID == 0 || m.Username == "" {
493 continue
494 }
495 seen[m.Username] = m
496 }
497 }
498 if repo.OwnerKind == "user" {
499 if u, err := s.Store.UserByID(ctx, repo.OwnerID); err == nil {
500 seen[u.Username] = store.Member{UserID: u.ID, Username: u.Username, Role: access.RoleMaintainer}
501 }
502 }
503 if members, err := s.Store.ListMembers(ctx, "repo", repo.ID); err == nil {
504 add(members)
505 }
506 if repo.OwnerKind == "group" {
507 if members, err := s.Store.ListMembers(ctx, "group", repo.OwnerID); err == nil {
508 add(members)
509 }
510 }
511 out := make([]store.Member, 0, len(seen))
512 for _, m := range seen {
513 out = append(out, m)
514 }
515 sort.Slice(out, func(i, j int) bool { return out[i].Username < out[j].Username })
516 return out
517}
518
519func (s *Server) triageInput(r *http.Request, repo store.Repo) (labels, assignees []int64, milestoneID int64, due string, err error) {
520 labels, err = s.resolveLabels(r.Context(), repo.ID, r.Form["label"])
521 if err != nil {
522 return nil, nil, 0, "", err
523 }
524 assignees, err = s.resolveAssignees(r.Context(), repo, r.Form["assignee"])
525 if err != nil {
526 return nil, nil, 0, "", err
527 }
528 milestoneID, err = s.resolveMilestone(r.Context(), repo.ID, r.FormValue("milestone"))
529 if err != nil {
530 return nil, nil, 0, "", err
531 }
532 due = strings.TrimSpace(r.FormValue("due_on"))
533 if err := store.ValidDue(due); err != nil {
534 return nil, nil, 0, "", err
535 }
536 return labels, assignees, milestoneID, due, nil
537}
538
539func (s *Server) resolveLabels(ctx context.Context, repoID int64, names []string) ([]int64, error) {
540 ids := []int64{}
541 seen := map[int64]bool{}
542 for _, name := range names {
543 name = strings.TrimSpace(name)
544 if name == "" {
545 continue
546 }
547 if err := store.ValidLabelName(name); err != nil {
548 return nil, err
549 }
550 lab, err := s.Store.LabelByName(ctx, repoID, name)
551 if err != nil {
552 return nil, i18n.E("err.labelMissing", name)
553 }
554 if seen[lab.ID] {
555 continue
556 }
557 seen[lab.ID] = true
558 ids = append(ids, lab.ID)
559 }
560 return ids, nil
561}
562
563func (s *Server) resolveAssignees(ctx context.Context, repo store.Repo, names []string) ([]int64, error) {
564 cand := map[string]int64{}
565 for _, m := range s.issueCandidates(ctx, repo) {
566 cand[m.Username] = m.UserID
567 }
568 ids := []int64{}
569 seen := map[int64]bool{}
570 for _, name := range names {
571 name = strings.ToLower(strings.TrimSpace(strings.TrimPrefix(name, "@")))
572 if name == "" {
573 continue
574 }
575 id, ok := cand[name]
576 if !ok {
577 return nil, i18n.E("err.assignee", name)
578 }
579 if seen[id] {
580 continue
581 }
582 seen[id] = true
583 ids = append(ids, id)
584 }
585 return ids, nil
586}
587
588func (s *Server) resolveMilestone(ctx context.Context, repoID int64, title string) (int64, error) {
589 title = strings.TrimSpace(title)
590 if title == "" {
591 return 0, nil
592 }
593 m, err := s.Store.MilestoneByTitle(ctx, repoID, title)
594 if err != nil {
595 return 0, i18n.E("err.milestone")
596 }
597 return m.ID, nil
598}
599
600func (s *Server) issueHook(repo store.Repo, number int64, actor, action, comment string) {
601 if s.Store == nil {
602 return
603 }
604 iss, err := s.Store.IssueByNumber(context.Background(), repo.ID, number)
605 if err != nil {
606 return
607 }
608 num := strconv.FormatInt(iss.Number, 10)
609 page := strings.TrimRight(s.Cfg.BaseURL, "/") + issuePath(repo, iss.Number)
610 key := "hook.issueOpened"
611 switch action {
612 case "updated":
613 key = "hook.issueUpdated"
614 case "closed":
615 key = "hook.issueClosed"
616 case "reopened":
617 key = "hook.issueReopened"
618 case "commented":
619 key = "hook.issueComment"
620 }
621 summary := i18n.T(i18n.EN, key, num)
622 if action != "commented" {
623 summary = i18n.T(i18n.EN, key, num, iss.Title)
624 }
625 s.Dispatch(repo.ID, webhook.Event{
626 Type: webhook.EventIssue, Project: repo.FullPath(), Actor: actor,
627 Summary: summary, URL: page, Comment: comment,
628 Issue: &webhook.IssueInfo{
629 ID: iss.Number, Title: iss.Title, Description: iss.Description,
630 Status: iss.Status, Confidential: iss.Confidential, Author: iss.Author,
631 Assignees: iss.Assignees, Labels: labelNames(iss.Labels),
632 Milestone: iss.Milestone, DueDate: iss.DueOn, Action: action, URL: page,
633 },
634 })
635}
636
637func (s *Server) closeIssueNumbers(ctx context.Context, repo store.Repo, actor store.User, numbers []int64) {
638 if s.Store == nil {
639 return
640 }
641 for _, n := range numbers {
642 iss, err := s.Store.IssueByNumber(ctx, repo.ID, n)
643 if err != nil || iss.Status == "closed" {
644 continue
645 }
646 changed, err := s.Store.SetIssueState(ctx, iss.ID, "closed")
647 if err != nil || !changed {
648 continue
649 }
650 s.issueHook(repo, n, actor.Username, "closed", "")
651 }
652}
653
654func (s *Server) mergeCloseTexts(r *http.Request, repo store.Repo, mr store.MergeRequest) []string {
655 texts := []string{mr.Description}
656 if s.StoragePath() == "" {
657 return texts
658 }
659 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
660 commits, err := gitrepo.RangeLog(r.Context(), s.Git, dir, mr.TargetBranch, mr.SourceBranch)
661 if err != nil {
662 return texts
663 }
664 for i, c := range commits {
665 if i >= 50 {
666 break
667 }
668 texts = append(texts, commitText(c))
669 }
670 return texts
671}
672
673func (s *Server) closeIssuesOnPush(repo store.Repo, user store.User, before, after string) {
674 if s.Store == nil || s.StoragePath() == "" {
675 return
676 }
677 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
678 commits, err := gitrepo.RangeLog(context.Background(), s.Git, dir, before, after)
679 if err != nil {
680 return
681 }
682 var texts []string
683 for i, c := range commits {
684 if i >= 50 {
685 break
686 }
687 texts = append(texts, commitText(c))
688 }
689 s.closeIssueNumbers(context.Background(), repo, user, closingNumbers(texts...))
690}
691
692func closingNumbers(texts ...string) []int64 {
693 seen := map[int64]bool{}
694 var out []int64
695 for _, text := range texts {
696 text = fenceRe.ReplaceAllString(text, " ")
697 text = inlineCodeRe.ReplaceAllString(text, " ")
698 for _, m := range closeIssueRe.FindAllStringSubmatch(text, -1) {
699 n, err := strconv.ParseInt(m[2], 10, 64)
700 if err != nil || n < 1 || seen[n] {
701 continue
702 }
703 seen[n] = true
704 out = append(out, n)
705 }
706 }
707 return out
708}
709
710func issueVisible(iss store.Issue, u store.User, role access.Role) bool {
711 if !iss.Confidential {
712 return true
713 }
714 if role.CanTriageIssue() {
715 return true
716 }
717 return u.ID != 0 && u.ID == iss.AuthorID
718}
719
720func triagePosted(r *http.Request) bool {
721 if r.Form == nil {
722 return false
723 }
724 _, label := r.Form["label"]
725 _, assignee := r.Form["assignee"]
726 _, milestone := r.Form["milestone"]
727 _, due := r.Form["due_on"]
728 return label || assignee || milestone || due
729}
730
731func markChoices(list []IssueChoice, selected []string) []IssueChoice {
732 on := map[string]bool{}
733 for _, name := range selected {
734 on[name] = true
735 }
736 for i := range list {
737 list[i].On = on[list[i].Name]
738 }
739 return list
740}
741
742func labelNames(labels []store.Label) []string {
743 out := []string{}
744 for _, l := range labels {
745 out = append(out, l.Name)
746 }
747 return out
748}
749
750func issuePath(repo store.Repo, n int64) string {
751 return repoURL(repo) + "/-/issues/" + strconv.FormatInt(n, 10)
752}
753
754func (s *Server) fail(w http.ResponseWriter, r *http.Request, err error) {
755 http.Error(w, s.trErr(r, err), http.StatusInternalServerError)
756}