343 lines
8.3 KiB
Go
343 lines
8.3 KiB
Go
package commands
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
|
|
"git.hangman-lab.top/zhi/HarborForge.Cli/internal/client"
|
|
"git.hangman-lab.top/zhi/HarborForge.Cli/internal/config"
|
|
"git.hangman-lab.top/zhi/HarborForge.Cli/internal/output"
|
|
)
|
|
|
|
// milestoneResponse matches the backend MilestoneResponse schema.
|
|
type milestoneResponse struct {
|
|
ID int `json:"id"`
|
|
Code string `json:"code"`
|
|
Title string `json:"title"`
|
|
Description *string `json:"description"`
|
|
Status string `json:"status"`
|
|
DueDate *string `json:"due_date"`
|
|
ProjectCode string `json:"project_code"`
|
|
CreatedAt string `json:"created_at"`
|
|
}
|
|
|
|
// milestoneProgressResponse matches the backend progress response.
|
|
type milestoneProgressResponse struct {
|
|
Code string `json:"code"`
|
|
Title string `json:"title"`
|
|
Status string `json:"status"`
|
|
TotalTasks int `json:"total_tasks"`
|
|
DoneTasks int `json:"done_tasks"`
|
|
Progress float64 `json:"progress"`
|
|
}
|
|
|
|
// RunMilestoneList implements `hf milestone list --project <project-code>`.
|
|
func RunMilestoneList(args []string, tokenFlag string) {
|
|
token := ResolveToken(tokenFlag)
|
|
|
|
query := ""
|
|
for i := 0; i < len(args); i++ {
|
|
switch args[i] {
|
|
case "--project":
|
|
if i+1 >= len(args) {
|
|
output.Error("--project requires a value")
|
|
}
|
|
i++
|
|
query = appendQuery(query, "project_code", args[i])
|
|
case "--status":
|
|
if i+1 >= len(args) {
|
|
output.Error("--status requires a value")
|
|
}
|
|
i++
|
|
query = appendQuery(query, "status", args[i])
|
|
case "--order-by":
|
|
if i+1 >= len(args) {
|
|
output.Error("--order-by requires a value")
|
|
}
|
|
i++
|
|
query = appendQuery(query, "order_by", args[i])
|
|
default:
|
|
output.Errorf("unknown flag: %s", args[i])
|
|
}
|
|
}
|
|
|
|
cfg, err := config.Load()
|
|
if err != nil {
|
|
output.Errorf("config error: %v", err)
|
|
}
|
|
c := client.New(cfg.BaseURL, token)
|
|
path := "/milestones"
|
|
if query != "" {
|
|
path += "?" + query
|
|
}
|
|
data, err := c.Get(path)
|
|
if err != nil {
|
|
output.Errorf("failed to list milestones: %v", err)
|
|
}
|
|
|
|
if output.JSONMode {
|
|
var raw json.RawMessage
|
|
if err := json.Unmarshal(data, &raw); err != nil {
|
|
output.Errorf("invalid JSON response: %v", err)
|
|
}
|
|
output.PrintJSON(raw)
|
|
return
|
|
}
|
|
|
|
var milestones []milestoneResponse
|
|
if err := json.Unmarshal(data, &milestones); err != nil {
|
|
output.Errorf("cannot parse milestone list: %v", err)
|
|
}
|
|
|
|
headers := []string{"CODE", "TITLE", "STATUS", "DUE DATE", "PROJECT"}
|
|
var rows [][]string
|
|
for _, m := range milestones {
|
|
due := ""
|
|
if m.DueDate != nil {
|
|
due = *m.DueDate
|
|
}
|
|
rows = append(rows, []string{m.Code, m.Title, m.Status, due, m.ProjectCode})
|
|
}
|
|
output.PrintTable(headers, rows)
|
|
}
|
|
|
|
// RunMilestoneGet implements `hf milestone get <milestone-code>`.
|
|
func RunMilestoneGet(milestoneCode, tokenFlag string) {
|
|
token := ResolveToken(tokenFlag)
|
|
cfg, err := config.Load()
|
|
if err != nil {
|
|
output.Errorf("config error: %v", err)
|
|
}
|
|
c := client.New(cfg.BaseURL, token)
|
|
data, err := c.Get("/milestones/" + milestoneCode)
|
|
if err != nil {
|
|
output.Errorf("failed to get milestone: %v", err)
|
|
}
|
|
|
|
if output.JSONMode {
|
|
var raw json.RawMessage
|
|
if err := json.Unmarshal(data, &raw); err != nil {
|
|
output.Errorf("invalid JSON response: %v", err)
|
|
}
|
|
output.PrintJSON(raw)
|
|
return
|
|
}
|
|
|
|
var m milestoneResponse
|
|
if err := json.Unmarshal(data, &m); err != nil {
|
|
output.Errorf("cannot parse milestone: %v", err)
|
|
}
|
|
|
|
desc := ""
|
|
if m.Description != nil {
|
|
desc = *m.Description
|
|
}
|
|
due := ""
|
|
if m.DueDate != nil {
|
|
due = *m.DueDate
|
|
}
|
|
output.PrintKeyValue(
|
|
"code", m.Code,
|
|
"title", m.Title,
|
|
"description", desc,
|
|
"status", m.Status,
|
|
"due-date", due,
|
|
"project", m.ProjectCode,
|
|
"created", m.CreatedAt,
|
|
)
|
|
}
|
|
|
|
// RunMilestoneCreate implements `hf milestone create`.
|
|
func RunMilestoneCreate(args []string, tokenFlag string) {
|
|
token := ResolveToken(tokenFlag)
|
|
|
|
project, title, desc, due := "", "", "", ""
|
|
for i := 0; i < len(args); i++ {
|
|
switch args[i] {
|
|
case "--project":
|
|
if i+1 >= len(args) {
|
|
output.Error("--project requires a value")
|
|
}
|
|
i++
|
|
project = args[i]
|
|
case "--title":
|
|
if i+1 >= len(args) {
|
|
output.Error("--title requires a value")
|
|
}
|
|
i++
|
|
title = args[i]
|
|
case "--desc":
|
|
if i+1 >= len(args) {
|
|
output.Error("--desc requires a value")
|
|
}
|
|
i++
|
|
desc = args[i]
|
|
case "--due":
|
|
if i+1 >= len(args) {
|
|
output.Error("--due requires a value")
|
|
}
|
|
i++
|
|
due = args[i]
|
|
default:
|
|
output.Errorf("unknown flag: %s", args[i])
|
|
}
|
|
}
|
|
|
|
if project == "" || title == "" {
|
|
output.Error("usage: hf milestone create --project <project-code> --title <title>")
|
|
}
|
|
|
|
payload := map[string]interface{}{
|
|
"project_code": project,
|
|
"title": title,
|
|
}
|
|
if desc != "" {
|
|
payload["description"] = desc
|
|
}
|
|
if due != "" {
|
|
payload["due_date"] = due
|
|
}
|
|
|
|
body, err := json.Marshal(payload)
|
|
if err != nil {
|
|
output.Errorf("cannot marshal payload: %v", err)
|
|
}
|
|
|
|
cfg, err := config.Load()
|
|
if err != nil {
|
|
output.Errorf("config error: %v", err)
|
|
}
|
|
c := client.New(cfg.BaseURL, token)
|
|
data, err := c.Post("/milestones", bytes.NewReader(body))
|
|
if err != nil {
|
|
output.Errorf("failed to create milestone: %v", err)
|
|
}
|
|
|
|
if output.JSONMode {
|
|
var raw json.RawMessage
|
|
if err := json.Unmarshal(data, &raw); err != nil {
|
|
output.Errorf("invalid JSON response: %v", err)
|
|
}
|
|
output.PrintJSON(raw)
|
|
return
|
|
}
|
|
|
|
var m milestoneResponse
|
|
if err := json.Unmarshal(data, &m); err != nil {
|
|
fmt.Printf("milestone created: %s\n", title)
|
|
return
|
|
}
|
|
fmt.Printf("milestone created: %s (code: %s)\n", m.Title, m.Code)
|
|
}
|
|
|
|
// RunMilestoneUpdate implements `hf milestone update <milestone-code>`.
|
|
func RunMilestoneUpdate(milestoneCode string, args []string, tokenFlag string) {
|
|
token := ResolveToken(tokenFlag)
|
|
|
|
payload := make(map[string]interface{})
|
|
for i := 0; i < len(args); i++ {
|
|
switch args[i] {
|
|
case "--title":
|
|
if i+1 >= len(args) {
|
|
output.Error("--title requires a value")
|
|
}
|
|
i++
|
|
payload["title"] = args[i]
|
|
case "--desc":
|
|
if i+1 >= len(args) {
|
|
output.Error("--desc requires a value")
|
|
}
|
|
i++
|
|
payload["description"] = args[i]
|
|
case "--status":
|
|
if i+1 >= len(args) {
|
|
output.Error("--status requires a value")
|
|
}
|
|
i++
|
|
payload["status"] = args[i]
|
|
case "--due":
|
|
if i+1 >= len(args) {
|
|
output.Error("--due requires a value")
|
|
}
|
|
i++
|
|
payload["due_date"] = args[i]
|
|
default:
|
|
output.Errorf("unknown flag: %s", args[i])
|
|
}
|
|
}
|
|
|
|
if len(payload) == 0 {
|
|
output.Error("nothing to update — provide at least one flag")
|
|
}
|
|
|
|
body, err := json.Marshal(payload)
|
|
if err != nil {
|
|
output.Errorf("cannot marshal payload: %v", err)
|
|
}
|
|
|
|
cfg, err := config.Load()
|
|
if err != nil {
|
|
output.Errorf("config error: %v", err)
|
|
}
|
|
c := client.New(cfg.BaseURL, token)
|
|
_, err = c.Patch("/milestones/"+milestoneCode, bytes.NewReader(body))
|
|
if err != nil {
|
|
output.Errorf("failed to update milestone: %v", err)
|
|
}
|
|
|
|
fmt.Printf("milestone updated: %s\n", milestoneCode)
|
|
}
|
|
|
|
// RunMilestoneDelete implements `hf milestone delete <milestone-code>`.
|
|
func RunMilestoneDelete(milestoneCode, tokenFlag string) {
|
|
token := ResolveToken(tokenFlag)
|
|
cfg, err := config.Load()
|
|
if err != nil {
|
|
output.Errorf("config error: %v", err)
|
|
}
|
|
c := client.New(cfg.BaseURL, token)
|
|
_, err = c.Delete("/milestones/" + milestoneCode)
|
|
if err != nil {
|
|
output.Errorf("failed to delete milestone: %v", err)
|
|
}
|
|
fmt.Printf("milestone deleted: %s\n", milestoneCode)
|
|
}
|
|
|
|
// RunMilestoneProgress implements `hf milestone progress <milestone-code>`.
|
|
func RunMilestoneProgress(milestoneCode, tokenFlag string) {
|
|
token := ResolveToken(tokenFlag)
|
|
cfg, err := config.Load()
|
|
if err != nil {
|
|
output.Errorf("config error: %v", err)
|
|
}
|
|
c := client.New(cfg.BaseURL, token)
|
|
data, err := c.Get("/milestones/" + milestoneCode + "/progress")
|
|
if err != nil {
|
|
output.Errorf("failed to get milestone progress: %v", err)
|
|
}
|
|
|
|
if output.JSONMode {
|
|
var raw json.RawMessage
|
|
if err := json.Unmarshal(data, &raw); err != nil {
|
|
output.Errorf("invalid JSON response: %v", err)
|
|
}
|
|
output.PrintJSON(raw)
|
|
return
|
|
}
|
|
|
|
var p milestoneProgressResponse
|
|
if err := json.Unmarshal(data, &p); err != nil {
|
|
output.Errorf("cannot parse progress: %v", err)
|
|
}
|
|
|
|
output.PrintKeyValue(
|
|
"code", p.Code,
|
|
"title", p.Title,
|
|
"status", p.Status,
|
|
"total-tasks", fmt.Sprintf("%d", p.TotalTasks),
|
|
"done-tasks", fmt.Sprintf("%d", p.DoneTasks),
|
|
"progress", fmt.Sprintf("%.1f%%", p.Progress*100),
|
|
)
|
|
}
|