From eab78573f5df814f497c284bdaff1b12048744cc Mon Sep 17 00:00:00 2001 From: Seonghyeon Lim Date: Mon, 8 Aug 2022 22:37:17 +0900 Subject: [PATCH] feat: add sprint agile apis --- board.go | 16 +++--- examples/sprint/main.go | 124 ++++++++++++++++++++++++++++++++++++++++ sprint.go | 91 +++++++++++++++++++++++++++++ sprint_test.go | 82 ++++++++++++++++++++++++++ 4 files changed, 305 insertions(+), 8 deletions(-) create mode 100644 examples/sprint/main.go diff --git a/board.go b/board.go index 890d6e0a..10663da7 100644 --- a/board.go +++ b/board.go @@ -65,14 +65,14 @@ type SprintsList struct { // Sprint represents a sprint on Jira agile board type Sprint struct { - ID int `json:"id" structs:"id"` - Name string `json:"name" structs:"name"` - CompleteDate *time.Time `json:"completeDate" structs:"completeDate"` - EndDate *time.Time `json:"endDate" structs:"endDate"` - StartDate *time.Time `json:"startDate" structs:"startDate"` - OriginBoardID int `json:"originBoardId" structs:"originBoardId"` - Self string `json:"self" structs:"self"` - State string `json:"state" structs:"state"` + ID int `json:"id,omitempty" structs:"id,omitempty"` + Name string `json:"name,omitempty" structs:"name,omitempty"` + CompleteDate *time.Time `json:"completeDate,omitempty" structs:"completeDate,omitempty"` + EndDate *time.Time `json:"endDate,omitempty" structs:"endDate,omitempty"` + StartDate *time.Time `json:"startDate,omitempty" structs:"startDate,omitempty"` + OriginBoardID int `json:"originBoardId,omitempty" structs:"originBoardId,omitempty"` + Self string `json:"self,omitempty" structs:"self,omitempty"` + State string `json:"state,omitempty" structs:"state,omitempty"` } // BoardConfiguration represents a boardConfiguration of a jira board diff --git a/examples/sprint/main.go b/examples/sprint/main.go new file mode 100644 index 00000000..e01d9ad8 --- /dev/null +++ b/examples/sprint/main.go @@ -0,0 +1,124 @@ +package main + +import ( + "bufio" + "fmt" + "golang.org/x/term" + "log" + "os" + "strconv" + "syscall" + "time" + + jira "github.com/andygrunwald/go-jira" +) + +// This example implement the behaviour of Jira's "Complete sprint" button. +// It creates a new sprint and close the sprint currently active. +// Then all issues under the closed sprint are moved to the newly created sprint. +func main() { + sc := bufio.NewScanner(os.Stdin) + + fmt.Print("Jira URL: ") + sc.Scan() + jiraURL := sc.Text() + + fmt.Print("Jira Username: ") + sc.Scan() + username := sc.Text() + + fmt.Print("Jira Password: ") + bytePassword, _ := term.ReadPassword(int(syscall.Stdin)) + password := string(bytePassword) + + fmt.Print("\nJira Board ID : ") + sc.Scan() + boardIDstr := sc.Text() + boardID, err := strconv.Atoi(boardIDstr) + if err != nil { + log.Fatal(err) + } + + tp := jira.BasicAuthTransport{ + Username: username, + Password: password, + } + + client, err := jira.NewClient(tp.Client(), jiraURL) + if err != nil { + log.Println(err) + return + } + + // create a new sprint + start := time.Now() + end := start.AddDate(0, 0, 7) + s := jira.Sprint{ + Name: "New Sprint", + StartDate: &start, + EndDate: &end, + OriginBoardID: boardID, + } + futureSprint, _, err := client.Sprint.Create(&s) + if err != nil { + log.Fatal(err) + } + log.Println("New sprint created ID:", futureSprint.ID) + + // get the sprint currently active + sprints, _, err := client.Board.GetAllSprintsWithOptions(boardID, &jira.GetAllSprintsOptions{ + State: "active", + }) + if err != nil { + log.Fatal(err) + } + if len(sprints.Values) != 1 { + log.Fatal("Retrieved active sprint list has invalid length") + } + activeSprint := sprints.Values[0] + log.Println("Active sprint retrieved ID:", activeSprint.ID) + + // get all non-subtask issues of the active sprint + issues, _, err := client.Sprint.GetIssuesForSprintWithOptions(activeSprint.ID, &jira.GetIssuesForSprintOptions{ + Jql: "type NOT IN ('Sub-task')", + }) + if err != nil { + log.Fatal(err) + } + log.Println("All non-subtask issues of the active sprint retrieved length:", len(issues)) + for _, i := range issues { + log.Printf("\t(%s) %s", i.ID, i.Fields.Summary) + } + + // complete the active sprint + completeParam := make(map[string]interface{}) + completeParam["state"] = "closed" + resp, err := client.Sprint.UpdateSprint(activeSprint.ID, completeParam) + if err != nil { + log.Fatal(err) + } + resp.Body.Close() + log.Println("Active sprint completed") + + // move the issues previously under the active sprint to the newly created sprint + var issueIDs []string + for _, i := range issues { + issueIDs = append(issueIDs, i.ID) + } + resp, err = client.Sprint.MoveIssuesToSprint(futureSprint.ID, issueIDs) + if err != nil { + log.Fatal(err) + } + resp.Body.Close() + log.Println("The issues from the active sprint have been moved to the new sprint") + + // start the newly created sprint + startParam := make(map[string]interface{}) + startParam["state"] = "active" + resp, err = client.Sprint.UpdateSprint(futureSprint.ID, startParam) + if err != nil { + log.Fatal(err) + } + resp.Body.Close() + log.Println("The new sprint has been started") +} diff --git a/sprint.go b/sprint.go index f0f98d6f..841e5147 100644 --- a/sprint.go +++ b/sprint.go @@ -23,6 +23,13 @@ type IssuesInSprintResult struct { Issues []Issue `json:"issues"` } +type GetIssuesForSprintOptions struct { + // Jql filters results to issues that match the given JQL. + Jql string `url:"jql,omitempty"` + + SearchOptions +} + // MoveIssuesToSprintWithContext moves issues to a sprint, for a given sprint Id. // Issues can only be moved to open or active sprints. // The maximum number of issues that can be moved in one operation is 50. @@ -81,6 +88,39 @@ func (s *SprintService) GetIssuesForSprint(sprintID int) ([]Issue, *Response, er return s.GetIssuesForSprintWithContext(context.Background(), sprintID) } +// GetIssuesForSprintWithOptionsWithContext returns all issues in a sprint, for a given sprint Id. +// The issues are filtered out with the given options. +// This only includes issues that the user has permission to view. +// By default, the returned issues are ordered by rank. +// +// Jira API Docs: https://docs.atlassian.com/jira-software/REST/cloud/#agile/1.0/sprint-getIssuesForSprint +func (s *SprintService) GetIssuesForSprintWithOptionsWithContext(ctx context.Context, sprintID int, options *GetIssuesForSprintOptions) ([]Issue, *Response, error) { + apiEndpoint := fmt.Sprintf("rest/agile/1.0/sprint/%d/issue", sprintID) + url, err := addOptions(apiEndpoint, options) + if err != nil { + return nil, nil, err + } + + req, err := s.client.NewRequestWithContext(ctx, "GET", url, nil) + + if err != nil { + return nil, nil, err + } + + result := new(IssuesInSprintResult) + resp, err := s.client.Do(req, result) + if err != nil { + err = NewJiraError(resp, err) + } + + return result.Issues, resp, err +} + +// GetIssuesForSprintWithOptions wraps GetIssuesForSprintWithOptionsWithContext using the background context. +func (s *SprintService) GetIssuesForSprintWithOptions(sprintID int, options *GetIssuesForSprintOptions) ([]Issue, *Response, error) { + return s.GetIssuesForSprintWithOptionsWithContext(context.Background(), sprintID, options) +} + // GetIssueWithContext returns a full representation of the issue for the given issue key. // Jira will attempt to identify the issue by the issueIdOrKey path parameter. // This can be an issue id, or an issue key. @@ -123,3 +163,54 @@ func (s *SprintService) GetIssueWithContext(ctx context.Context, issueID string, func (s *SprintService) GetIssue(issueID string, options *GetQueryOptions) (*Issue, *Response, error) { return s.GetIssueWithContext(context.Background(), issueID, options) } + +// CreateWithContext creates a sprint from a JSON representation. +// +// Jira API docs: https://docs.atlassian.com/jira-software/REST/7.3.1/#agile/1.0/sprint-createSprint +func (s *SprintService) CreateWithContext(ctx context.Context, sprint *Sprint) (*Sprint, *Response, error) { + apiEndpoint := "rest/agile/1.0/sprint" + req, err := s.client.NewRequestWithContext(ctx, "POST", apiEndpoint, sprint) + if err != nil { + return nil, nil, err + } + + created := new(Sprint) + resp, err := s.client.Do(req, created) + if err != nil { + jerr := NewJiraError(resp, err) + return nil, resp, jerr + } + + return created, resp, nil +} + +// Create wraps CreateWithContext using the background context. +func (s *SprintService) Create(sprint *Sprint) (*Sprint, *Response, error) { + return s.CreateWithContext(context.Background(), sprint) +} + +// UpdateSprintWithContext partially updates a sprint from a JSON representation. The sprint is found by ID. +// +// Jira API docs: https://docs.atlassian.com/jira-software/REST/7.3.1/#agile/1.0/sprint-partiallyUpdateSprint +// Caller must close resp.Body +func (s *SprintService) UpdateSprintWithContext(ctx context.Context, sprintID int, data map[string]interface{}) (*Response, error) { + apiEndpoint := fmt.Sprintf("rest/agile/1.0/sprint/%v", sprintID) + + req, err := s.client.NewRequestWithContext(ctx, "POST", apiEndpoint, data) + if err != nil { + return nil, err + } + resp, err := s.client.Do(req, nil) + if err != nil { + jerr := NewJiraError(resp, err) + return resp, jerr + } + + return resp, nil +} + +// UpdateSprint wraps UpdateSprintWithContext using the background context. +// Caller must close resp.Body +func (s *SprintService) UpdateSprint(sprintID int, data map[string]interface{}) (*Response, error) { + return s.UpdateSprintWithContext(context.Background(), sprintID, data) +} diff --git a/sprint_test.go b/sprint_test.go index 64125dbc..b13c0a11 100644 --- a/sprint_test.go +++ b/sprint_test.go @@ -7,6 +7,7 @@ import ( "net/http" "reflect" "testing" + "time" ) func TestSprintService_MoveIssuesToSprint(t *testing.T) { @@ -67,6 +68,35 @@ func TestSprintService_GetIssuesForSprint(t *testing.T) { } +func TestSprintService_GetIssuesForSprintWithOptions(t *testing.T) { + setup() + defer teardown() + testAPIEdpoint := "/rest/agile/1.0/sprint/123/issue" + + raw, err := ioutil.ReadFile("./mocks/issues_in_sprint.json") + if err != nil { + t.Error(err.Error()) + } + testMux.HandleFunc(testAPIEdpoint, func(w http.ResponseWriter, r *http.Request) { + testMethod(t, r, "GET") + testRequestURL(t, r, testAPIEdpoint) + fmt.Fprint(w, string(raw)) + }) + + issues, _, err := testClient.Sprint.GetIssuesForSprintWithOptions(123, &GetIssuesForSprintOptions{ + Jql: "type NOT IN ('Sub-task')", + }) + if err != nil { + t.Errorf("Error given: %v", err) + } + if issues == nil { + t.Error("Expected issues in sprint list. Issues list is nil") + } + if len(issues) != 1 { + t.Errorf("Expect there to be 1 issue in the sprint, found %v", len(issues)) + } +} + func TestSprintService_GetIssue(t *testing.T) { setup() defer teardown() @@ -114,3 +144,55 @@ func TestSprintService_GetIssue(t *testing.T) { t.Errorf("Error given: %s", err) } } + +func TestSprintService_Create(t *testing.T) { + setup() + defer teardown() + + testAPIEndpoint := "/rest/agile/1.0/sprint" + + testMux.HandleFunc(testAPIEndpoint, func(w http.ResponseWriter, r *http.Request) { + testMethod(t, r, "POST") + testRequestURL(t, r, testAPIEndpoint) + fmt.Fprint(w, `{"id":11,"self":"http://www.example.com/jira/rest/agile/1.0/sprint/11","state":"future","name":"Test Sprint","startDate":"2022-08-09T12:34:56.000Z","endDate":"2022-08-16T12:34:56.000Z","originBoardId":17}`) + }) + + start := time.Date(2022, 8, 9, 12, 34, 56, 0, time.UTC) + end := time.Date(2022, 8, 16, 12, 34, 56, 0, time.UTC) + s := Sprint{ + Name: "Test Sprint", + StartDate: &start, + EndDate: &end, + OriginBoardID: 17, + } + sprint, _, err := testClient.Sprint.Create(&s) + if sprint == nil { + t.Error("Expected sprint. Sprint is nil") + } + if err != nil { + t.Errorf("Error given: %s", err) + } +} + +func TestSprintService_UpdateSprint(t *testing.T) { + setup() + defer teardown() + + testAPIEndpoint := "/rest/agile/1.0/sprint/11" + + testMux.HandleFunc(testAPIEndpoint, func(w http.ResponseWriter, r *http.Request) { + testMethod(t, r, "POST") + testRequestURL(t, r, testAPIEndpoint) + fmt.Fprint(w, `{"id":11,"self":"http://www.example.com/jira/rest/agile/1.0/sprint/11","state":"future","name":"Updated Name","startDate":"2022-08-09T12:34:56.000Z","endDate":"2022-08-16T12:34:56.000Z","originBoardId":17}`) + }) + + data := make(map[string]interface{}) + data["name"] = "Updated Name" + resp, err := testClient.Sprint.UpdateSprint(11, data) + if resp == nil { + t.Error("Expected resp. resp is nil") + } + if err != nil { + t.Errorf("Error given: %s", err) + } +}