| // Copyright (c) 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| /* |
| Utilities for interacting with the GoogleCode issue tracker. |
| |
| Example usage: |
| issueTracker := issue_tracker.MakeIssueTraker(myOAuthConfigFile) |
| authURL := issueTracker.MakeAuthRequestURL() |
| // Visit the authURL to obtain an authorization code. |
| issueTracker.UpgradeCode(code) |
| // Now issueTracker can be used to retrieve and edit issues. |
| */ |
| package issue_tracker |
| |
| import ( |
| "bytes" |
| "code.google.com/p/goauth2/oauth" |
| "encoding/json" |
| "fmt" |
| "io/ioutil" |
| "net/http" |
| "net/url" |
| "strconv" |
| "strings" |
| ) |
| |
| // BugPriorities are the possible values for "Priority-*" labels for issues. |
| var BugPriorities = []string{"Critical", "High", "Medium", "Low", "Never"} |
| |
| var apiScope = []string{ |
| "https://www.googleapis.com/auth/projecthosting", |
| "https://www.googleapis.com/auth/userinfo.email", |
| } |
| |
| const issueApiURL = "https://www.googleapis.com/projecthosting/v2/projects/" |
| const issueURL = "https://code.google.com/p/skia/issues/detail?id=" |
| const personApiURL = "https://www.googleapis.com/userinfo/v2/me" |
| |
| // Enum for determining whether a label has been added, removed, or is |
| // unchanged. |
| const ( |
| labelAdded = iota |
| labelRemoved |
| labelUnchanged |
| ) |
| |
| // loadOAuthConfig reads the OAuth given config file path and returns an |
| // appropriate oauth.Config. |
| func loadOAuthConfig(oauthConfigFile string) (*oauth.Config, error) { |
| errFmt := "failed to read OAuth config file: %s" |
| fileContents, err := ioutil.ReadFile(oauthConfigFile) |
| if err != nil { |
| return nil, fmt.Errorf(errFmt, err) |
| } |
| var decodedJson map[string]struct { |
| AuthURL string `json:"auth_uri"` |
| ClientId string `json:"client_id"` |
| ClientSecret string `json:"client_secret"` |
| TokenURL string `json:"token_uri"` |
| } |
| if err := json.Unmarshal(fileContents, &decodedJson); err != nil { |
| return nil, fmt.Errorf(errFmt, err) |
| } |
| config, ok := decodedJson["web"] |
| if !ok { |
| return nil, fmt.Errorf(errFmt, err) |
| } |
| return &oauth.Config{ |
| ClientId: config.ClientId, |
| ClientSecret: config.ClientSecret, |
| Scope: strings.Join(apiScope, " "), |
| AuthURL: config.AuthURL, |
| TokenURL: config.TokenURL, |
| }, nil |
| } |
| |
| // Issue contains information about an issue. |
| type Issue struct { |
| Id int `json:"id"` |
| Project string `json:"projectId"` |
| Title string `json:"title"` |
| Labels []string `json:"labels"` |
| } |
| |
| // URL returns the URL of a given issue. |
| func (i Issue) URL() string { |
| return issueURL + strconv.Itoa(i.Id) |
| } |
| |
| // IssueList represents a list of issues from the IssueTracker. |
| type IssueList struct { |
| TotalResults int `json:"totalResults"` |
| Items []*Issue `json:"items"` |
| } |
| |
| // IssueTracker is the primary point of contact with the issue tracker, |
| // providing methods for authenticating to and interacting with it. |
| type IssueTracker struct { |
| OAuthConfig *oauth.Config |
| OAuthTransport *oauth.Transport |
| } |
| |
| // MakeIssueTracker creates and returns an IssueTracker with authentication |
| // configuration from the given authConfigFile. |
| func MakeIssueTracker(authConfigFile string, redirectURL string) (*IssueTracker, error) { |
| oauthConfig, err := loadOAuthConfig(authConfigFile) |
| if err != nil { |
| return nil, fmt.Errorf( |
| "failed to create IssueTracker: %s", err) |
| } |
| oauthConfig.RedirectURL = redirectURL |
| return &IssueTracker{ |
| OAuthConfig: oauthConfig, |
| OAuthTransport: &oauth.Transport{Config: oauthConfig}, |
| }, nil |
| } |
| |
| // MakeAuthRequestURL returns an authentication request URL which can be used |
| // to obtain an authorization code via user sign-in. |
| func (it IssueTracker) MakeAuthRequestURL() string { |
| // NOTE: Need to add XSRF protection if we ever want to run this on a public |
| // server. |
| return it.OAuthConfig.AuthCodeURL(it.OAuthConfig.RedirectURL) |
| } |
| |
| // IsAuthenticated determines whether the IssueTracker has sufficient |
| // permissions to retrieve and edit Issues. |
| func (it IssueTracker) IsAuthenticated() bool { |
| return it.OAuthTransport.Token != nil |
| } |
| |
| // UpgradeCode exchanges the single-use authorization code, obtained by |
| // following the URL obtained from IssueTracker.MakeAuthRequestURL, for a |
| // multi-use, session token. This is required before IssueTracker can retrieve |
| // and edit issues. |
| func (it *IssueTracker) UpgradeCode(code string) error { |
| token, err := it.OAuthTransport.Exchange(code) |
| if err == nil { |
| it.OAuthTransport.Token = token |
| return nil |
| } else { |
| return fmt.Errorf( |
| "failed to exchange single-user auth code: %s", err) |
| } |
| } |
| |
| // GetLoggedInUser retrieves the email address of the authenticated user. |
| func (it IssueTracker) GetLoggedInUser() (string, error) { |
| errFmt := "error retrieving user email: %s" |
| if !it.IsAuthenticated() { |
| return "", fmt.Errorf(errFmt, "User is not authenticated!") |
| } |
| resp, err := it.OAuthTransport.Client().Get(personApiURL) |
| if err != nil { |
| return "", fmt.Errorf(errFmt, err) |
| } |
| defer resp.Body.Close() |
| body, _ := ioutil.ReadAll(resp.Body) |
| if resp.StatusCode != http.StatusOK { |
| return "", fmt.Errorf(errFmt, fmt.Sprintf( |
| "user data API returned code %d: %v", resp.StatusCode, string(body))) |
| } |
| userInfo := struct { |
| Email string `json:"email"` |
| }{} |
| if err := json.Unmarshal(body, &userInfo); err != nil { |
| return "", fmt.Errorf(errFmt, err) |
| } |
| return userInfo.Email, nil |
| } |
| |
| // GetBug retrieves the Issue with the given ID from the IssueTracker. |
| func (it IssueTracker) GetBug(project string, id int) (*Issue, error) { |
| errFmt := fmt.Sprintf("error retrieving issue %d: %s", id, "%s") |
| if !it.IsAuthenticated() { |
| return nil, fmt.Errorf(errFmt, "user is not authenticated!") |
| } |
| requestURL := issueApiURL + project + "/issues/" + strconv.Itoa(id) |
| resp, err := it.OAuthTransport.Client().Get(requestURL) |
| if err != nil { |
| return nil, fmt.Errorf(errFmt, err) |
| } |
| defer resp.Body.Close() |
| body, _ := ioutil.ReadAll(resp.Body) |
| if resp.StatusCode != http.StatusOK { |
| return nil, fmt.Errorf(errFmt, fmt.Sprintf( |
| "issue tracker returned code %d:%v", resp.StatusCode, string(body))) |
| } |
| var issue Issue |
| if err := json.Unmarshal(body, &issue); err != nil { |
| return nil, fmt.Errorf(errFmt, err) |
| } |
| return &issue, nil |
| } |
| |
| // GetBugs retrieves all Issues with the given owner from the IssueTracker, |
| // returning an IssueList. |
| func (it IssueTracker) GetBugs(project string, owner string) (*IssueList, error) { |
| errFmt := "error retrieving issues: %s" |
| if !it.IsAuthenticated() { |
| return nil, fmt.Errorf(errFmt, "user is not authenticated!") |
| } |
| params := map[string]string{ |
| "owner": url.QueryEscape(owner), |
| "can": "open", |
| "maxResults": "9999", |
| } |
| requestURL := issueApiURL + project + "/issues?" |
| first := true |
| for k, v := range params { |
| if first { |
| first = false |
| } else { |
| requestURL += "&" |
| } |
| requestURL += k + "=" + v |
| } |
| resp, err := it.OAuthTransport.Client().Get(requestURL) |
| if err != nil { |
| return nil, fmt.Errorf(errFmt, err) |
| } |
| defer resp.Body.Close() |
| body, _ := ioutil.ReadAll(resp.Body) |
| if resp.StatusCode != http.StatusOK { |
| return nil, fmt.Errorf(errFmt, fmt.Sprintf( |
| "issue tracker returned code %d:%v", resp.StatusCode, string(body))) |
| } |
| |
| var bugList IssueList |
| if err := json.Unmarshal(body, &bugList); err != nil { |
| return nil, fmt.Errorf(errFmt, err) |
| } |
| return &bugList, nil |
| } |
| |
| // SubmitIssueChanges creates a comment on the given Issue which modifies it |
| // according to the contents of the passed-in Issue struct. |
| func (it IssueTracker) SubmitIssueChanges(issue *Issue, comment string) error { |
| errFmt := "Error updating issue " + strconv.Itoa(issue.Id) + ": %s" |
| if !it.IsAuthenticated() { |
| return fmt.Errorf(errFmt, "user is not authenticated!") |
| } |
| oldIssue, err := it.GetBug(issue.Project, issue.Id) |
| if err != nil { |
| return fmt.Errorf(errFmt, err) |
| } |
| postData := struct { |
| Content string `json:"content"` |
| Updates struct { |
| Title *string `json:"summary"` |
| Labels []string `json:"labels"` |
| } `json:"updates"` |
| }{ |
| Content: comment, |
| } |
| if issue.Title != oldIssue.Title { |
| postData.Updates.Title = &issue.Title |
| } |
| // TODO(borenet): Add other issue attributes, eg. Owner. |
| labels := make(map[string]int) |
| for _, label := range issue.Labels { |
| labels[label] = labelAdded |
| } |
| for _, label := range oldIssue.Labels { |
| if _, ok := labels[label]; ok { |
| labels[label] = labelUnchanged |
| } else { |
| labels[label] = labelRemoved |
| } |
| } |
| labelChanges := make([]string, 0) |
| for labelName, present := range labels { |
| if present == labelRemoved { |
| labelChanges = append(labelChanges, "-"+labelName) |
| } else if present == labelAdded { |
| labelChanges = append(labelChanges, labelName) |
| } |
| } |
| if len(labelChanges) > 0 { |
| postData.Updates.Labels = labelChanges |
| } |
| |
| postBytes, err := json.Marshal(&postData) |
| if err != nil { |
| return fmt.Errorf(errFmt, err) |
| } |
| requestURL := issueApiURL + issue.Project + "/issues/" + |
| strconv.Itoa(issue.Id) + "/comments" |
| resp, err := it.OAuthTransport.Client().Post( |
| requestURL, "application/json", bytes.NewReader(postBytes)) |
| if err != nil { |
| return fmt.Errorf(errFmt, err) |
| } |
| defer resp.Body.Close() |
| body, _ := ioutil.ReadAll(resp.Body) |
| if resp.StatusCode != http.StatusOK { |
| return fmt.Errorf(errFmt, fmt.Sprintf( |
| "Issue tracker returned code %d:%v", resp.StatusCode, string(body))) |
| } |
| return nil |
| } |