mrcharles
d98f0aeb93
issue list/show/create/update, version list/create, category list/create, relation create. Names resolve case-insensitively against server enumerations; -o json everywhere; exit 0/1/2 with one-line stderr carrying the http status for API failures.
542 lines
16 KiB
Go
542 lines
16 KiB
Go
package cli
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"git.knownelement.com/ukrrs/mopac-redmine-go/redmine"
|
|
)
|
|
|
|
func marshalIndent(v any) ([]byte, error) { return json.MarshalIndent(v, "", " ") }
|
|
|
|
// --- issue -----------------------------------------------------------------
|
|
|
|
func cmdIssue(args []string, stdout, stderr io.Writer) int {
|
|
if len(args) == 0 {
|
|
return usageErr(stderr, "issue: expected list|show|create|update (see mred help)")
|
|
}
|
|
sub, rest := args[0], args[1:]
|
|
switch sub {
|
|
case "list":
|
|
return cmdIssueList(rest, stdout, stderr)
|
|
case "show":
|
|
return cmdIssueShow(rest, stdout, stderr)
|
|
case "create":
|
|
return cmdIssueCreate(rest, stdout, stderr)
|
|
case "update":
|
|
return cmdIssueUpdate(rest, stdout, stderr)
|
|
default:
|
|
return usageErr(stderr, "issue: unknown subcommand %q", sub)
|
|
}
|
|
}
|
|
|
|
func cmdIssueList(args []string, stdout, stderr io.Writer) int {
|
|
fs, cfgPath, out := newFlags("issue list", stderr)
|
|
project := fs.String("p", "", "project identifier (required)")
|
|
status := fs.String("status", "open", "open|all|closed|status name")
|
|
version := fs.String("version", "", "target version name")
|
|
limit := fs.Int("limit", 0, "max issues returned (0 = server default)")
|
|
pos, err := parseArgs(fs, args)
|
|
if err != nil || len(pos) != 0 || *project == "" {
|
|
return usageErr(stderr, "issue list: usage: mred issue list -p PROJECT [--status open|all|NAME] [--version NAME] [--limit N]")
|
|
}
|
|
c, err := client(*cfgPath)
|
|
if err != nil {
|
|
return usageErr(stderr, "%v", err)
|
|
}
|
|
ctx := context.Background()
|
|
|
|
f := redmine.IssueFilter{Project: *project, Limit: *limit}
|
|
switch s := *status; s {
|
|
case "open", "all", "closed":
|
|
f.Status = map[string]string{"all": redmine.StatusAll}[s]
|
|
if f.Status == "" {
|
|
f.Status = s
|
|
}
|
|
default:
|
|
id, err := c.StatusIDByName(ctx, s)
|
|
if err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
f.Status = strconv.Itoa(id)
|
|
}
|
|
if *version != "" {
|
|
id, err := c.VersionIDByName(ctx, *project, *version)
|
|
if err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
f.FixedVersion = id
|
|
}
|
|
|
|
issues, _, err := c.ListIssues(ctx, f)
|
|
if err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
if *out == "json" {
|
|
emitJSON(stdout, map[string]any{"issues": issues})
|
|
return 0
|
|
}
|
|
for _, i := range issues {
|
|
line := fmt.Sprintf("%-6d %-14s %s", i.ID, i.Status.Name, i.Subject)
|
|
if i.FixedVersion.Name != "" {
|
|
line += " @" + i.FixedVersion.Name
|
|
}
|
|
fmt.Fprintln(stdout, line)
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func cmdIssueShow(args []string, stdout, stderr io.Writer) int {
|
|
fs, cfgPath, out := newFlags("issue show", stderr)
|
|
with := fs.String("with", "", "extra sections to include: journals")
|
|
pos, err := parseArgs(fs, args)
|
|
if err != nil || len(pos) != 1 {
|
|
return usageErr(stderr, "issue show: usage: mred issue show ID [--with journals]")
|
|
}
|
|
id, err := strconv.Atoi(pos[0])
|
|
if err != nil {
|
|
return usageErr(stderr, "issue show: ID must be numeric, got %q", pos[0])
|
|
}
|
|
c, err := client(*cfgPath)
|
|
if err != nil {
|
|
return usageErr(stderr, "%v", err)
|
|
}
|
|
withJournals := false
|
|
switch *with {
|
|
case "":
|
|
case "journals":
|
|
withJournals = true
|
|
default:
|
|
return usageErr(stderr, "issue show: --with understands only journals")
|
|
}
|
|
issue, err := c.GetIssue(context.Background(), id, withJournals)
|
|
if err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
if *out == "json" {
|
|
emitJSON(stdout, map[string]any{"issue": issue})
|
|
return 0
|
|
}
|
|
printIssue(stdout, issue, withJournals)
|
|
return 0
|
|
}
|
|
|
|
func printIssue(w io.Writer, i *redmine.Issue, withJournals bool) {
|
|
fmt.Fprintf(w, "#%d %s\n", i.ID, i.Subject)
|
|
fmt.Fprintf(w, "Tracker: %-10s Status: %-12s Priority: %s\n", i.Tracker.Name, i.Status.Name, i.Priority.Name)
|
|
meta := "Project: " + i.Project.Name
|
|
if i.FixedVersion.Name != "" {
|
|
meta += " Version: " + i.FixedVersion.Name
|
|
}
|
|
if i.Category.Name != "" {
|
|
meta += " Category: " + i.Category.Name
|
|
}
|
|
if i.Parent.ID != 0 {
|
|
meta += " Parent: #" + strconv.Itoa(i.Parent.ID)
|
|
}
|
|
fmt.Fprintln(w, meta)
|
|
facts := ""
|
|
if i.DueDate != "" {
|
|
facts += "Due: " + i.DueDate + " "
|
|
}
|
|
if i.EstimatedHours != nil {
|
|
facts += fmt.Sprintf("Estimate: %gh ", *i.EstimatedHours)
|
|
}
|
|
if i.DoneRatio != 0 {
|
|
facts += fmt.Sprintf("Done: %d%% ", i.DoneRatio)
|
|
}
|
|
if facts != "" {
|
|
fmt.Fprintln(w, strings.TrimRight(facts, " "))
|
|
}
|
|
fmt.Fprintf(w, "Created: %s Updated: %s\n", i.CreatedOn, i.UpdatedOn)
|
|
if i.Description != "" {
|
|
fmt.Fprintln(w)
|
|
fmt.Fprintln(w, i.Description)
|
|
}
|
|
if withJournals && len(i.Journals) > 0 {
|
|
fmt.Fprintln(w)
|
|
fmt.Fprintln(w, "Journals:")
|
|
for _, j := range i.Journals {
|
|
fmt.Fprintf(w, "* %s user %d: %s\n", j.CreatedOn, j.UserID, j.Notes)
|
|
}
|
|
}
|
|
}
|
|
|
|
func cmdIssueCreate(args []string, stdout, stderr io.Writer) int {
|
|
fs, cfgPath, out := newFlags("issue create", stderr)
|
|
project := fs.String("p", "", "project identifier (required)")
|
|
subject := fs.String("s", "", "subject (required)")
|
|
desc := fs.String("desc", "", "description from FILE, or - for stdin")
|
|
tracker := fs.String("tracker", "", "tracker name (e.g. feature)")
|
|
priority := fs.String("priority", "", "priority name (e.g. immediate)")
|
|
category := fs.String("category", "", "category name")
|
|
version := fs.String("version", "", "target version name")
|
|
due := fs.String("due", "", "due date YYYY-MM-DD")
|
|
parent := fs.Int("parent", 0, "parent issue id")
|
|
est := fs.Float64("est", 0, "estimated hours")
|
|
note := fs.String("note", "", "create-time journal note")
|
|
pos, perr := parseArgs(fs, args)
|
|
if perr != nil || len(pos) != 0 || *project == "" || *subject == "" {
|
|
return usageErr(stderr, "issue create: usage: mred issue create -p PROJECT -s SUBJECT [flags] (see mred help)")
|
|
}
|
|
c, err := client(*cfgPath)
|
|
if err != nil {
|
|
return usageErr(stderr, "%v", err)
|
|
}
|
|
ctx := context.Background()
|
|
|
|
p := redmine.IssueParams{Project: *project, Subject: *subject, DueDate: *due, Notes: *note}
|
|
if *desc != "" {
|
|
text, err := readDesc(*desc)
|
|
if err != nil {
|
|
return usageErr(stderr, "%v", err)
|
|
}
|
|
p.Description = text
|
|
}
|
|
if *tracker != "" {
|
|
if p.TrackerID, err = c.TrackerIDByName(ctx, *tracker); err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
}
|
|
if *priority != "" {
|
|
if p.PriorityID, err = c.PriorityIDByName(ctx, *priority); err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
}
|
|
if *category != "" {
|
|
if p.CategoryID, err = c.CategoryIDByName(ctx, *project, *category); err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
}
|
|
if *version != "" {
|
|
if p.FixedVersionID, err = c.VersionIDByName(ctx, *project, *version); err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
}
|
|
if *parent != 0 {
|
|
p.ParentIssueID = *parent
|
|
}
|
|
if *est != 0 {
|
|
p.EstimatedHours = est
|
|
}
|
|
|
|
issue, err := c.CreateIssue(ctx, p)
|
|
if err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
if *out == "json" {
|
|
emitJSON(stdout, map[string]any{"issue": issue})
|
|
return 0
|
|
}
|
|
fmt.Fprintf(stdout, "created issue #%d: %s\n", issue.ID, issue.Subject)
|
|
return 0
|
|
}
|
|
|
|
func cmdIssueUpdate(args []string, stdout, stderr io.Writer) int {
|
|
fs, cfgPath, out := newFlags("issue update", stderr)
|
|
status := fs.String("status", "", "status name (e.g. done, \"In Progress\")")
|
|
priority := fs.String("priority", "", "priority name")
|
|
category := fs.String("category", "", "category name")
|
|
version := fs.String("version", "", "target version name")
|
|
due := fs.String("due", "", "due date YYYY-MM-DD")
|
|
doneRatio := fs.Int("done-ratio", -1, "progress percent 0-100")
|
|
desc := fs.String("desc", "", "replace description from FILE, or - for stdin")
|
|
note := fs.String("note", "", "append a journal note")
|
|
pos, perr := parseArgs(fs, args)
|
|
if perr != nil || len(pos) != 1 {
|
|
return usageErr(stderr, "issue update: usage: mred issue update ID [flags] (see mred help)")
|
|
}
|
|
id, err := strconv.Atoi(pos[0])
|
|
if err != nil {
|
|
return usageErr(stderr, "issue update: ID must be numeric, got %q", pos[0])
|
|
}
|
|
c, err := client(*cfgPath)
|
|
if err != nil {
|
|
return usageErr(stderr, "%v", err)
|
|
}
|
|
ctx := context.Background()
|
|
|
|
p := redmine.IssueParams{Notes: *note}
|
|
|
|
// category/version names resolve within the issue's own project.
|
|
var projectID string
|
|
resolveProject := func() (string, error) {
|
|
if projectID != "" {
|
|
return projectID, nil
|
|
}
|
|
fresh, err := c.GetIssue(ctx, id, false)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if fresh.Project.ID == 0 {
|
|
return "", fmt.Errorf("issue #%d carries no project id", id)
|
|
}
|
|
projectID = strconv.Itoa(fresh.Project.ID)
|
|
return projectID, nil
|
|
}
|
|
if *status != "" {
|
|
if p.StatusID, err = c.StatusIDByName(ctx, *status); err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
}
|
|
if *priority != "" {
|
|
if p.PriorityID, err = c.PriorityIDByName(ctx, *priority); err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
}
|
|
if *category != "" {
|
|
proj, perr := resolveProject()
|
|
if perr != nil {
|
|
return apiErr(stderr, perr)
|
|
}
|
|
if p.CategoryID, err = c.CategoryIDByName(ctx, proj, *category); err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
}
|
|
if *version != "" {
|
|
proj, perr := resolveProject()
|
|
if perr != nil {
|
|
return apiErr(stderr, perr)
|
|
}
|
|
if p.FixedVersionID, err = c.VersionIDByName(ctx, proj, *version); err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
}
|
|
if *due != "" {
|
|
p.DueDate = *due
|
|
}
|
|
if *doneRatio >= 0 {
|
|
p.DoneRatio = *doneRatio
|
|
}
|
|
if *desc != "" {
|
|
text, err := readDesc(*desc)
|
|
if err != nil {
|
|
return usageErr(stderr, "%v", err)
|
|
}
|
|
p.Description = text
|
|
}
|
|
|
|
if err := c.UpdateIssue(ctx, id, p); err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
if *out == "json" {
|
|
fresh, err := c.GetIssue(ctx, id, false)
|
|
if err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
emitJSON(stdout, map[string]any{"issue": fresh})
|
|
return 0
|
|
}
|
|
fmt.Fprintf(stdout, "updated issue #%d\n", id)
|
|
return 0
|
|
}
|
|
|
|
// readDesc loads a description from a file, or from stdin when path is "-".
|
|
func readDesc(path string) (string, error) {
|
|
if path == "-" {
|
|
b, err := io.ReadAll(os.Stdin)
|
|
if err != nil {
|
|
return "", fmt.Errorf("desc: cannot read stdin: %w", err)
|
|
}
|
|
return string(b), nil
|
|
}
|
|
b, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return "", fmt.Errorf("desc: cannot read %s", path)
|
|
}
|
|
return string(b), nil
|
|
}
|
|
|
|
// --- version ----------------------------------------------------------------
|
|
|
|
func cmdVersion(args []string, stdout, stderr io.Writer) int {
|
|
if len(args) == 0 {
|
|
return usageErr(stderr, "version: expected list|create (see mred help)")
|
|
}
|
|
sub, rest := args[0], args[1:]
|
|
switch sub {
|
|
case "list":
|
|
return cmdVersionList(rest, stdout, stderr)
|
|
case "create":
|
|
return cmdVersionCreate(rest, stdout, stderr)
|
|
default:
|
|
return usageErr(stderr, "version: unknown subcommand %q", sub)
|
|
}
|
|
}
|
|
|
|
func cmdVersionList(args []string, stdout, stderr io.Writer) int {
|
|
fs, cfgPath, out := newFlags("version list", stderr)
|
|
project := fs.String("p", "", "project identifier (required)")
|
|
pos, err := parseArgs(fs, args)
|
|
if err != nil || len(pos) != 0 || *project == "" {
|
|
return usageErr(stderr, "version list: usage: mred version list -p PROJECT")
|
|
}
|
|
c, err := client(*cfgPath)
|
|
if err != nil {
|
|
return usageErr(stderr, "%v", err)
|
|
}
|
|
versions, err := c.ListVersions(context.Background(), *project)
|
|
if err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
if *out == "json" {
|
|
emitJSON(stdout, map[string]any{"versions": versions})
|
|
return 0
|
|
}
|
|
for _, v := range versions {
|
|
fmt.Fprintf(stdout, "%-6d %-10s %s %s\n", v.ID, v.Status, v.Name, dueSuffix(v.DueDate))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func cmdVersionCreate(args []string, stdout, stderr io.Writer) int {
|
|
fs, cfgPath, out := newFlags("version create", stderr)
|
|
project := fs.String("p", "", "project identifier (required)")
|
|
name := fs.String("n", "", "version name (required)")
|
|
due := fs.String("due", "", "due date YYYY-MM-DD")
|
|
status := fs.String("status", "open", "open|closed")
|
|
pos, err := parseArgs(fs, args)
|
|
if err != nil || len(pos) != 0 || *project == "" || *name == "" {
|
|
return usageErr(stderr, "version create: usage: mred version create -p PROJECT -n NAME [--due DATE] [--status open|closed]")
|
|
}
|
|
if *status != "open" && *status != "closed" && *status != "locked" {
|
|
return usageErr(stderr, "version create: --status must be open|closed|locked")
|
|
}
|
|
c, err := client(*cfgPath)
|
|
if err != nil {
|
|
return usageErr(stderr, "%v", err)
|
|
}
|
|
v, err := c.CreateVersion(context.Background(), *project, redmine.VersionParams{
|
|
Name: *name, DueDate: *due, Status: *status, Sharing: "descendants",
|
|
})
|
|
if err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
if *out == "json" {
|
|
emitJSON(stdout, map[string]any{"version": v})
|
|
return 0
|
|
}
|
|
fmt.Fprintf(stdout, "created version #%d %s (%s) %s\n", v.ID, v.Name, v.Status, dueSuffix(v.DueDate))
|
|
return 0
|
|
}
|
|
|
|
func dueSuffix(due string) string {
|
|
if due == "" {
|
|
return ""
|
|
}
|
|
return "due " + due
|
|
}
|
|
|
|
// --- category -----------------------------------------------------------------
|
|
|
|
func cmdCategory(args []string, stdout, stderr io.Writer) int {
|
|
if len(args) == 0 {
|
|
return usageErr(stderr, "category: expected list|create (see mred help)")
|
|
}
|
|
sub, rest := args[0], args[1:]
|
|
switch sub {
|
|
case "list":
|
|
return cmdCategoryList(rest, stdout, stderr)
|
|
case "create":
|
|
return cmdCategoryCreate(rest, stdout, stderr)
|
|
default:
|
|
return usageErr(stderr, "category: unknown subcommand %q", sub)
|
|
}
|
|
}
|
|
|
|
func cmdCategoryList(args []string, stdout, stderr io.Writer) int {
|
|
fs, cfgPath, out := newFlags("category list", stderr)
|
|
project := fs.String("p", "", "project identifier (required)")
|
|
pos, err := parseArgs(fs, args)
|
|
if err != nil || len(pos) != 0 || *project == "" {
|
|
return usageErr(stderr, "category list: usage: mred category list -p PROJECT")
|
|
}
|
|
c, err := client(*cfgPath)
|
|
if err != nil {
|
|
return usageErr(stderr, "%v", err)
|
|
}
|
|
cats, err := c.ListCategories(context.Background(), *project)
|
|
if err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
if *out == "json" {
|
|
emitJSON(stdout, map[string]any{"issue_categories": cats})
|
|
return 0
|
|
}
|
|
for _, cat := range cats {
|
|
fmt.Fprintf(stdout, "%-6d %s\n", cat.ID, cat.Name)
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func cmdCategoryCreate(args []string, stdout, stderr io.Writer) int {
|
|
fs, cfgPath, out := newFlags("category create", stderr)
|
|
project := fs.String("p", "", "project identifier (required)")
|
|
name := fs.String("n", "", "category name (required)")
|
|
pos, perr := parseArgs(fs, args)
|
|
if perr != nil || len(pos) != 0 || *project == "" || *name == "" {
|
|
return usageErr(stderr, "category create: usage: mred category create -p PROJECT -n NAME")
|
|
}
|
|
c, err := client(*cfgPath)
|
|
if err != nil {
|
|
return usageErr(stderr, "%v", err)
|
|
}
|
|
cat, err := c.CreateCategory(context.Background(), *project, *name)
|
|
if err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
if *out == "json" {
|
|
emitJSON(stdout, map[string]any{"issue_category": cat})
|
|
return 0
|
|
}
|
|
fmt.Fprintf(stdout, "created category #%d %s\n", cat.ID, cat.Name)
|
|
return 0
|
|
}
|
|
|
|
// --- relation -------------------------------------------------------------------
|
|
|
|
func cmdRelation(args []string, stdout, stderr io.Writer) int {
|
|
if len(args) == 0 {
|
|
return usageErr(stderr, "relation: expected create (see mred help)")
|
|
}
|
|
if args[0] != "create" {
|
|
return usageErr(stderr, "relation: unknown subcommand %q", args[0])
|
|
}
|
|
fs, cfgPath, out := newFlags("relation create", stderr)
|
|
relType := fs.String("type", "", "blocks|relates (required)")
|
|
pos, err := parseArgs(fs, args[1:])
|
|
if err != nil || len(pos) != 2 || *relType == "" {
|
|
return usageErr(stderr, "relation create: usage: mred relation create FROM TO --type blocks|relates")
|
|
}
|
|
if *relType != "blocks" && *relType != "relates" {
|
|
return usageErr(stderr, "relation create: --type must be blocks|relates")
|
|
}
|
|
from, err := strconv.Atoi(pos[0])
|
|
if err != nil {
|
|
return usageErr(stderr, "relation create: FROM must be numeric, got %q", pos[0])
|
|
}
|
|
to, err := strconv.Atoi(pos[1])
|
|
if err != nil {
|
|
return usageErr(stderr, "relation create: TO must be numeric, got %q", pos[1])
|
|
}
|
|
c, err := client(*cfgPath)
|
|
if err != nil {
|
|
return usageErr(stderr, "%v", err)
|
|
}
|
|
rel, err := c.CreateRelation(context.Background(), from, to, *relType)
|
|
if err != nil {
|
|
return apiErr(stderr, err)
|
|
}
|
|
if *out == "json" {
|
|
emitJSON(stdout, map[string]any{"relation": rel})
|
|
return 0
|
|
}
|
|
fmt.Fprintf(stdout, "created relation #%d: %d %s %d\n", rel.ID, from, rel.RelationType, to)
|
|
return 0
|
|
}
|