package server import ( "context" "strings" "gitlab.com/Timfa/bluegit/internal/quick" "gitlab.com/Timfa/bluegit/internal/store" ) type quickBase struct { Labels []string Assignees []string Milestone string Due string Confidential bool } type quickResult struct { Body string LabelIDs []int64 AssigneeIDs []int64 MilestoneID int64 Due string Confidential bool Labels bool Assignees bool Meta bool } func (q quickResult) touched() bool { return q.Labels || q.Assignees || q.Meta } // foldQuick haalt quick actions uit de tekst als de gebruiker ze mag uitvoeren. // Een regel zonder recht blijft staan. Een onbekend label of een onbekende // gebruiker is een fout en er wordt nog niets opgeslagen. func (s *Server) foldQuick(ctx context.Context, repo store.Repo, body string, canTriage, creating bool, base quickBase) (quickResult, error) { labels := append([]string{}, base.Labels...) assignees := append([]string{}, base.Assignees...) mile := base.Milestone due := base.Due conf := base.Confidential var kept []string var touchL, touchA, touchM bool for _, p := range quick.Scan(body) { if p.Cmd == nil || !allowQuick(p.Cmd.Kind, canTriage, creating) { kept = append(kept, p.Text) continue } switch p.Cmd.Kind { case "label": touchL = true for _, name := range p.Cmd.Names { if !hasName(labels, name) { labels = append(labels, name) } } case "unlabel": touchL = true labels = dropNames(labels, p.Cmd.Names) case "assign": touchA = true for _, name := range p.Cmd.Names { if !hasFold(assignees, name) { assignees = append(assignees, name) } } case "unassign": touchA = true assignees = dropFold(assignees, p.Cmd.Names) case "milestone": touchM = true mile = p.Cmd.Names[0] case "due": touchM = true due = p.Cmd.Due case "confidential": touchM = true conf = true } } res := quickResult{Body: strings.Join(kept, "\n"), Due: due, Confidential: conf, Labels: touchL, Assignees: touchA, Meta: touchM} if touchL { ids, err := s.resolveLabels(ctx, repo.ID, labels) if err != nil { return quickResult{}, err } res.LabelIDs = ids } if touchA { ids, err := s.resolveAssignees(ctx, repo, assignees) if err != nil { return quickResult{}, err } res.AssigneeIDs = ids } if touchM { id, err := s.resolveMilestone(ctx, repo.ID, mile) if err != nil { return quickResult{}, err } if err := store.ValidDue(due); err != nil { return quickResult{}, err } res.MilestoneID = id } return res, nil } func (s *Server) persistQuick(ctx context.Context, repo store.Repo, issueID int64, res quickResult) error { if res.Labels { if err := s.Store.SetIssueLabels(ctx, repo.ID, issueID, res.LabelIDs); err != nil { return err } } if res.Assignees { if err := s.Store.SetIssueAssignees(ctx, repo.ID, issueID, res.AssigneeIDs); err != nil { return err } } if res.Meta { if err := s.Store.SetIssueMeta(ctx, repo.ID, issueID, res.MilestoneID, res.Confidential, res.Due); err != nil { return err } } return nil } func allowQuick(kind string, canTriage, creating bool) bool { if canTriage { return true } return creating && kind == "confidential" } func hasName(list []string, name string) bool { for _, item := range list { if item == name { return true } } return false } func hasFold(list []string, name string) bool { for _, item := range list { if strings.EqualFold(item, name) { return true } } return false } func dropNames(list, gone []string) []string { dead := map[string]bool{} for _, name := range gone { dead[name] = true } var out []string for _, name := range list { if !dead[name] { out = append(out, name) } } return out } func dropFold(list, gone []string) []string { var out []string for _, name := range list { if !hasFold(gone, name) { out = append(out, name) } } return out } func quickFromIssue(iss store.Issue) quickBase { return quickBase{ Labels: labelNames(iss.Labels), Assignees: append([]string{}, iss.Assignees...), Milestone: iss.Milestone, Due: iss.DueOn, Confidential: iss.Confidential, } }