package server import ( "context" "html/template" "net/http" "regexp" "sort" "strconv" "strings" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/gitrepo" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/markdown" "gitlab.com/Timfa/bluegit/internal/store" "gitlab.com/Timfa/bluegit/internal/webhook" ) // IssueBoard is de gegevensset voor de issuepagina's. type IssueBoard struct { List []IssueRow One *IssueRow Notes []IssueNoteRow Labels []IssueChoice Milestones []store.Milestone People []IssueChoice State string Query string Label string Assignee string Milestone string Due string FormTitle string FormBody string Confidential bool CanCreate bool CanTriage bool CanEdit bool CanClose bool CanReopen bool CanDelete bool Relate int64 Related []IssueRow Tpls []string Tpl string } // IssueChoice is een label of persoon in een formulier. type IssueChoice struct { Name string Color string On bool } // IssueRow is één issue in een lijst of op de detailpagina. type IssueRow struct { Number int64 Title string Status string Author string AuthorURL string Confidential bool Milestone string Due string When string Assignees string Labels []store.Label HTML template.HTML } // IssueNoteRow is een gerenderde reactie. type IssueNoteRow struct { Author string AuthorURL string When string HTML template.HTML } var ( closeIssueRe = regexp.MustCompile(`(?i)(?:^|[\s:])((?:close[sd]?|fix(?:e[sd])?|resolve[sd]?|implement(?:s|ed)?))\s+#(\d+)\b`) fenceRe = regexp.MustCompile("(?s)```.*?```") inlineCodeRe = regexp.MustCompile("`[^`\n]*`") ) func (s *Server) issuesPage(w http.ResponseWriter, r *http.Request) { u, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } v := s.repoView(w, r, repo, role, "tab.issues") v.Title = s.tr(r, "tab.issues") v.Page = "issues" v.Wide = true b := s.issueBoard(r, repo, role, u) state := r.URL.Query().Get("state") if state != "closed" && state != "all" { state = "open" } b.State = state b.Query = strings.TrimSpace(r.URL.Query().Get("q")) b.Label = strings.TrimSpace(r.URL.Query().Get("label")) b.Assignee = strings.TrimSpace(r.URL.Query().Get("assignee")) list, err := s.Store.ListIssues(r.Context(), repo.ID, store.IssueFilter{ State: b.State, Query: b.Query, Label: b.Label, Assignee: b.Assignee, ViewerID: u.ID, Triage: role.CanTriageIssue(), }) if err != nil { s.fail(w, r, err) return } for _, iss := range list { b.List = append(b.List, s.issueRow(r, repo, iss)) } v.Issues = b s.render(w, "issues", v) } func (s *Server) newIssue(w http.ResponseWriter, r *http.Request) { u, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } if u.ID == 0 || !role.CanCreateIssue() { http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden) return } v := s.repoView(w, r, repo, role, "issue.new") v.Title = s.tr(r, "issue.new") v.Page = "issuenew" v.Wide = true b := s.issueBoard(r, repo, role, u) s.prefillIssue(r, repo, u, role, b) s.fillTpl(r, repo, "issue", &b.FormBody, &b.Tpl, &b.Tpls) v.Issues = b s.render(w, "issuenew", v) } func (s *Server) createIssue(w http.ResponseWriter, r *http.Request) { u, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok || !s.csrfOK(w, r) { return } back := repoURL(repo) + "/-/issues/new" if u.ID == 0 || !role.CanCreateIssue() { http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden) return } in := store.NewIssue{ Title: r.FormValue("title"), Description: r.FormValue("description"), Confidential: r.FormValue("confidential") == "1", } base := quickBase{Confidential: in.Confidential} if triagePosted(r) { if !role.CanTriageIssue() { http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden) return } var err error in.LabelIDs, in.AssigneeIDs, in.MilestoneID, in.DueOn, err = s.triageInput(r, repo) if err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } base.Labels = r.Form["label"] base.Assignees = r.Form["assignee"] base.Milestone = r.FormValue("milestone") base.Due = in.DueOn } q, err := s.foldQuick(r.Context(), repo, in.Description, role.CanTriageIssue(), true, base) if err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } in.Description = q.Body if q.Labels { in.LabelIDs = q.LabelIDs } if q.Assignees { in.AssigneeIDs = q.AssigneeIDs } if q.Meta { in.MilestoneID = q.MilestoneID in.DueOn = q.Due in.Confidential = q.Confidential } iss, err := s.Store.CreateIssue(r.Context(), repo.ID, u.ID, in) if err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } if rel, _ := strconv.ParseInt(r.FormValue("relate"), 10, 64); rel > 0 { if other, err := s.Store.IssueByNumber(r.Context(), repo.ID, rel); err == nil && issueVisible(other, u, role) { _ = s.Store.LinkIssues(r.Context(), repo.ID, iss.ID, other.ID) } } s.issueHook(repo, iss.Number, u.Username, "opened", "") s.redirect(w, r, issuePath(repo, iss.Number), s.tr(r, "flash.issueCreated"), "") } func (s *Server) showIssue(w http.ResponseWriter, r *http.Request) { u, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } iss, ok := s.loadVisibleIssue(w, r, repo, u, role) if !ok { return } v := s.repoView(w, r, repo, role, "#"+strconv.FormatInt(iss.Number, 10)) v.Title = "#" + strconv.FormatInt(iss.Number, 10) + " " + iss.Title v.Page = "issue" v.Wide = true b := s.issueBoard(r, repo, role, u) row := s.issueRow(r, repo, iss) canText := u.ID != 0 && (u.ID == iss.AuthorID || role.CanTriageIssue()) row.HTML = template.HTML(markdown.RenderTasks(iss.Description, "", "", "/"+repo.FullPath(), s.taskOpt(r, v.CSRF, repo, "issue", strconv.FormatInt(iss.Number, 10), canText))) b.One = &row b.Confidential = iss.Confidential b.Milestone = iss.Milestone b.Due = iss.DueOn b.FormTitle = iss.Title b.FormBody = iss.Description b.CanEdit = u.ID != 0 && (u.ID == iss.AuthorID || role.CanTriageIssue()) b.CanClose = iss.Status == "open" && b.CanEdit b.CanReopen = iss.Status == "closed" && b.CanEdit b.Labels = markChoices(b.Labels, labelNames(iss.Labels)) b.People = markChoices(b.People, iss.Assignees) notes, _ := s.Store.ListIssueNotes(r.Context(), iss.ID) for _, n := range notes { noteURL := "" if n.Author != "" { noteURL = "/users/" + n.Author } b.Notes = append(b.Notes, IssueNoteRow{ Author: n.Author, AuthorURL: noteURL, When: i18n.FormatDate(s.langOf(r), n.CreatedAt), 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))), }) } related, _ := s.Store.RelatedIssues(r.Context(), repo.ID, iss.ID) for _, other := range related { if issueVisible(other, u, role) { b.Related = append(b.Related, s.issueRow(r, repo, other)) } } v.Issues = b s.render(w, "issue", v) } func (s *Server) postIssue(w http.ResponseWriter, r *http.Request) { u, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok || !s.csrfOK(w, r) { return } iss, ok := s.loadVisibleIssue(w, r, repo, u, role) if !ok { return } back := issuePath(repo, iss.Number) if u.ID == 0 { http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden) return } switch r.FormValue("action") { case "note": if !role.CanCreateIssue() { http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden) return } q, err := s.foldQuick(r.Context(), repo, r.FormValue("body"), role.CanTriageIssue(), false, quickFromIssue(iss)) if err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } if err := s.persistQuick(r.Context(), repo, iss.ID, q); err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } if strings.TrimSpace(q.Body) == "" { if !q.touched() { s.redirect(w, r, back, "", s.tr(r, "err.issueNote")) return } s.issueHook(repo, iss.Number, u.Username, "updated", "") s.redirect(w, r, back, s.tr(r, "flash.issueUpdated"), "") return } if _, err := s.Store.AddIssueNote(r.Context(), repo.ID, iss.ID, u.ID, q.Body); err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } s.issueHook(repo, iss.Number, u.Username, "commented", strings.TrimSpace(q.Body)) s.redirect(w, r, back, s.tr(r, "flash.note"), "") case "close", "reopen": if u.ID != iss.AuthorID && !role.CanTriageIssue() { http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden) return } status := "closed" flash := "flash.issueClosed" action := "closed" if r.FormValue("action") == "reopen" { status, flash, action = "open", "flash.issueReopened", "reopened" } changed, err := s.Store.SetIssueState(r.Context(), iss.ID, status) if err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } if changed { s.issueHook(repo, iss.Number, u.Username, action, "") } s.redirect(w, r, back, s.tr(r, flash), "") case "update": if u.ID != iss.AuthorID && !role.CanTriageIssue() { http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden) return } q, err := s.foldQuick(r.Context(), repo, r.FormValue("description"), role.CanTriageIssue(), false, quickFromIssue(iss)) if err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } if err := s.Store.UpdateIssueText(r.Context(), iss.ID, r.FormValue("title"), q.Body); err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } if err := s.persistQuick(r.Context(), repo, iss.ID, q); err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } s.issueHook(repo, iss.Number, u.Username, "updated", "") s.redirect(w, r, back, s.tr(r, "flash.issueUpdated"), "") case "meta": if !role.CanTriageIssue() { http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden) return } labels, assignees, milestoneID, due, err := s.triageInput(r, repo) if err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } if err := s.Store.SetIssueLabels(r.Context(), repo.ID, iss.ID, labels); err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } if err := s.Store.SetIssueAssignees(r.Context(), repo.ID, iss.ID, assignees); err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } if err := s.Store.SetIssueMeta(r.Context(), repo.ID, iss.ID, milestoneID, r.FormValue("confidential") == "1", due); err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } s.issueHook(repo, iss.Number, u.Username, "updated", "") s.redirect(w, r, back, s.tr(r, "flash.issueUpdated"), "") case "delete": if !role.CanManageSettings() { http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden) return } if err := s.Store.DeleteIssue(r.Context(), repo.ID, iss.ID); err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } s.redirect(w, r, repoURL(repo)+"/-/issues", s.tr(r, "flash.issueDeleted"), "") default: http.Error(w, s.tr(r, "err.badForm"), http.StatusBadRequest) } } func (s *Server) createIssueLabel(w http.ResponseWriter, r *http.Request) { u, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok || !s.csrfOK(w, r) { return } if u.ID == 0 || !role.CanManageSettings() { http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden) return } back := repoURL(repo) + "/-/issues" if _, err := s.Store.UpsertLabel(r.Context(), repo.ID, r.FormValue("name"), r.FormValue("color")); err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } s.redirect(w, r, back, s.tr(r, "flash.label"), "") } func (s *Server) createIssueMilestone(w http.ResponseWriter, r *http.Request) { u, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok || !s.csrfOK(w, r) { return } if u.ID == 0 || !role.CanManageSettings() { http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden) return } back := repoURL(repo) + "/-/issues" if _, err := s.Store.UpsertMilestone(r.Context(), repo.ID, r.FormValue("title"), r.FormValue("due_on")); err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } s.redirect(w, r, back, s.tr(r, "flash.milestone"), "") } func (s *Server) loadVisibleIssue(w http.ResponseWriter, r *http.Request, repo store.Repo, u store.User, role access.Role) (store.Issue, bool) { n, err := strconv.ParseInt(r.PathValue("number"), 10, 64) if err != nil || n < 1 { http.NotFound(w, r) return store.Issue{}, false } iss, err := s.Store.IssueByNumber(r.Context(), repo.ID, n) if err != nil || !issueVisible(iss, u, role) { if err == nil && iss.Confidential && isCrawler(r) { s.writeLockedCard(w, r) } else { http.NotFound(w, r) } return store.Issue{}, false } return iss, true } func (s *Server) issueBoard(r *http.Request, repo store.Repo, role access.Role, u store.User) *IssueBoard { labels, _ := s.Store.ListLabels(r.Context(), repo.ID) miles, _ := s.Store.ListMilestones(r.Context(), repo.ID) b := &IssueBoard{ Labels: []IssueChoice{}, Milestones: miles, People: []IssueChoice{}, CanCreate: u.ID != 0 && role.CanCreateIssue(), CanTriage: role.CanTriageIssue(), CanDelete: role.CanManageSettings(), } if b.Milestones == nil { b.Milestones = []store.Milestone{} } for _, l := range labels { b.Labels = append(b.Labels, IssueChoice{Name: l.Name, Color: l.Color}) } for _, p := range s.issueCandidates(r.Context(), repo) { b.People = append(b.People, IssueChoice{Name: p.Username}) } return b } func (s *Server) issueRow(r *http.Request, repo store.Repo, iss store.Issue) IssueRow { url := "" if iss.Author != "" { url = "/users/" + iss.Author } return IssueRow{ Number: iss.Number, Title: iss.Title, Status: iss.Status, Author: iss.Author, AuthorURL: url, Confidential: iss.Confidential, Milestone: iss.Milestone, Due: iss.DueOn, When: i18n.FormatDate(s.langOf(r), iss.CreatedAt), Assignees: strings.Join(iss.Assignees, ", "), Labels: iss.Labels, HTML: template.HTML(markdown.Render(iss.Description, "", "", "/"+repo.FullPath())), } } func (s *Server) prefillIssue(r *http.Request, repo store.Repo, u store.User, role access.Role, b *IssueBoard) { if rel, err := strconv.ParseInt(r.URL.Query().Get("relate"), 10, 64); err == nil && rel > 0 { if iss, err := s.Store.IssueByNumber(r.Context(), repo.ID, rel); err == nil && issueVisible(iss, u, role) { b.Relate = rel } } if r.URL.Query().Get("from") != "mr" { return } n, err := strconv.ParseInt(r.URL.Query().Get("mr"), 10, 64) if err != nil || n < 1 { return } mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n) if err != nil { return } ref := "!" + strconv.FormatInt(n, 10) b.FormBody = ref noteID, _ := strconv.ParseInt(r.URL.Query().Get("note"), 10, 64) if noteID == 0 { return } notes, err := s.Store.ListNotes(r.Context(), mr.ID) if err != nil { return } for _, note := range notes { if note.ID == noteID { b.FormBody = strings.TrimSpace(note.Body) + "\n\n" + ref return } } } func (s *Server) issueCandidates(ctx context.Context, repo store.Repo) []store.Member { seen := map[string]store.Member{} add := func(list []store.Member) { for _, m := range list { if m.Pending || m.UserID == 0 || m.Username == "" { continue } seen[m.Username] = m } } if repo.OwnerKind == "user" { if u, err := s.Store.UserByID(ctx, repo.OwnerID); err == nil { seen[u.Username] = store.Member{UserID: u.ID, Username: u.Username, Role: access.RoleMaintainer} } } if members, err := s.Store.ListMembers(ctx, "repo", repo.ID); err == nil { add(members) } if repo.OwnerKind == "group" { if members, err := s.Store.ListMembers(ctx, "group", repo.OwnerID); err == nil { add(members) } } out := make([]store.Member, 0, len(seen)) for _, m := range seen { out = append(out, m) } sort.Slice(out, func(i, j int) bool { return out[i].Username < out[j].Username }) return out } func (s *Server) triageInput(r *http.Request, repo store.Repo) (labels, assignees []int64, milestoneID int64, due string, err error) { labels, err = s.resolveLabels(r.Context(), repo.ID, r.Form["label"]) if err != nil { return nil, nil, 0, "", err } assignees, err = s.resolveAssignees(r.Context(), repo, r.Form["assignee"]) if err != nil { return nil, nil, 0, "", err } milestoneID, err = s.resolveMilestone(r.Context(), repo.ID, r.FormValue("milestone")) if err != nil { return nil, nil, 0, "", err } due = strings.TrimSpace(r.FormValue("due_on")) if err := store.ValidDue(due); err != nil { return nil, nil, 0, "", err } return labels, assignees, milestoneID, due, nil } func (s *Server) resolveLabels(ctx context.Context, repoID int64, names []string) ([]int64, error) { ids := []int64{} seen := map[int64]bool{} for _, name := range names { name = strings.TrimSpace(name) if name == "" { continue } if err := store.ValidLabelName(name); err != nil { return nil, err } lab, err := s.Store.LabelByName(ctx, repoID, name) if err != nil { return nil, i18n.E("err.labelMissing", name) } if seen[lab.ID] { continue } seen[lab.ID] = true ids = append(ids, lab.ID) } return ids, nil } func (s *Server) resolveAssignees(ctx context.Context, repo store.Repo, names []string) ([]int64, error) { cand := map[string]int64{} for _, m := range s.issueCandidates(ctx, repo) { cand[m.Username] = m.UserID } ids := []int64{} seen := map[int64]bool{} for _, name := range names { name = strings.ToLower(strings.TrimSpace(strings.TrimPrefix(name, "@"))) if name == "" { continue } id, ok := cand[name] if !ok { return nil, i18n.E("err.assignee", name) } if seen[id] { continue } seen[id] = true ids = append(ids, id) } return ids, nil } func (s *Server) resolveMilestone(ctx context.Context, repoID int64, title string) (int64, error) { title = strings.TrimSpace(title) if title == "" { return 0, nil } m, err := s.Store.MilestoneByTitle(ctx, repoID, title) if err != nil { return 0, i18n.E("err.milestone") } return m.ID, nil } func (s *Server) issueHook(repo store.Repo, number int64, actor, action, comment string) { if s.Store == nil { return } iss, err := s.Store.IssueByNumber(context.Background(), repo.ID, number) if err != nil { return } num := strconv.FormatInt(iss.Number, 10) page := strings.TrimRight(s.Cfg.BaseURL, "/") + issuePath(repo, iss.Number) key := "hook.issueOpened" switch action { case "updated": key = "hook.issueUpdated" case "closed": key = "hook.issueClosed" case "reopened": key = "hook.issueReopened" case "commented": key = "hook.issueComment" } summary := i18n.T(i18n.EN, key, num) if action != "commented" { summary = i18n.T(i18n.EN, key, num, iss.Title) } s.Dispatch(repo.ID, webhook.Event{ Type: webhook.EventIssue, Project: repo.FullPath(), Actor: actor, Summary: summary, URL: page, Comment: comment, Issue: &webhook.IssueInfo{ ID: iss.Number, Title: iss.Title, Description: iss.Description, Status: iss.Status, Confidential: iss.Confidential, Author: iss.Author, Assignees: iss.Assignees, Labels: labelNames(iss.Labels), Milestone: iss.Milestone, DueDate: iss.DueOn, Action: action, URL: page, }, }) } func (s *Server) closeIssueNumbers(ctx context.Context, repo store.Repo, actor store.User, numbers []int64) { if s.Store == nil { return } for _, n := range numbers { iss, err := s.Store.IssueByNumber(ctx, repo.ID, n) if err != nil || iss.Status == "closed" { continue } changed, err := s.Store.SetIssueState(ctx, iss.ID, "closed") if err != nil || !changed { continue } s.issueHook(repo, n, actor.Username, "closed", "") } } func (s *Server) mergeCloseTexts(r *http.Request, repo store.Repo, mr store.MergeRequest) []string { texts := []string{mr.Description} if s.StoragePath() == "" { return texts } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) commits, err := gitrepo.RangeLog(r.Context(), s.Git, dir, mr.TargetBranch, mr.SourceBranch) if err != nil { return texts } for i, c := range commits { if i >= 50 { break } texts = append(texts, commitText(c)) } return texts } func (s *Server) closeIssuesOnPush(repo store.Repo, user store.User, before, after string) { if s.Store == nil || s.StoragePath() == "" { return } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) commits, err := gitrepo.RangeLog(context.Background(), s.Git, dir, before, after) if err != nil { return } var texts []string for i, c := range commits { if i >= 50 { break } texts = append(texts, commitText(c)) } s.closeIssueNumbers(context.Background(), repo, user, closingNumbers(texts...)) } func closingNumbers(texts ...string) []int64 { seen := map[int64]bool{} var out []int64 for _, text := range texts { text = fenceRe.ReplaceAllString(text, " ") text = inlineCodeRe.ReplaceAllString(text, " ") for _, m := range closeIssueRe.FindAllStringSubmatch(text, -1) { n, err := strconv.ParseInt(m[2], 10, 64) if err != nil || n < 1 || seen[n] { continue } seen[n] = true out = append(out, n) } } return out } func issueVisible(iss store.Issue, u store.User, role access.Role) bool { if !iss.Confidential { return true } if role.CanTriageIssue() { return true } return u.ID != 0 && u.ID == iss.AuthorID } func triagePosted(r *http.Request) bool { if r.Form == nil { return false } _, label := r.Form["label"] _, assignee := r.Form["assignee"] _, milestone := r.Form["milestone"] _, due := r.Form["due_on"] return label || assignee || milestone || due } func markChoices(list []IssueChoice, selected []string) []IssueChoice { on := map[string]bool{} for _, name := range selected { on[name] = true } for i := range list { list[i].On = on[list[i].Name] } return list } func labelNames(labels []store.Label) []string { out := []string{} for _, l := range labels { out = append(out, l.Name) } return out } func issuePath(repo store.Repo, n int64) string { return repoURL(repo) + "/-/issues/" + strconv.FormatInt(n, 10) } func (s *Server) fail(w http.ResponseWriter, r *http.Request, err error) { http.Error(w, s.trErr(r, err), http.StatusInternalServerError) }