forked from Gitlink/gitlink-cli
510 lines
17 KiB
Go
510 lines
17 KiB
Go
package issue
|
|
|
|
import (
|
|
"fmt"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
|
|
clierrors "github.com/gitlink-org/gitlink-cli/internal/errors"
|
|
"github.com/gitlink-org/gitlink-cli/shortcuts/common"
|
|
)
|
|
|
|
// v1RepoPath returns the v1 API path prefix: /v1/{owner}/{repo}
|
|
func v1RepoPath(ctx *common.RuntimeContext) string {
|
|
return fmt.Sprintf("/v1/%s/%s", ctx.Owner, ctx.Repo)
|
|
}
|
|
|
|
type existingIssue struct {
|
|
Subject string
|
|
Description string
|
|
}
|
|
|
|
func Shortcuts() []*common.Shortcut {
|
|
return []*common.Shortcut{
|
|
newBatchCloseShortcut(),
|
|
newBatchStatusShortcut(),
|
|
newBatchPriorityShortcut(),
|
|
newBatchAssignShortcut(),
|
|
newBatchLabelShortcut(),
|
|
newBatchCreateShortcut(),
|
|
newBatchDestroyShortcut(),
|
|
newLabelAddShortcut(),
|
|
newLabelRemoveShortcut(),
|
|
newLabelListShortcut(),
|
|
{
|
|
Name: "list",
|
|
Description: "List issues",
|
|
Long: "List issues in a repository with optional filtering by state and pagination.",
|
|
Example: " gitlink-cli issue +list --state open\n gitlink-cli issue +list --state closed --page 1 --limit 50\n gitlink-cli issue +list --columns id,subject,status,priority --state all",
|
|
Flags: []common.Flag{
|
|
{Name: "state", Short: "s", Usage: "Filter by state", Default: "open", Choices: []string{"open", "closed", "all"}},
|
|
{Name: "page", Short: "p", Usage: "Page number", Default: "1"},
|
|
{Name: "limit", Short: "l", Usage: "Items per page", Default: "20"},
|
|
},
|
|
Run: func(ctx *common.RuntimeContext) error {
|
|
if err := ctx.ResolveOwnerRepo(); err != nil {
|
|
return err
|
|
}
|
|
q := url.Values{}
|
|
q.Set("page", ctx.Arg("page"))
|
|
q.Set("limit", ctx.Arg("limit"))
|
|
if s := ctx.Arg("state"); s != "" {
|
|
q.Set("state", s)
|
|
}
|
|
env, err := ctx.CallAPIWithQuery("GET", v1RepoPath(ctx)+"/issues", q)
|
|
if err != nil {
|
|
return clierrors.OpError(clierrors.KindServer, "list", "issues", err).WithCommand(ctx.CommandName)
|
|
}
|
|
return ctx.Output(env)
|
|
},
|
|
},
|
|
{
|
|
Name: "create",
|
|
Description: "Create a new issue",
|
|
Long: "Create a new issue in the repository. Requires --title. Supports --body, --assignee, --milestone, and --label.",
|
|
Example: " gitlink-cli issue +create --title \"Bug: login crash\" --body \"Steps to reproduce...\"\n gitlink-cli issue +create --title \"Feature request\" --assignee zhangsan --label 3",
|
|
DryRun: true,
|
|
DryRunHint: func(ctx *common.RuntimeContext) (string, error) {
|
|
title := ctx.Arg("title")
|
|
return fmt.Sprintf("Create issue: %s", title), nil
|
|
},
|
|
Flags: []common.Flag{
|
|
{Name: "title", Short: "t", Usage: "Issue title", Required: true},
|
|
{Name: "body", Short: "b", Usage: "Issue description"},
|
|
{Name: "assignee", Short: "a", Usage: "Assignee login"},
|
|
{Name: "milestone", Short: "m", Usage: "Milestone ID"},
|
|
{Name: "label", Usage: "Label ID"},
|
|
},
|
|
Run: func(ctx *common.RuntimeContext) error {
|
|
if err := ctx.ResolveOwnerRepo(); err != nil {
|
|
return err
|
|
}
|
|
title, err := ctx.RequireArg("title", `--title "Bug: 登录页崩溃"`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
body := map[string]interface{}{
|
|
"subject": title,
|
|
"status_id": 1, // 1 = open (required by v1 API)
|
|
"priority_id": 2, // 2 = normal
|
|
"done_ratio": 0,
|
|
}
|
|
if desc := ctx.Arg("body"); desc != "" {
|
|
body["description"] = desc
|
|
}
|
|
if a := ctx.Arg("assignee"); a != "" {
|
|
body["assigner_ids"] = []interface{}{a}
|
|
}
|
|
if m := ctx.Arg("milestone"); m != "" {
|
|
body["fixed_version_id"] = m
|
|
}
|
|
env, err := ctx.CallAPI("POST", v1RepoPath(ctx)+"/issues", body)
|
|
if err != nil {
|
|
return clierrors.OpError(clierrors.KindServer, "create", "issue", err).WithCommand(ctx.CommandName)
|
|
}
|
|
return ctx.Output(env)
|
|
},
|
|
},
|
|
{
|
|
Name: "view",
|
|
Description: "View issue details",
|
|
Example: " gitlink-cli issue +view --number 42",
|
|
Flags: []common.Flag{
|
|
{Name: "number", Short: "n", Usage: "Issue number (as shown in the web URL)", Required: true},
|
|
},
|
|
Run: func(ctx *common.RuntimeContext) error {
|
|
if err := ctx.ResolveOwnerRepo(); err != nil {
|
|
return err
|
|
}
|
|
number, err := ctx.RequireArg("number", "--number 42")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
env, err := ctx.CallAPI("GET", fmt.Sprintf("%s/issues/%s", v1RepoPath(ctx), number), nil)
|
|
if err != nil {
|
|
return clierrors.OpError(clierrors.KindNotFound, "view", "issue", err).WithCommand(ctx.CommandName)
|
|
}
|
|
return ctx.Output(env)
|
|
},
|
|
},
|
|
{
|
|
Name: "close",
|
|
Description: "Close an issue",
|
|
Example: " gitlink-cli issue +close --number 42\n gitlink-cli issue +close --number 42 --dry-run",
|
|
DryRun: true,
|
|
DryRunHint: func(ctx *common.RuntimeContext) (string, error) {
|
|
number := ctx.Arg("number")
|
|
return fmt.Sprintf("Close issue #%s", number), nil
|
|
},
|
|
Flags: []common.Flag{
|
|
{Name: "number", Short: "n", Usage: "Issue number (as shown in the web URL)", Required: true},
|
|
},
|
|
Run: func(ctx *common.RuntimeContext) error {
|
|
if err := ctx.ResolveOwnerRepo(); err != nil {
|
|
return err
|
|
}
|
|
number, err := ctx.RequireArg("number", "--number 42")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
current, err := fetchExistingIssue(ctx, number)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
body := map[string]interface{}{
|
|
"subject": current.Subject,
|
|
"description": current.Description,
|
|
"status_id": 5, // 5 = closed
|
|
}
|
|
env, err := ctx.CallAPI("PATCH", fmt.Sprintf("%s/issues/%s", v1RepoPath(ctx), number), body)
|
|
if err != nil {
|
|
return clierrors.OpError(clierrors.KindServer, "close", "issue", err).WithCommand(ctx.CommandName)
|
|
}
|
|
return ctx.Output(env)
|
|
},
|
|
},
|
|
{
|
|
Name: "reopen",
|
|
Description: "Reopen a closed issue",
|
|
Flags: []common.Flag{
|
|
{Name: "number", Short: "n", Usage: "Issue number (as shown in the web URL)", Required: true},
|
|
},
|
|
Run: func(ctx *common.RuntimeContext) error {
|
|
if err := ctx.ResolveOwnerRepo(); err != nil {
|
|
return err
|
|
}
|
|
number, err := ctx.RequireArg("number", "--number 42")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
current, err := fetchExistingIssue(ctx, number)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
body := map[string]interface{}{
|
|
"subject": current.Subject,
|
|
"description": current.Description,
|
|
"status_id": 1, // 1 = open
|
|
}
|
|
env, err := ctx.CallAPI("PATCH", fmt.Sprintf("%s/issues/%s", v1RepoPath(ctx), number), body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return ctx.Output(env)
|
|
},
|
|
},
|
|
{
|
|
Name: "update",
|
|
Description: "Update an issue",
|
|
Example: " gitlink-cli issue +update --number 42 --title \"Updated title\"\n gitlink-cli issue +update --number 42 --state closed",
|
|
DryRun: true,
|
|
DryRunHint: func(ctx *common.RuntimeContext) (string, error) {
|
|
number := ctx.Arg("number")
|
|
return fmt.Sprintf("Update issue #%s", number), nil
|
|
},
|
|
Flags: []common.Flag{
|
|
{Name: "number", Short: "n", Usage: "Issue number (as shown in the web URL)", Required: true},
|
|
{Name: "title", Short: "t", Usage: "New title"},
|
|
{Name: "body", Short: "b", Usage: "New description"},
|
|
{Name: "state", Short: "s", Usage: "New state", Validate: validateIssueState},
|
|
},
|
|
Run: func(ctx *common.RuntimeContext) error {
|
|
if err := ctx.ResolveOwnerRepo(); err != nil {
|
|
return err
|
|
}
|
|
number, err := ctx.RequireArg("number", "--number 42")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
title := ctx.Arg("title")
|
|
description := ctx.Arg("body")
|
|
state := ctx.Arg("state")
|
|
if title == "" && description == "" && state == "" {
|
|
return clierrors.InputError(
|
|
"at least one of --title, --body, or --state is required",
|
|
"至少需要提供 --title、--body 或 --state 中的一个参数",
|
|
).WithCommand(ctx.CommandName)
|
|
}
|
|
|
|
current, err := fetchExistingIssue(ctx, number)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
body := map[string]interface{}{
|
|
"subject": current.Subject,
|
|
"description": current.Description,
|
|
}
|
|
if t := ctx.Arg("title"); t != "" {
|
|
body["subject"] = t
|
|
}
|
|
if b := ctx.Arg("body"); b != "" {
|
|
body["description"] = b
|
|
}
|
|
if s := ctx.Arg("state"); s != "" {
|
|
statusID, err := issueStateToStatusID(s)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
body["status_id"] = statusID
|
|
}
|
|
env, err := ctx.CallAPI("PATCH", fmt.Sprintf("%s/issues/%s", v1RepoPath(ctx), number), body)
|
|
if err != nil {
|
|
return clierrors.OpError(clierrors.KindServer, "update", "issue", err).WithCommand(ctx.CommandName)
|
|
}
|
|
return ctx.Output(env)
|
|
},
|
|
},
|
|
{
|
|
Name: "comment",
|
|
Description: "Add a comment to an issue",
|
|
DryRun: true,
|
|
DryRunHint: func(ctx *common.RuntimeContext) (string, error) {
|
|
number := ctx.Arg("number")
|
|
return fmt.Sprintf("Add comment to issue #%s", number), nil
|
|
},
|
|
Flags: []common.Flag{
|
|
{Name: "number", Short: "n", Usage: "Issue number (as shown in the web URL)", Required: true},
|
|
{Name: "body", Short: "b", Usage: "Comment body", Required: true},
|
|
},
|
|
Run: func(ctx *common.RuntimeContext) error {
|
|
if err := ctx.ResolveOwnerRepo(); err != nil {
|
|
return err
|
|
}
|
|
number, err := ctx.RequireArg("number", "--number 42")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
body, err := ctx.RequireArg("body", `--body "可以这样复现..."`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
payload := map[string]interface{}{
|
|
"notes": body,
|
|
}
|
|
env, err := ctx.CallAPI("POST", fmt.Sprintf("%s/issues/%s/journals", v1RepoPath(ctx), number), payload)
|
|
if err != nil {
|
|
return clierrors.OpError(clierrors.KindServer, "comment", "issue", err).WithCommand(ctx.CommandName)
|
|
}
|
|
return ctx.Output(env)
|
|
},
|
|
},
|
|
// === 元数据查询 ===
|
|
{
|
|
Name: "statuses",
|
|
Description: "List issue statuses",
|
|
Run: func(ctx *common.RuntimeContext) error {
|
|
if err := ctx.ResolveOwnerRepo(); err != nil {
|
|
return err
|
|
}
|
|
env, err := ctx.CallAPIWithQuery("GET", v1RepoPath(ctx)+"/issue_statues", nil)
|
|
if err != nil {
|
|
return clierrors.OpError(clierrors.KindServer, "list", "issue statuses", err).WithCommand(ctx.CommandName)
|
|
}
|
|
return ctx.Output(env)
|
|
},
|
|
},
|
|
{
|
|
Name: "authors",
|
|
Description: "List issue authors",
|
|
Flags: []common.Flag{
|
|
{Name: "keyword", Short: "k", Usage: "Search keyword"},
|
|
},
|
|
Run: func(ctx *common.RuntimeContext) error {
|
|
if err := ctx.ResolveOwnerRepo(); err != nil {
|
|
return err
|
|
}
|
|
q := url.Values{}
|
|
if kw := ctx.Arg("keyword"); kw != "" {
|
|
q.Set("keyword", kw)
|
|
}
|
|
env, err := ctx.CallAPIWithQuery("GET", v1RepoPath(ctx)+"/issue_authors", q)
|
|
if err != nil {
|
|
return clierrors.OpError(clierrors.KindServer, "list", "issue authors", err).WithCommand(ctx.CommandName)
|
|
}
|
|
return ctx.Output(env)
|
|
},
|
|
},
|
|
{
|
|
Name: "assigners",
|
|
Description: "List issue assignees",
|
|
Flags: []common.Flag{
|
|
{Name: "keyword", Short: "k", Usage: "Search keyword"},
|
|
},
|
|
Run: func(ctx *common.RuntimeContext) error {
|
|
if err := ctx.ResolveOwnerRepo(); err != nil {
|
|
return err
|
|
}
|
|
q := url.Values{}
|
|
if kw := ctx.Arg("keyword"); kw != "" {
|
|
q.Set("keyword", kw)
|
|
}
|
|
env, err := ctx.CallAPIWithQuery("GET", v1RepoPath(ctx)+"/issue_assigners", q)
|
|
if err != nil {
|
|
return clierrors.OpError(clierrors.KindServer, "list", "issue assignees", err).WithCommand(ctx.CommandName)
|
|
}
|
|
return ctx.Output(env)
|
|
},
|
|
},
|
|
{
|
|
Name: "priorities",
|
|
Description: "List issue priorities",
|
|
Run: func(ctx *common.RuntimeContext) error {
|
|
if err := ctx.ResolveOwnerRepo(); err != nil {
|
|
return err
|
|
}
|
|
env, err := ctx.CallAPIWithQuery("GET", v1RepoPath(ctx)+"/issue_priorities", nil)
|
|
if err != nil {
|
|
return clierrors.OpError(clierrors.KindServer, "list", "issue priorities", err).WithCommand(ctx.CommandName)
|
|
}
|
|
return ctx.Output(env)
|
|
},
|
|
},
|
|
// === 评论管理 ===
|
|
{
|
|
Name: "comment-edit",
|
|
Description: "Edit an issue comment",
|
|
Flags: []common.Flag{
|
|
{Name: "number", Short: "n", Usage: "Issue number", Required: true},
|
|
{Name: "comment-id", Short: "c", Usage: "Comment ID", Required: true},
|
|
{Name: "body", Short: "b", Usage: "New comment body", Required: true},
|
|
},
|
|
Run: func(ctx *common.RuntimeContext) error {
|
|
if err := ctx.ResolveOwnerRepo(); err != nil {
|
|
return err
|
|
}
|
|
number, err := ctx.RequireArg("number", "--number 42")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
commentID, err := ctx.RequireArg("comment-id", "--comment-id 123")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
body, err := ctx.RequireArg("body", `--body "updated comment"`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
payload := map[string]interface{}{
|
|
"notes": body,
|
|
"attachment_ids": []int{},
|
|
}
|
|
env, err := ctx.CallAPI("PATCH", fmt.Sprintf("%s/issues/%s/journals/%s", v1RepoPath(ctx), number, commentID), payload)
|
|
if err != nil {
|
|
return clierrors.OpError(clierrors.KindServer, "edit", "comment", err).WithCommand(ctx.CommandName)
|
|
}
|
|
return ctx.Output(env)
|
|
},
|
|
},
|
|
{
|
|
Name: "comment-delete",
|
|
Description: "Delete an issue comment",
|
|
DryRun: true,
|
|
DryRunHint: func(ctx *common.RuntimeContext) (string, error) {
|
|
return fmt.Sprintf("删除 Issue #%s 的评论 #%s", ctx.Arg("number"), ctx.Arg("comment-id")), nil
|
|
},
|
|
Flags: []common.Flag{
|
|
{Name: "number", Short: "n", Usage: "Issue number", Required: true},
|
|
{Name: "comment-id", Short: "c", Usage: "Comment ID", Required: true},
|
|
},
|
|
Run: func(ctx *common.RuntimeContext) error {
|
|
if err := ctx.ResolveOwnerRepo(); err != nil {
|
|
return err
|
|
}
|
|
number, err := ctx.RequireArg("number", "--number 42")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
commentID, err := ctx.RequireArg("comment-id", "--comment-id 123")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
env, err := ctx.CallAPI("DELETE", fmt.Sprintf("%s/issues/%s/journals/%s", v1RepoPath(ctx), number, commentID), nil)
|
|
if err != nil {
|
|
return clierrors.OpError(clierrors.KindServer, "delete", "comment", err).WithCommand(ctx.CommandName)
|
|
}
|
|
return ctx.Output(env)
|
|
},
|
|
},
|
|
{
|
|
Name: "replies",
|
|
Description: "List replies to a comment",
|
|
Flags: []common.Flag{
|
|
{Name: "number", Short: "n", Usage: "Issue number", Required: true},
|
|
{Name: "comment-id", Short: "c", Usage: "Parent comment ID", Required: true},
|
|
{Name: "page", Short: "p", Usage: "Page number", Default: "1"},
|
|
{Name: "limit", Short: "l", Usage: "Items per page", Default: "20"},
|
|
},
|
|
Run: func(ctx *common.RuntimeContext) error {
|
|
if err := ctx.ResolveOwnerRepo(); err != nil {
|
|
return err
|
|
}
|
|
number, err := ctx.RequireArg("number", "--number 42")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
commentID, err := ctx.RequireArg("comment-id", "--comment-id 123")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
q := url.Values{}
|
|
q.Set("page", ctx.Arg("page"))
|
|
q.Set("limit", ctx.Arg("limit"))
|
|
env, err := ctx.CallAPIWithQuery("GET", fmt.Sprintf("%s/issues/%s/journals/%s/children_journals", v1RepoPath(ctx), number, commentID), q)
|
|
if err != nil {
|
|
return clierrors.OpError(clierrors.KindServer, "list", "replies", err).WithCommand(ctx.CommandName)
|
|
}
|
|
return ctx.Output(env)
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func fetchExistingIssue(ctx *common.RuntimeContext, number string) (*existingIssue, error) {
|
|
getEnv, err := ctx.CallAPI("GET", fmt.Sprintf("%s/issues/%s", v1RepoPath(ctx), number), nil)
|
|
if err != nil {
|
|
return nil, clierrors.OpError(clierrors.KindNotFound, "view", "issue", err).WithCommand(ctx.CommandName)
|
|
}
|
|
issueData, ok := getEnv.Data.(map[string]interface{})
|
|
if !ok {
|
|
return nil, clierrors.InputError("failed to parse issue data", "API 返回格式异常，请稍后重试").WithCommand(ctx.CommandName)
|
|
}
|
|
subject, _ := issueData["subject"].(string)
|
|
if subject == "" {
|
|
return nil, clierrors.InputError("failed to parse issue subject", "API 返回数据中缺少 subject 字段，请稍后重试").WithCommand(ctx.CommandName)
|
|
}
|
|
description, _ := issueData["description"].(string)
|
|
return &existingIssue{
|
|
Subject: subject,
|
|
Description: description,
|
|
}, nil
|
|
}
|
|
|
|
func validateIssueState(state string) error {
|
|
state = strings.ToLower(strings.TrimSpace(state))
|
|
if state == "open" || state == "closed" {
|
|
return nil
|
|
}
|
|
if _, err := strconv.Atoi(state); err == nil {
|
|
return nil
|
|
}
|
|
return fmt.Errorf("must be \"open\", \"closed\", or a numeric status_id, got %q", state)
|
|
}
|
|
|
|
func issueStateToStatusID(state string) (interface{}, error) {
|
|
switch strings.ToLower(strings.TrimSpace(state)) {
|
|
case "open":
|
|
return 1, nil
|
|
case "closed":
|
|
return 5, nil
|
|
default:
|
|
if id, err := strconv.Atoi(state); err == nil {
|
|
return id, nil
|
|
}
|
|
return nil, fmt.Errorf("invalid state: %s", state)
|
|
}
|
|
}
|