358 lines
10 KiB
Go
358 lines
10 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/Tencent/WeKnora/pluginsdk/pluginapi"
|
|
)
|
|
|
|
// gatewayURL is Atlassian's API gateway, where OAuth tokens are used. Tests
|
|
// point it at a fake.
|
|
var gatewayURL = "https://api.atlassian.com"
|
|
|
|
// httpClient honors HTTPS_PROXY: a host plugin's traffic must go through the
|
|
// plugin host's egress proxy.
|
|
var httpClient = &http.Client{
|
|
Timeout: 30 * time.Second,
|
|
Transport: &http.Transport{Proxy: http.ProxyFromEnvironment},
|
|
}
|
|
|
|
// Credential fields, as the instance schema names them.
|
|
type credentials struct {
|
|
Auth string `json:"auth"`
|
|
Account string `json:"account"` // an OAuth access token by the time it reaches us
|
|
Site string `json:"site"` // cloud ID
|
|
BaseURL string `json:"base_url"`
|
|
Email string `json:"email"`
|
|
APIToken string `json:"api_token"`
|
|
}
|
|
|
|
// client calls one Jira Cloud site's REST API.
|
|
type client struct {
|
|
api string // REST root: the site, or the gateway's /ex/jira/{cloudId}
|
|
siteURL string // for links to issues
|
|
auth string // Authorization header
|
|
}
|
|
|
|
// site is a Jira site an OAuth token can reach.
|
|
type site struct {
|
|
ID string `json:"id"`
|
|
URL string `json:"url"`
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
// accessibleSites lists the sites an OAuth token was granted.
|
|
func accessibleSites(ctx context.Context, token string) ([]site, error) {
|
|
c := &client{api: gatewayURL, auth: "Bearer " + token}
|
|
var sites []site
|
|
err := c.do(ctx, http.MethodGet, "/oauth/token/accessible-resources", nil, &sites)
|
|
return sites, err
|
|
}
|
|
|
|
// newClient checks the credentials and connects to the site they name.
|
|
// Problems with the form come back as invalid_config on its fields.
|
|
func newClient(ctx context.Context, cr credentials, locale string) (*client, error) {
|
|
switch cr.Auth {
|
|
case "", "oauth":
|
|
if cr.Account == "" {
|
|
return nil, pluginapi.InvalidConfig(say(locale, msgConnectAccount),
|
|
map[string]string{"credentials.account": "required"})
|
|
}
|
|
if cr.Site == "" {
|
|
return nil, pluginapi.InvalidConfig(say(locale, msgChooseSite),
|
|
map[string]string{"credentials.site": "required"})
|
|
}
|
|
sites, err := accessibleSites(ctx, cr.Account)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, s := range sites {
|
|
if s.ID == cr.Site {
|
|
return &client{
|
|
api: gatewayURL + "/ex/jira/" + url.PathEscape(s.ID),
|
|
siteURL: strings.TrimSuffix(s.URL, "/"),
|
|
auth: "Bearer " + cr.Account,
|
|
}, nil
|
|
}
|
|
}
|
|
return nil, pluginapi.InvalidConfig(say(locale, msgSiteGone),
|
|
map[string]string{"credentials.site": "not granted"})
|
|
case "token":
|
|
base := strings.TrimSuffix(strings.TrimSpace(cr.BaseURL), "/")
|
|
fields := map[string]string{}
|
|
if base == "" {
|
|
fields["credentials.base_url"] = "required"
|
|
}
|
|
if cr.Email == "" {
|
|
fields["credentials.email"] = "required"
|
|
}
|
|
if cr.APIToken == "" {
|
|
fields["credentials.api_token"] = "required"
|
|
}
|
|
if len(fields) > 0 {
|
|
return nil, pluginapi.InvalidConfig(say(locale, msgTokenFields), fields)
|
|
}
|
|
basic := cr.Email + ":" + cr.APIToken
|
|
return &client{
|
|
api: base, siteURL: base,
|
|
auth: "Basic " + base64.StdEncoding.EncodeToString([]byte(basic)),
|
|
}, nil
|
|
default:
|
|
return nil, pluginapi.InvalidConfig(say(locale, msgUnknownAuth),
|
|
map[string]string{"credentials.auth": "enum"})
|
|
}
|
|
}
|
|
|
|
// do sends one request and decodes a JSON answer. Jira's failures map to
|
|
// protocol errors: WeKnora retries unavailable and rate_limited, and shows
|
|
// unauthorized as broken credentials.
|
|
func (c *client) do(ctx context.Context, method, path string, body, out any) error {
|
|
var rd io.Reader
|
|
if body != nil {
|
|
b, err := json.Marshal(body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
rd = bytes.NewReader(b)
|
|
}
|
|
req, err := http.NewRequestWithContext(ctx, method, c.api+path, rd)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
req.Header.Set("Authorization", c.auth)
|
|
req.Header.Set("Accept", "application/json")
|
|
if body != nil {
|
|
req.Header.Set("Content-Type", "application/json")
|
|
}
|
|
resp, err := httpClient.Do(req)
|
|
if err != nil {
|
|
return pluginapi.Errorf(pluginapi.CodeUnavailable, "jira: %v", err)
|
|
}
|
|
defer func() { _ = resp.Body.Close() }()
|
|
data, err := io.ReadAll(io.LimitReader(resp.Body, 32<<20))
|
|
if err != nil {
|
|
return pluginapi.Errorf(pluginapi.CodeUnavailable, "jira: %v", err)
|
|
}
|
|
if resp.StatusCode >= 300 {
|
|
return statusError(resp, data)
|
|
}
|
|
if out == nil {
|
|
return nil
|
|
}
|
|
if err := json.Unmarshal(data, out); err != nil {
|
|
return fmt.Errorf("jira %s: decode: %w", path, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func statusError(resp *http.Response, body []byte) error {
|
|
msg := jiraMessage(body)
|
|
switch {
|
|
case resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden:
|
|
return pluginapi.Errorf(
|
|
pluginapi.CodeUnauthorized,
|
|
"jira refused the credentials (%d): %s",
|
|
resp.StatusCode,
|
|
msg,
|
|
)
|
|
case resp.StatusCode == http.StatusTooManyRequests:
|
|
e := pluginapi.Errorf(pluginapi.CodeRateLimited, "jira rate limit: %s", msg)
|
|
if s, err := strconv.Atoi(resp.Header.Get("Retry-After")); err == nil && s > 0 {
|
|
e.Details = &pluginapi.ErrorDetails{RetryAfter: s}
|
|
}
|
|
return e
|
|
case resp.StatusCode >= 500:
|
|
return pluginapi.Errorf(pluginapi.CodeUnavailable, "jira %d: %s", resp.StatusCode, msg)
|
|
case resp.StatusCode == http.StatusBadRequest:
|
|
// Mostly a JQL filter Jira does not accept.
|
|
return pluginapi.InvalidConfig("jira rejected the query: "+msg,
|
|
map[string]string{"settings.jql": msg})
|
|
default:
|
|
return fmt.Errorf("jira %d: %s", resp.StatusCode, msg)
|
|
}
|
|
}
|
|
|
|
// jiraMessage extracts Jira's error text ({"errorMessages": [...]}).
|
|
func jiraMessage(body []byte) string {
|
|
var e struct {
|
|
ErrorMessages []string `json:"errorMessages"`
|
|
Errors map[string]string `json:"errors"`
|
|
Message string `json:"message"`
|
|
}
|
|
if json.Unmarshal(body, &e) == nil {
|
|
parts := append([]string{}, e.ErrorMessages...)
|
|
for k, v := range e.Errors {
|
|
parts = append(parts, k+": "+v)
|
|
}
|
|
if e.Message != "" {
|
|
parts = append(parts, e.Message)
|
|
}
|
|
if len(parts) > 0 {
|
|
return strings.Join(parts, "; ")
|
|
}
|
|
}
|
|
s := strings.TrimSpace(string(body))
|
|
if len(s) > 200 {
|
|
s = s[:200]
|
|
}
|
|
return s
|
|
}
|
|
|
|
// myself is the signed-in user. Its time zone is the one JQL dates are in.
|
|
type myself struct {
|
|
AccountID string `json:"accountId"`
|
|
DisplayName string `json:"displayName"`
|
|
TimeZone string `json:"timeZone"`
|
|
}
|
|
|
|
func (c *client) myself(ctx context.Context) (*myself, error) {
|
|
var me myself
|
|
if err := c.do(ctx, http.MethodGet, "/rest/api/3/myself", nil, &me); err != nil {
|
|
return nil, err
|
|
}
|
|
return &me, nil
|
|
}
|
|
|
|
type project struct {
|
|
ID string `json:"id"`
|
|
Key string `json:"key"`
|
|
Name string `json:"name"`
|
|
Description string `json:"description"`
|
|
Style string `json:"style"`
|
|
}
|
|
|
|
// projects lists every project the user can browse.
|
|
func (c *client) projects(ctx context.Context) ([]project, error) {
|
|
var out []project
|
|
for start := 0; ; {
|
|
var page struct {
|
|
Values []project `json:"values"`
|
|
IsLast bool `json:"isLast"`
|
|
}
|
|
q := url.Values{"startAt": {strconv.Itoa(start)}, "maxResults": {"50"}, "orderBy": {"name"}}
|
|
if err := c.do(ctx, http.MethodGet, "/rest/api/3/project/search?"+q.Encode(), nil, &page); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, page.Values...)
|
|
if page.IsLast || len(page.Values) == 0 {
|
|
return out, nil
|
|
}
|
|
start += len(page.Values)
|
|
}
|
|
}
|
|
|
|
type issueType struct {
|
|
Name string `json:"name"`
|
|
Subtask bool `json:"subtask"`
|
|
}
|
|
|
|
func (c *client) issueTypes(ctx context.Context) ([]issueType, error) {
|
|
var out []issueType
|
|
err := c.do(ctx, http.MethodGet, "/rest/api/3/issuetype", nil, &out)
|
|
return out, err
|
|
}
|
|
|
|
// issue is the part of a Jira issue the connector turns into a document.
|
|
type issue struct {
|
|
ID string `json:"id"`
|
|
Key string `json:"key"`
|
|
Fields struct {
|
|
Summary string `json:"summary"`
|
|
Description json.RawMessage `json:"description"`
|
|
Status *named `json:"status"`
|
|
IssueType *named `json:"issuetype"`
|
|
Priority *named `json:"priority"`
|
|
Resolution *named `json:"resolution"`
|
|
Assignee *user `json:"assignee"`
|
|
Reporter *user `json:"reporter"`
|
|
Labels []string `json:"labels"`
|
|
Created jiraTime `json:"created"`
|
|
Updated jiraTime `json:"updated"`
|
|
Project *project `json:"project"`
|
|
Parent *struct {
|
|
Key string `json:"key"`
|
|
} `json:"parent"`
|
|
Comment *struct {
|
|
Comments []comment `json:"comments"`
|
|
Total int `json:"total"`
|
|
} `json:"comment"`
|
|
} `json:"fields"`
|
|
}
|
|
|
|
type named struct {
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
type user struct {
|
|
DisplayName string `json:"displayName"`
|
|
}
|
|
|
|
type comment struct {
|
|
Author *user `json:"author"`
|
|
Created jiraTime `json:"created"`
|
|
Body json.RawMessage `json:"body"`
|
|
}
|
|
|
|
// jiraTime parses Jira's timestamps ("2026-09-26T10:04:05.123+0800").
|
|
type jiraTime struct{ time.Time }
|
|
|
|
func (t *jiraTime) UnmarshalJSON(b []byte) error {
|
|
var s string
|
|
if err := json.Unmarshal(b, &s); err != nil || s == "" {
|
|
return nil
|
|
}
|
|
for _, layout := range []string{"2006-01-02T15:04:05.000-0700", time.RFC3339Nano} {
|
|
if v, err := time.Parse(layout, s); err == nil {
|
|
t.Time = v
|
|
return nil
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
var searchFields = []string{
|
|
"summary", "description", "status", "issuetype", "priority", "resolution", "assignee", "reporter",
|
|
"labels", "created", "updated", "project", "parent", "comment",
|
|
}
|
|
|
|
// search runs JQL a page at a time (the enhanced search API, which pages
|
|
// with a token). fn sees each page; returning an error stops the search.
|
|
func (c *client) search(ctx context.Context, jql string, withComments bool, fn func([]issue) error) error {
|
|
fields := searchFields
|
|
if !withComments {
|
|
fields = fields[:len(fields)-1]
|
|
}
|
|
token := ""
|
|
for {
|
|
body := map[string]any{"jql": jql, "maxResults": 50, "fields": fields}
|
|
if token != "" {
|
|
body["nextPageToken"] = token
|
|
}
|
|
var page struct {
|
|
Issues []issue `json:"issues"`
|
|
NextPageToken string `json:"nextPageToken"`
|
|
IsLast bool `json:"isLast"`
|
|
}
|
|
if err := c.do(ctx, http.MethodPost, "/rest/api/3/search/jql", body, &page); err != nil {
|
|
return err
|
|
}
|
|
if err := fn(page.Issues); err != nil {
|
|
return err
|
|
}
|
|
if page.IsLast || page.NextPageToken == "" || len(page.Issues) == 0 {
|
|
return nil
|
|
}
|
|
token = page.NextPageToken
|
|
}
|
|
}
|