BlueGit

timfa bluegit

Files

bluegit / internal / server / issues.go

issues.go

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