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)
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: "all", Label: b.Label, Assignee: b.Assignee,
ViewerID: u.ID, Triage: role.CanTriageIssue(),
})
if err != nil {
s.fail(w, r, err)
return
}
v.Flow = s.flowIssues(r, repo, b, list)
b.State = v.Flow.State
for _, iss := range list {
if iss.Status != b.State && b.State != "all" {
continue
}
if !flowHit(b.Query, issueSearchBits(iss)...) {
continue
}
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)
}