require (
cloud.google.com/go v0.78.0 // indirect
code.gitea.io/gitea-vet v0.2.1
- code.gitea.io/sdk/gitea v0.13.2
+ code.gitea.io/sdk/gitea v0.14.0
gitea.com/go-chi/binding v0.0.0-20210301195521-1fe1c9a555e7
gitea.com/go-chi/cache v0.0.0-20210110083709-82c4c9ce2d5e
gitea.com/go-chi/captcha v0.0.0-20210110083842-e7696c336a1e
cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
code.gitea.io/gitea-vet v0.2.1 h1:b30by7+3SkmiftK0RjuXqFvZg2q4p68uoPGuxhzBN0s=
code.gitea.io/gitea-vet v0.2.1/go.mod h1:zcNbT/aJEmivCAhfmkHOlT645KNOf9W2KnkLgFjGGfE=
-code.gitea.io/sdk/gitea v0.13.2 h1:wAnT/J7Z62q3fJXbgnecoaOBh8CM1Qq0/DakWxiv4yA=
-code.gitea.io/sdk/gitea v0.13.2/go.mod h1:lee2y8LeV3kQb2iK+hHlMqoadL4bp27QOkOV/hawLKg=
+code.gitea.io/sdk/gitea v0.14.0 h1:m4J352I3p9+bmJUfS+g0odeQzBY/5OXP91Gv6D4fnJ0=
+code.gitea.io/sdk/gitea v0.14.0/go.mod h1:89WiyOX1KEcvjP66sRHdu0RafojGo60bT9UqW17VbWs=
dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
gitea.com/go-chi/binding v0.0.0-20210301195521-1fe1c9a555e7 h1:xCVJPY823C8RWpgMabTw2kOglDrg0iS3GcQU6wdwHkU=
gitea.com/go-chi/binding v0.0.0-20210301195521-1fe1c9a555e7/go.mod h1:AyfTrwtfYN54R/HmVvMYPnSTenH5bVoyh8x6tBluxEA=
headRepoName = pr.Head.Repository.Name
headCloneURL = pr.Head.Repository.CloneURL
}
- if err := fixPullHeadSha(g.client, pr); err != nil {
- return nil, false, fmt.Errorf("error while resolving head git ref: %s for pull #%d. Error: %v", pr.Head.Ref, pr.Index, err)
- }
headSHA = pr.Head.Sha
headRef = pr.Head.Ref
}
}
return allReviews, nil
}
-
-// fixPullHeadSha is a workaround for https://github.com/go-gitea/gitea/issues/12675
-// When no head sha is available, this is because the branch got deleted in the base repo.
-// pr.Head.Ref points in this case not to the head repo branch name, but the base repo ref,
-// which stays available to resolve the commit sha.
-func fixPullHeadSha(client *gitea_sdk.Client, pr *gitea_sdk.PullRequest) error {
- owner := pr.Base.Repository.Owner.UserName
- repo := pr.Base.Repository.Name
- if pr.Head != nil && pr.Head.Sha == "" {
- refs, _, err := client.GetRepoRefs(owner, repo, pr.Head.Ref)
- if err != nil {
- return err
- } else if len(refs) == 0 {
- return fmt.Errorf("unable to resolve PR ref '%s'", pr.Head.Ref)
- }
- pr.Head.Sha = refs[0].Object.SHA
- }
- return nil
-}
if err := c.checkServerVersionGreaterThanOrEqual(version1_13_0); err != nil {
return nil, err
}
+ if err := escapeValidatePathSegments(&task); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("POST", fmt.Sprintf("/admin/cron/%s", task), jsonHeader, nil)
return resp, err
}
// AdminCreateOrg create an organization
func (c *Client) AdminCreateOrg(user string, opt CreateOrgOption) (*Organization, *Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, nil, err
+ }
body, err := json.Marshal(&opt)
if err != nil {
return nil, nil, err
// AdminCreateRepo create a repo
func (c *Client) AdminCreateRepo(user string, opt CreateRepoOption) (*Repository, *Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, nil, err
+ }
body, err := json.Marshal(&opt)
if err != nil {
return nil, nil, err
// EditUserOption edit user options
type EditUserOption struct {
- SourceID int64 `json:"source_id"`
- LoginName string `json:"login_name"`
- FullName string `json:"full_name"`
- Email string `json:"email"`
- Password string `json:"password"`
- MustChangePassword *bool `json:"must_change_password"`
- Website string `json:"website"`
- Location string `json:"location"`
- Active *bool `json:"active"`
- Admin *bool `json:"admin"`
- AllowGitHook *bool `json:"allow_git_hook"`
- AllowImportLocal *bool `json:"allow_import_local"`
- MaxRepoCreation *int `json:"max_repo_creation"`
- ProhibitLogin *bool `json:"prohibit_login"`
- AllowCreateOrganization *bool `json:"allow_create_organization"`
+ SourceID int64 `json:"source_id"`
+ LoginName string `json:"login_name"`
+ Email *string `json:"email"`
+ FullName *string `json:"full_name"`
+ Password string `json:"password"`
+ MustChangePassword *bool `json:"must_change_password"`
+ Website *string `json:"website"`
+ Location *string `json:"location"`
+ Active *bool `json:"active"`
+ Admin *bool `json:"admin"`
+ AllowGitHook *bool `json:"allow_git_hook"`
+ AllowImportLocal *bool `json:"allow_import_local"`
+ MaxRepoCreation *int `json:"max_repo_creation"`
+ ProhibitLogin *bool `json:"prohibit_login"`
+ AllowCreateOrganization *bool `json:"allow_create_organization"`
}
// AdminEditUser modify user informations
func (c *Client) AdminEditUser(user string, opt EditUserOption) (*Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, err
+ }
body, err := json.Marshal(&opt)
if err != nil {
return nil, err
// AdminDeleteUser delete one user according name
func (c *Client) AdminDeleteUser(user string) (*Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/admin/users/%s", user), nil, nil)
return resp, err
}
// AdminCreateUserPublicKey adds a public key for the user
func (c *Client) AdminCreateUserPublicKey(user string, opt CreateKeyOption) (*PublicKey, *Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, nil, err
+ }
body, err := json.Marshal(&opt)
if err != nil {
return nil, nil, err
// AdminDeleteUserPublicKey deletes a user's public key
func (c *Client) AdminDeleteUserPublicKey(user string, keyID int) (*Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/admin/users/%s/keys/%d", user, keyID), nil, nil)
return resp, err
}
// ListReleaseAttachments list release's attachments
func (c *Client) ListReleaseAttachments(user, repo string, release int64, opt ListReleaseAttachmentsOptions) ([]*Attachment, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
attachments := make([]*Attachment, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET",
// GetReleaseAttachment returns the requested attachment
func (c *Client) GetReleaseAttachment(user, repo string, release int64, id int64) (*Attachment, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
a := new(Attachment)
resp, err := c.getParsedResponse("GET",
fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, id),
// CreateReleaseAttachment creates an attachment for the given release
func (c *Client) CreateReleaseAttachment(user, repo string, release int64, file io.Reader, filename string) (*Attachment, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
// Write file to body
body := new(bytes.Buffer)
writer := multipart.NewWriter(body)
// EditReleaseAttachment updates the given attachment with the given options
func (c *Client) EditReleaseAttachment(user, repo string, release int64, attachment int64, form EditAttachmentOptions) (*Attachment, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
body, err := json.Marshal(&form)
if err != nil {
return nil, nil, err
// DeleteReleaseAttachment deletes the given attachment including the uploaded file
func (c *Client) DeleteReleaseAttachment(user, repo string, release int64, id int64) (*Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, id), nil, nil)
return resp, err
}
"io"
"io/ioutil"
"net/http"
+ "net/url"
"strings"
"sync"
// Version return the library version
func Version() string {
- return "0.13.0"
+ return "0.14.0"
}
-// Client represents a Gitea API client.
+// Client represents a thread-safe Gitea API client.
type Client struct {
- url string
- accessToken string
- username string
- password string
- otp string
- sudo string
- debug bool
- client *http.Client
- ctx context.Context
- serverVersion *version.Version
- versionLock sync.RWMutex
+ url string
+ accessToken string
+ username string
+ password string
+ otp string
+ sudo string
+ debug bool
+ client *http.Client
+ ctx context.Context
+ mutex sync.RWMutex
+ serverVersion *version.Version
+ getVersionOnce sync.Once
}
// Response represents the gitea response
}
// NewClient initializes and returns a API client.
+// Usage of all gitea.Client methods is concurrency-safe.
func NewClient(url string, options ...func(*Client)) (*Client, error) {
client := &Client{
url: strings.TrimSuffix(url, "/"),
for _, opt := range options {
opt(client)
}
- if err := client.checkServerVersionGreaterThanOrEqual(version1_10_0); err != nil {
+ if err := client.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
return nil, err
}
return client, nil
// SetHTTPClient is an option for NewClient to set custom http client
func SetHTTPClient(httpClient *http.Client) func(client *Client) {
return func(client *Client) {
- client.client = httpClient
+ client.SetHTTPClient(httpClient)
}
}
+// SetHTTPClient replaces default http.Client with user given one.
+func (c *Client) SetHTTPClient(client *http.Client) {
+ c.mutex.Lock()
+ c.client = client
+ c.mutex.Unlock()
+}
+
// SetToken is an option for NewClient to set token
func SetToken(token string) func(client *Client) {
return func(client *Client) {
+ client.mutex.Lock()
client.accessToken = token
+ client.mutex.Unlock()
}
}
// SetBasicAuth sets username and password
func (c *Client) SetBasicAuth(username, password string) {
+ c.mutex.Lock()
c.username, c.password = username, password
+ c.mutex.Unlock()
}
// SetOTP is an option for NewClient to set OTP for 2FA
// SetOTP sets OTP for 2FA
func (c *Client) SetOTP(otp string) {
+ c.mutex.Lock()
c.otp = otp
+ c.mutex.Unlock()
}
// SetContext is an option for NewClient to set context
// SetContext set context witch is used for http requests
func (c *Client) SetContext(ctx context.Context) {
+ c.mutex.Lock()
c.ctx = ctx
-}
-
-// SetHTTPClient replaces default http.Client with user given one.
-func (c *Client) SetHTTPClient(client *http.Client) {
- c.client = client
+ c.mutex.Unlock()
}
// SetSudo is an option for NewClient to set sudo header
// SetSudo sets username to impersonate.
func (c *Client) SetSudo(sudo string) {
+ c.mutex.Lock()
c.sudo = sudo
+ c.mutex.Unlock()
}
// SetDebugMode is an option for NewClient to enable debug mode
func SetDebugMode() func(client *Client) {
return func(client *Client) {
+ client.mutex.Lock()
client.debug = true
+ client.mutex.Unlock()
}
}
func (c *Client) getWebResponse(method, path string, body io.Reader) ([]byte, *Response, error) {
- if c.debug {
+ c.mutex.RLock()
+ debug := c.debug
+ if debug {
fmt.Printf("%s: %s\nBody: %v\n", method, c.url+path, body)
}
req, err := http.NewRequestWithContext(c.ctx, method, c.url+path, body)
+
+ client := c.client // client ref can change from this point on so safe it
+ c.mutex.RUnlock()
+
if err != nil {
return nil, nil, err
}
- resp, err := c.client.Do(req)
+
+ resp, err := client.Do(req)
if err != nil {
return nil, nil, err
}
defer resp.Body.Close()
data, err := ioutil.ReadAll(resp.Body)
- if c.debug {
+ if debug {
fmt.Printf("Response: %v\n\n", resp)
}
return data, &Response{resp}, nil
}
func (c *Client) doRequest(method, path string, header http.Header, body io.Reader) (*Response, error) {
- if c.debug {
+ c.mutex.RLock()
+ debug := c.debug
+ if debug {
fmt.Printf("%s: %s\nHeader: %v\nBody: %s\n", method, c.url+"/api/v1"+path, header, body)
}
req, err := http.NewRequestWithContext(c.ctx, method, c.url+"/api/v1"+path, body)
if err != nil {
+ c.mutex.RUnlock()
return nil, err
}
if len(c.accessToken) != 0 {
if len(c.sudo) != 0 {
req.Header.Set("Sudo", c.sudo)
}
+
+ client := c.client // client ref can change from this point on so safe it
+ c.mutex.RUnlock()
+
for k, v := range header {
req.Header[k] = v
}
- resp, err := c.client.Do(req)
+ resp, err := client.Do(req)
if err != nil {
return nil, err
}
- if c.debug {
+ if debug {
fmt.Printf("Response: %v\n\n", resp)
}
return &Response{resp}, nil
}
-func (c *Client) getResponse(method, path string, header http.Header, body io.Reader) ([]byte, *Response, error) {
- resp, err := c.doRequest(method, path, header, body)
- if err != nil {
- return nil, nil, err
+// Converts a response for a HTTP status code indicating an error condition
+// (non-2XX) to a well-known error value and response body. For non-problematic
+// (2XX) status codes nil will be returned. Note that on a non-2XX response, the
+// response body stream will have been read and, hence, is closed on return.
+func statusCodeToErr(resp *Response) (body []byte, err error) {
+ // no error
+ if resp.StatusCode/100 == 2 {
+ return nil, nil
}
- defer resp.Body.Close()
+ //
+ // error: body will be read for details
+ //
+ defer resp.Body.Close()
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
- return nil, resp, err
+ return nil, fmt.Errorf("body read on HTTP error %d: %v", resp.StatusCode, err)
}
switch resp.StatusCode {
case 403:
- return data, resp, errors.New("403 Forbidden")
+ return data, errors.New("403 Forbidden")
case 404:
- return data, resp, errors.New("404 Not Found")
+ return data, errors.New("404 Not Found")
case 409:
- return data, resp, errors.New("409 Conflict")
+ return data, errors.New("409 Conflict")
case 422:
- return data, resp, fmt.Errorf("422 Unprocessable Entity: %s", string(data))
+ return data, fmt.Errorf("422 Unprocessable Entity: %s", string(data))
}
- if resp.StatusCode/100 != 2 {
- errMap := make(map[string]interface{})
- if err = json.Unmarshal(data, &errMap); err != nil {
- // when the JSON can't be parsed, data was probably empty or a plain string,
- // so we try to return a helpful error anyway
- return data, resp, fmt.Errorf("Unknown API Error: %d\nRequest: '%s' with '%s' method '%s' header and '%s' body", resp.StatusCode, path, method, header, string(data))
- }
- return data, resp, errors.New(errMap["message"].(string))
+ path := resp.Request.URL.Path
+ method := resp.Request.Method
+ header := resp.Request.Header
+ errMap := make(map[string]interface{})
+ if err = json.Unmarshal(data, &errMap); err != nil {
+ // when the JSON can't be parsed, data was probably empty or a
+ // plain string, so we try to return a helpful error anyway
+ return data, fmt.Errorf("Unknown API Error: %d\nRequest: '%s' with '%s' method '%s' header and '%s' body", resp.StatusCode, path, method, header, string(data))
+ }
+ return data, errors.New(errMap["message"].(string))
+}
+
+func (c *Client) getResponse(method, path string, header http.Header, body io.Reader) ([]byte, *Response, error) {
+ resp, err := c.doRequest(method, path, header, body)
+ if err != nil {
+ return nil, nil, err
+ }
+ defer resp.Body.Close()
+
+ // check for errors
+ data, err := statusCodeToErr(resp)
+ if err != nil {
+ return data, resp, err
+ }
+
+ // success (2XX), read body
+ data, err = ioutil.ReadAll(resp.Body)
+ if err != nil {
+ return nil, resp, err
}
return data, resp, nil
return resp.StatusCode, resp, nil
}
+
+// pathEscapeSegments escapes segments of a path while not escaping forward slash
+func pathEscapeSegments(path string) string {
+ slice := strings.Split(path, "/")
+ for index := range slice {
+ slice[index] = url.PathEscape(slice[index])
+ }
+ escapedPath := strings.Join(slice, "/")
+ return escapedPath
+}
+
+// escapeValidatePathSegments is a help function to validate and encode url path segments
+func escapeValidatePathSegments(seg ...*string) error {
+ for i := range seg {
+ if seg[i] == nil || len(*seg[i]) == 0 {
+ return fmt.Errorf("path segment [%d] is empty", i)
+ }
+ *seg[i] = url.PathEscape(*seg[i])
+ }
+ return nil
+}
// ListForks list a repository's forks
func (c *Client) ListForks(user string, repo string, opt ListForksOptions) ([]*Repository, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
forks := make([]*Repository, opt.PageSize)
resp, err := c.getParsedResponse("GET",
// CreateFork create a fork of a repository
func (c *Client) CreateFork(user, repo string, form CreateForkOption) (*Repository, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
body, err := json.Marshal(form)
if err != nil {
return nil, nil, err
// GetBlob get the blob of a repository file
func (c *Client) GetBlob(user, repo, sha string) (*GitBlobResponse, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo, &sha); err != nil {
+ return nil, nil, err
+ }
blob := new(GitBlobResponse)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/blobs/%s", user, repo, sha), nil, nil, blob)
return blob, resp, err
// ListRepoGitHooks list all the Git hooks of one repository
func (c *Client) ListRepoGitHooks(user, repo string, opt ListRepoGitHooksOptions) ([]*GitHook, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
hooks := make([]*GitHook, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/git?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &hooks)
// GetRepoGitHook get a Git hook of a repository
func (c *Client) GetRepoGitHook(user, repo, id string) (*GitHook, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo, &id); err != nil {
+ return nil, nil, err
+ }
h := new(GitHook)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), nil, nil, h)
return h, resp, err
// EditRepoGitHook modify one Git hook of a repository
func (c *Client) EditRepoGitHook(user, repo, id string, opt EditGitHookOption) (*Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo, &id); err != nil {
+ return nil, err
+ }
body, err := json.Marshal(&opt)
if err != nil {
return nil, err
// DeleteRepoGitHook delete one Git hook from a repository
func (c *Client) DeleteRepoGitHook(user, repo, id string) (*Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo, &id); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), nil, nil)
return resp, err
}
module code.gitea.io/sdk/gitea
-go 1.12
+go 1.13
require (
github.com/hashicorp/go-version v1.2.1
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/hashicorp/go-version v1.2.0 h1:3vNe/fWF5CBgRIguda1meWhsZHy3m8gCJ5wx+dIzX/E=
github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/hashicorp/go-version v1.2.1 h1:zEfKbn2+PDgroKdiOzqiE8rsmLqU2uwi5PB5pBJ3TkI=
+github.com/hashicorp/go-version v1.2.1/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
--- /dev/null
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+// OptionalBool convert a bool to a bool reference
+func OptionalBool(v bool) *bool {
+ return &v
+}
+
+// OptionalString convert a string to a string reference
+func OptionalString(v string) *string {
+ return &v
+}
+
+// OptionalInt64 convert a int64 to a int64 reference
+func OptionalInt64(v int64) *int64 {
+ return &v
+}
// ListOrgHooks list all the hooks of one organization
func (c *Client) ListOrgHooks(org string, opt ListHooksOptions) ([]*Hook, *Response, error) {
+ if err := escapeValidatePathSegments(&org); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
hooks := make([]*Hook, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/hooks?%s", org, opt.getURLQuery().Encode()), nil, nil, &hooks)
// ListRepoHooks list all the hooks of one repository
func (c *Client) ListRepoHooks(user, repo string, opt ListHooksOptions) ([]*Hook, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
hooks := make([]*Hook, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &hooks)
// GetOrgHook get a hook of an organization
func (c *Client) GetOrgHook(org string, id int64) (*Hook, *Response, error) {
+ if err := escapeValidatePathSegments(&org); err != nil {
+ return nil, nil, err
+ }
h := new(Hook)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), nil, nil, h)
return h, resp, err
// GetRepoHook get a hook of a repository
func (c *Client) GetRepoHook(user, repo string, id int64) (*Hook, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
h := new(Hook)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), nil, nil, h)
return h, resp, err
// CreateOrgHook create one hook for an organization, with options
func (c *Client) CreateOrgHook(org string, opt CreateHookOption) (*Hook, *Response, error) {
+ if err := escapeValidatePathSegments(&org); err != nil {
+ return nil, nil, err
+ }
if err := opt.Validate(); err != nil {
return nil, nil, err
}
// CreateRepoHook create one hook for a repository, with options
func (c *Client) CreateRepoHook(user, repo string, opt CreateHookOption) (*Hook, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
body, err := json.Marshal(&opt)
if err != nil {
return nil, nil, err
// EditOrgHook modify one hook of an organization, with hook id and options
func (c *Client) EditOrgHook(org string, id int64, opt EditHookOption) (*Response, error) {
+ if err := escapeValidatePathSegments(&org); err != nil {
+ return nil, err
+ }
body, err := json.Marshal(&opt)
if err != nil {
return nil, err
// EditRepoHook modify one hook of a repository, with hook id and options
func (c *Client) EditRepoHook(user, repo string, id int64, opt EditHookOption) (*Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, err
+ }
body, err := json.Marshal(&opt)
if err != nil {
return nil, err
// DeleteOrgHook delete one hook from an organization, with hook id
func (c *Client) DeleteOrgHook(org string, id int64) (*Response, error) {
+ if err := escapeValidatePathSegments(&org); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), nil, nil)
return resp, err
}
// DeleteRepoHook delete one hook from a repository, with hook id
func (c *Client) DeleteRepoHook(user, repo string, id int64) (*Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), nil, nil)
return resp, err
}
type Issue struct {
ID int64 `json:"id"`
URL string `json:"url"`
+ HTMLURL string `json:"html_url"`
Index int64 `json:"number"`
Poster *User `json:"user"`
OriginalAuthor string `json:"original_author"`
OriginalAuthorID int64 `json:"original_author_id"`
Title string `json:"title"`
Body string `json:"body"`
+ Ref string `json:"ref"`
Labels []*Label `json:"labels"`
Milestone *Milestone `json:"milestone"`
- Assignee *User `json:"assignee"`
- Assignees []*User `json:"assignees"`
+ // deprecated
+ // TODO: rm on sdk 0.15.0
+ Assignee *User `json:"assignee"`
+ Assignees []*User `json:"assignees"`
// Whether the issue is open or closed
State StateType `json:"state"`
IsLocked bool `json:"is_locked"`
}
}
}
+ for i := range issues {
+ c.issueBackwardsCompatibility(issues[i])
+ }
return issues, resp, err
}
// ListRepoIssues returns all issues for a given repository
func (c *Client) ListRepoIssues(owner, repo string, opt ListIssueOption) ([]*Issue, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
issues := make([]*Issue, 0, opt.PageSize)
}
}
}
+ for i := range issues {
+ c.issueBackwardsCompatibility(issues[i])
+ }
return issues, resp, err
}
// GetIssue returns a single issue for a given repository
func (c *Client) GetIssue(owner, repo string, index int64) (*Issue, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
issue := new(Issue)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d", owner, repo, index), nil, nil, issue)
if e := c.checkServerVersionGreaterThanOrEqual(version1_12_0); e != nil && issue.Repository != nil {
issue.Repository.Owner = strings.Split(issue.Repository.FullName, "/")[0]
}
+ c.issueBackwardsCompatibility(issue)
return issue, resp, err
}
type CreateIssueOption struct {
Title string `json:"title"`
Body string `json:"body"`
- // username of assignee
+ Ref string `json:"ref"`
+ // deprecated
+ // TODO: rm on sdk 0.15.0
Assignee string `json:"assignee"`
Assignees []string `json:"assignees"`
Deadline *time.Time `json:"due_date"`
// CreateIssue create a new issue for a given repository
func (c *Client) CreateIssue(owner, repo string, opt CreateIssueOption) (*Issue, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := opt.Validate(); err != nil {
return nil, nil, err
}
issue := new(Issue)
resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues", owner, repo),
jsonHeader, bytes.NewReader(body), issue)
+ c.issueBackwardsCompatibility(issue)
return issue, resp, err
}
// EditIssueOption options for editing an issue
type EditIssueOption struct {
- Title string `json:"title"`
- Body *string `json:"body"`
- Assignee *string `json:"assignee"`
- Assignees []string `json:"assignees"`
- Milestone *int64 `json:"milestone"`
- State *StateType `json:"state"`
- Deadline *time.Time `json:"due_date"`
+ Title string `json:"title"`
+ Body *string `json:"body"`
+ Ref *string `json:"ref"`
+ // deprecated
+ // TODO: rm on sdk 0.15.0
+ Assignee *string `json:"assignee"`
+ Assignees []string `json:"assignees"`
+ Milestone *int64 `json:"milestone"`
+ State *StateType `json:"state"`
+ Deadline *time.Time `json:"due_date"`
+ RemoveDeadline *bool `json:"unset_due_date"`
}
// Validate the EditIssueOption struct
// EditIssue modify an existing issue for a given repository
func (c *Client) EditIssue(owner, repo string, index int64, opt EditIssueOption) (*Issue, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := opt.Validate(); err != nil {
return nil, nil, err
}
resp, err := c.getParsedResponse("PATCH",
fmt.Sprintf("/repos/%s/%s/issues/%d", owner, repo, index),
jsonHeader, bytes.NewReader(body), issue)
+ c.issueBackwardsCompatibility(issue)
return issue, resp, err
}
+
+func (c *Client) issueBackwardsCompatibility(issue *Issue) {
+ if c.checkServerVersionGreaterThanOrEqual(version1_12_0) != nil {
+ c.mutex.RLock()
+ issue.HTMLURL = fmt.Sprintf("%s/%s/issues/%d", c.url, issue.Repository.FullName, issue.Index)
+ c.mutex.RUnlock()
+ }
+}
// ListIssueComments list comments on an issue.
func (c *Client) ListIssueComments(owner, repo string, index int64, opt ListIssueCommentOptions) ([]*Comment, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index))
link.RawQuery = opt.QueryEncode()
// ListRepoIssueComments list comments for a given repo.
func (c *Client) ListRepoIssueComments(owner, repo string, opt ListIssueCommentOptions) ([]*Comment, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/comments", owner, repo))
link.RawQuery = opt.QueryEncode()
// GetIssueComment get a comment for a given repo by id.
func (c *Client) GetIssueComment(owner, repo string, id int64) (*Comment, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
comment := new(Comment)
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return comment, nil, err
// CreateIssueComment create comment on an issue.
func (c *Client) CreateIssueComment(owner, repo string, index int64, opt CreateIssueCommentOption) (*Comment, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := opt.Validate(); err != nil {
return nil, nil, err
}
// EditIssueComment edits an issue comment.
func (c *Client) EditIssueComment(owner, repo string, commentID int64, opt EditIssueCommentOption) (*Comment, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := opt.Validate(); err != nil {
return nil, nil, err
}
// DeleteIssueComment deletes an issue comment.
func (c *Client) DeleteIssueComment(owner, repo string, commentID int64) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/comments/%d", owner, repo, commentID), nil, nil)
return resp, err
}
// ListRepoLabels list labels of one repository
func (c *Client) ListRepoLabels(owner, repo string, opt ListLabelsOptions) ([]*Label, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
labels := make([]*Label, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/labels?%s", owner, repo, opt.getURLQuery().Encode()), nil, nil, &labels)
// GetRepoLabel get one label of repository by repo it
func (c *Client) GetRepoLabel(owner, repo string, id int64) (*Label, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
label := new(Label)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), nil, nil, label)
return label, resp, err
// CreateLabel create one label of repository
func (c *Client) CreateLabel(owner, repo string, opt CreateLabelOption) (*Label, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := opt.Validate(); err != nil {
return nil, nil, err
}
// EditLabel modify one label with options
func (c *Client) EditLabel(owner, repo string, id int64, opt EditLabelOption) (*Label, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := opt.Validate(); err != nil {
return nil, nil, err
}
// DeleteLabel delete one label of repository by id
func (c *Client) DeleteLabel(owner, repo string, id int64) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), nil, nil)
return resp, err
}
// GetIssueLabels get labels of one issue via issue id
func (c *Client) GetIssueLabels(owner, repo string, index int64, opts ListLabelsOptions) ([]*Label, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
labels := make([]*Label, 0, 5)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/labels?%s", owner, repo, index, opts.getURLQuery().Encode()), nil, nil, &labels)
return labels, resp, err
// AddIssueLabels add one or more labels to one issue
func (c *Client) AddIssueLabels(owner, repo string, index int64, opt IssueLabelsOption) ([]*Label, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
body, err := json.Marshal(&opt)
if err != nil {
return nil, nil, err
// ReplaceIssueLabels replace old labels of issue with new labels
func (c *Client) ReplaceIssueLabels(owner, repo string, index int64, opt IssueLabelsOption) ([]*Label, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
body, err := json.Marshal(&opt)
if err != nil {
return nil, nil, err
// DeleteIssueLabel delete one label of one issue by issue id and label id
// TODO: maybe we need delete by label name and issue id
func (c *Client) DeleteIssueLabel(owner, repo string, index, label int64) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/labels/%d", owner, repo, index, label), nil, nil)
return resp, err
}
// ClearIssueLabels delete all the labels of one issue.
func (c *Client) ClearIssueLabels(owner, repo string, index int64) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), nil, nil)
return resp, err
}
// ListRepoMilestones list all the milestones of one repository
func (c *Client) ListRepoMilestones(owner, repo string, opt ListMilestoneOption) ([]*Milestone, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
milestones := make([]*Milestone, 0, opt.PageSize)
// GetMilestone get one milestone by repo name and milestone id
func (c *Client) GetMilestone(owner, repo string, id int64) (*Milestone, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
milestone := new(Milestone)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), nil, nil, milestone)
return milestone, resp, err
m, resp, err := c.resolveMilestoneByName(owner, repo, name)
return m, resp, err
}
+ if err := escapeValidatePathSegments(&owner, &repo, &name); err != nil {
+ return nil, nil, err
+ }
milestone := new(Milestone)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/milestones/%s", owner, repo, name), nil, nil, milestone)
return milestone, resp, err
// CreateMilestone create one milestone with options
func (c *Client) CreateMilestone(owner, repo string, opt CreateMilestoneOption) (*Milestone, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := opt.Validate(); err != nil {
return nil, nil, err
}
// EditMilestone modify milestone with options
func (c *Client) EditMilestone(owner, repo string, id int64, opt EditMilestoneOption) (*Milestone, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := opt.Validate(); err != nil {
return nil, nil, err
}
}
return c.EditMilestone(owner, repo, m.ID, opt)
}
+ if err := escapeValidatePathSegments(&owner, &repo, &name); err != nil {
+ return nil, nil, err
+ }
if err := opt.Validate(); err != nil {
return nil, nil, err
}
// DeleteMilestone delete one milestone by id
func (c *Client) DeleteMilestone(owner, repo string, id int64) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), nil, nil)
return resp, err
}
}
return c.DeleteMilestone(owner, repo, m.ID)
}
+ if err := escapeValidatePathSegments(&owner, &repo, &name); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/milestones/%s", owner, repo, name), nil, nil)
return resp, err
}
// GetIssueReactions get a list reactions of an issue
func (c *Client) GetIssueReactions(owner, repo string, index int64) ([]*Reaction, *Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
return nil, nil, err
}
reactions := make([]*Reaction, 0, 10)
// GetIssueCommentReactions get a list of reactions from a comment of an issue
func (c *Client) GetIssueCommentReactions(owner, repo string, commentID int64) ([]*Reaction, *Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
return nil, nil, err
}
reactions := make([]*Reaction, 0, 10)
// PostIssueReaction add a reaction to an issue
func (c *Client) PostIssueReaction(owner, repo string, index int64, reaction string) (*Reaction, *Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
return nil, nil, err
}
reactionResponse := new(Reaction)
// DeleteIssueReaction remove a reaction from an issue
func (c *Client) DeleteIssueReaction(owner, repo string, index int64, reaction string) (*Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
return nil, err
}
body, err := json.Marshal(&editReactionOption{Reaction: reaction})
// PostIssueCommentReaction add a reaction to a comment of an issue
func (c *Client) PostIssueCommentReaction(owner, repo string, commentID int64, reaction string) (*Reaction, *Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
return nil, nil, err
}
reactionResponse := new(Reaction)
// DeleteIssueCommentReaction remove a reaction from a comment of an issue
func (c *Client) DeleteIssueCommentReaction(owner, repo string, commentID int64, reaction string) (*Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
return nil, err
}
body, err := json.Marshal(&editReactionOption{Reaction: reaction})
// StopWatch represents a running stopwatch of an issue / pr
type StopWatch struct {
- Created time.Time `json:"created"`
- IssueIndex int64 `json:"issue_index"`
+ Created time.Time `json:"created"`
+ Seconds int64 `json:"seconds"`
+ Duration string `json:"duration"`
+ IssueIndex int64 `json:"issue_index"`
+ IssueTitle string `json:"issue_title"`
+ RepoOwnerName string `json:"repo_owner_name"`
+ RepoName string `json:"repo_name"`
}
// GetMyStopwatches list all stopwatches
// DeleteIssueStopwatch delete / cancel a specific stopwatch
func (c *Client) DeleteIssueStopwatch(owner, repo string, index int64) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/delete", owner, repo, index), nil, nil)
return resp, err
}
// StartIssueStopWatch starts a stopwatch for an existing issue for a given
// repository
func (c *Client) StartIssueStopWatch(owner, repo string, index int64) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/start", owner, repo, index), nil, nil)
return resp, err
}
// StopIssueStopWatch stops an existing stopwatch for an issue in a given
// repository
func (c *Client) StopIssueStopWatch(owner, repo string, index int64) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/stop", owner, repo, index), nil, nil)
return resp, err
}
// GetIssueSubscribers get list of users who subscribed on an issue
func (c *Client) GetIssueSubscribers(owner, repo string, index int64) ([]*User, *Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
return nil, nil, err
}
subscribers := make([]*User, 0, 10)
// AddIssueSubscription Subscribe user to issue
func (c *Client) AddIssueSubscription(owner, repo string, index int64, user string) (*Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
+ if err := escapeValidatePathSegments(&owner, &repo, &user); err != nil {
return nil, err
}
status, resp, err := c.getStatusCode("PUT", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions/%s", owner, repo, index, user), nil, nil)
// DeleteIssueSubscription unsubscribe user from issue
func (c *Client) DeleteIssueSubscription(owner, repo string, index int64, user string) (*Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
+ if err := escapeValidatePathSegments(&owner, &repo, &user); err != nil {
return nil, err
}
status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions/%s", owner, repo, index, user), nil, nil)
// CheckIssueSubscription check if current user is subscribed to an issue
func (c *Client) CheckIssueSubscription(owner, repo string, index int64) (*WatchInfo, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return nil, nil, err
}
"bytes"
"encoding/json"
"fmt"
+ "net/url"
"time"
)
Issue *Issue `json:"issue"`
}
-// GetUserTrackedTimes list tracked times of a user
-func (c *Client) GetUserTrackedTimes(owner, repo, user string) ([]*TrackedTime, *Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
- return nil, nil, err
+// ListTrackedTimesOptions options for listing repository's tracked times
+type ListTrackedTimesOptions struct {
+ ListOptions
+ Since time.Time
+ Before time.Time
+ // User filter is only used by ListRepoTrackedTimes !!!
+ User string
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *ListTrackedTimesOptions) QueryEncode() string {
+ query := opt.getURLQuery()
+
+ if !opt.Since.IsZero() {
+ query.Add("since", opt.Since.Format(time.RFC3339))
}
- times := make([]*TrackedTime, 0, 10)
- resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/times/%s", owner, repo, user), nil, nil, ×)
- return times, resp, err
+ if !opt.Before.IsZero() {
+ query.Add("before", opt.Before.Format(time.RFC3339))
+ }
+
+ if len(opt.User) != 0 {
+ query.Add("user", opt.User)
+ }
+
+ return query.Encode()
}
-// GetRepoTrackedTimes list tracked times of a repository
-func (c *Client) GetRepoTrackedTimes(owner, repo string) ([]*TrackedTime, *Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
+// ListRepoTrackedTimes list tracked times of a repository
+func (c *Client) ListRepoTrackedTimes(owner, repo string, opt ListTrackedTimesOptions) ([]*TrackedTime, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
return nil, nil, err
}
- times := make([]*TrackedTime, 0, 10)
- resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/times", owner, repo), nil, nil, ×)
+ link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/times", owner, repo))
+ opt.setDefaults()
+ link.RawQuery = opt.QueryEncode()
+ times := make([]*TrackedTime, 0, opt.PageSize)
+ resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, ×)
return times, resp, err
}
// GetMyTrackedTimes list tracked times of the current user
func (c *Client) GetMyTrackedTimes() ([]*TrackedTime, *Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
- return nil, nil, err
- }
times := make([]*TrackedTime, 0, 10)
- resp, err := c.getParsedResponse("GET", "/user/times", nil, nil, ×)
+ resp, err := c.getParsedResponse("GET", "/user/times", jsonHeader, nil, ×)
return times, resp, err
}
// AddTime adds time to issue with the given index
func (c *Client) AddTime(owner, repo string, index int64, opt AddTimeOption) (*TrackedTime, *Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
return nil, nil, err
}
if err := opt.Validate(); err != nil {
return t, resp, err
}
-// ListTrackedTimesOptions options for listing repository's tracked times
-type ListTrackedTimesOptions struct {
- ListOptions
-}
-
-// ListTrackedTimes list tracked times of a single issue for a given repository
-func (c *Client) ListTrackedTimes(owner, repo string, index int64, opt ListTrackedTimesOptions) ([]*TrackedTime, *Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
+// ListIssueTrackedTimes list tracked times of a single issue for a given repository
+func (c *Client) ListIssueTrackedTimes(owner, repo string, index int64, opt ListTrackedTimesOptions) ([]*TrackedTime, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
return nil, nil, err
}
+ link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/%d/times", owner, repo, index))
opt.setDefaults()
+ link.RawQuery = opt.QueryEncode()
times := make([]*TrackedTime, 0, opt.PageSize)
- resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/times?%s", owner, repo, index, opt.getURLQuery().Encode()), nil, nil, ×)
+ resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, ×)
return times, resp, err
}
// ResetIssueTime reset tracked time of a single issue for a given repository
func (c *Client) ResetIssueTime(owner, repo string, index int64) (*Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
return nil, err
}
- _, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/times", owner, repo, index), nil, nil)
+ _, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/times", owner, repo, index), jsonHeader, nil)
return resp, err
}
// DeleteTime delete a specific tracked time by id of a single issue for a given repository
func (c *Client) DeleteTime(owner, repo string, index, timeID int64) (*Response, error) {
- if err := c.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
return nil, err
}
- _, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/times/%d", owner, repo, index, timeID), nil, nil)
+ _, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/times/%d", owner, repo, index, timeID), jsonHeader, nil)
return resp, err
}
}
// ListRepoNotifications list users's notification threads on a specific repo
-func (c *Client) ListRepoNotifications(owner, reponame string, opt ListNotificationOptions) ([]*NotificationThread, *Response, error) {
+func (c *Client) ListRepoNotifications(owner, repo string, opt ListNotificationOptions) ([]*NotificationThread, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return nil, nil, err
}
if err := opt.Validate(c); err != nil {
return nil, nil, err
}
- link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/notifications", owner, reponame))
+ link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/notifications", owner, repo))
link.RawQuery = opt.QueryEncode()
threads := make([]*NotificationThread, 0, 10)
resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &threads)
}
// ReadRepoNotifications mark notification threads as read on a specific repo
-func (c *Client) ReadRepoNotifications(owner, reponame string, opt MarkNotificationOptions) (*Response, error) {
+func (c *Client) ReadRepoNotifications(owner, repo string, opt MarkNotificationOptions) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return nil, err
}
if err := opt.Validate(c); err != nil {
return nil, err
}
- link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/notifications", owner, reponame))
+ link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/notifications", owner, repo))
link.RawQuery = opt.QueryEncode()
_, resp, err := c.getResponse("PUT", link.String(), nil, nil)
return resp, err
// ListUserOrgs list all of some user's organizations
func (c *Client) ListUserOrgs(user string, opt ListOrgsOptions) ([]*Organization, *Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
orgs := make([]*Organization, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/orgs?%s", user, opt.getURLQuery().Encode()), nil, nil, &orgs)
// GetOrg get one organization by name
func (c *Client) GetOrg(orgname string) (*Organization, *Response, error) {
+ if err := escapeValidatePathSegments(&orgname); err != nil {
+ return nil, nil, err
+ }
org := new(Organization)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s", orgname), nil, nil, org)
return org, resp, err
// EditOrg modify one organization via options
func (c *Client) EditOrg(orgname string, opt EditOrgOption) (*Response, error) {
+ if err := escapeValidatePathSegments(&orgname); err != nil {
+ return nil, err
+ }
if err := opt.Validate(); err != nil {
return nil, err
}
// DeleteOrg deletes an organization
func (c *Client) DeleteOrg(orgname string) (*Response, error) {
+ if err := escapeValidatePathSegments(&orgname); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s", orgname), jsonHeader, nil)
return resp, err
}
// DeleteOrgMembership remove a member from an organization
func (c *Client) DeleteOrgMembership(org, user string) (*Response, error) {
- _, resp, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s/members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
+ if err := escapeValidatePathSegments(&org, &user); err != nil {
+ return nil, err
+ }
+ _, resp, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s/members/%s", org, user), nil, nil)
return resp, err
}
// ListOrgMembership list an organization's members
func (c *Client) ListOrgMembership(org string, opt ListOrgMembershipOption) ([]*User, *Response, error) {
+ if err := escapeValidatePathSegments(&org); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
users := make([]*User, 0, opt.PageSize)
- link, _ := url.Parse(fmt.Sprintf("/orgs/%s/members", url.PathEscape(org)))
+ link, _ := url.Parse(fmt.Sprintf("/orgs/%s/members", org))
link.RawQuery = opt.getURLQuery().Encode()
resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &users)
return users, resp, err
// ListPublicOrgMembership list an organization's members
func (c *Client) ListPublicOrgMembership(org string, opt ListOrgMembershipOption) ([]*User, *Response, error) {
+ if err := escapeValidatePathSegments(&org); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
users := make([]*User, 0, opt.PageSize)
- link, _ := url.Parse(fmt.Sprintf("/orgs/%s/public_members", url.PathEscape(org)))
+ link, _ := url.Parse(fmt.Sprintf("/orgs/%s/public_members", org))
link.RawQuery = opt.getURLQuery().Encode()
resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &users)
return users, resp, err
// CheckOrgMembership Check if a user is a member of an organization
func (c *Client) CheckOrgMembership(org, user string) (bool, *Response, error) {
- status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/orgs/%s/members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
+ if err := escapeValidatePathSegments(&org, &user); err != nil {
+ return false, nil, err
+ }
+ status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/orgs/%s/members/%s", org, user), nil, nil)
if err != nil {
return false, resp, err
}
// CheckPublicOrgMembership Check if a user is a member of an organization
func (c *Client) CheckPublicOrgMembership(org, user string) (bool, *Response, error) {
- status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/orgs/%s/public_members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
+ if err := escapeValidatePathSegments(&org, &user); err != nil {
+ return false, nil, err
+ }
+ status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/orgs/%s/public_members/%s", org, user), nil, nil)
if err != nil {
return false, resp, err
}
// SetPublicOrgMembership publicize/conceal a user's membership
func (c *Client) SetPublicOrgMembership(org, user string, visible bool) (*Response, error) {
+ if err := escapeValidatePathSegments(&org, &user); err != nil {
+ return nil, err
+ }
var (
status int
err error
resp *Response
)
if visible {
- status, resp, err = c.getStatusCode("PUT", fmt.Sprintf("/orgs/%s/public_members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
+ status, resp, err = c.getStatusCode("PUT", fmt.Sprintf("/orgs/%s/public_members/%s", org, user), nil, nil)
} else {
- status, resp, err = c.getStatusCode("DELETE", fmt.Sprintf("/orgs/%s/public_members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
+ status, resp, err = c.getStatusCode("DELETE", fmt.Sprintf("/orgs/%s/public_members/%s", org, user), nil, nil)
}
if err != nil {
return resp, err
// ListOrgTeams lists all teams of an organization
func (c *Client) ListOrgTeams(org string, opt ListTeamsOptions) ([]*Team, *Response, error) {
+ if err := escapeValidatePathSegments(&org); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
teams := make([]*Team, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/teams?%s", org, opt.getURLQuery().Encode()), nil, nil, &teams)
// CreateTeam creates a team for an organization
func (c *Client) CreateTeam(org string, opt CreateTeamOption) (*Team, *Response, error) {
+ if err := escapeValidatePathSegments(&org); err != nil {
+ return nil, nil, err
+ }
if err := opt.Validate(); err != nil {
return nil, nil, err
}
// GetTeamMember gets a member of a team
func (c *Client) GetTeamMember(id int64, user string) (*User, *Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, nil, err
+ }
m := new(User)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil, m)
return m, resp, err
// AddTeamMember adds a member to a team
func (c *Client) AddTeamMember(id int64, user string) (*Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("PUT", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil)
return resp, err
}
// RemoveTeamMember removes a member from a team
func (c *Client) RemoveTeamMember(id int64, user string) (*Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil)
return resp, err
}
// AddTeamRepository adds a repository to a team
func (c *Client) AddTeamRepository(id int64, org, repo string) (*Response, error) {
+ if err := escapeValidatePathSegments(&org, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("PUT", fmt.Sprintf("/teams/%d/repos/%s/%s", id, org, repo), nil, nil)
return resp, err
}
// RemoveTeamRepository removes a repository from a team
func (c *Client) RemoveTeamRepository(id int64, org, repo string) (*Response, error) {
+ if err := escapeValidatePathSegments(&org, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/teams/%d/repos/%s/%s", id, org, repo), nil, nil)
return resp, err
}
// ListRepoPullRequests list PRs of one repository
func (c *Client) ListRepoPullRequests(owner, repo string, opt ListPullRequestsOptions) ([]*PullRequest, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
prs := make([]*PullRequest, 0, opt.PageSize)
link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/pulls", owner, repo))
link.RawQuery = opt.QueryEncode()
resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &prs)
+ if c.checkServerVersionGreaterThanOrEqual(version1_14_0) != nil {
+ for i := range prs {
+ if err := fixPullHeadSha(c, prs[i]); err != nil {
+ return prs, resp, err
+ }
+ }
+ }
return prs, resp, err
}
// GetPullRequest get information of one PR
func (c *Client) GetPullRequest(owner, repo string, index int64) (*PullRequest, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
pr := new(PullRequest)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d", owner, repo, index), nil, nil, pr)
+ if c.checkServerVersionGreaterThanOrEqual(version1_14_0) != nil {
+ if err := fixPullHeadSha(c, pr); err != nil {
+ return pr, resp, err
+ }
+ }
return pr, resp, err
}
// CreatePullRequest create pull request with options
func (c *Client) CreatePullRequest(owner, repo string, opt CreatePullRequestOption) (*PullRequest, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
body, err := json.Marshal(&opt)
if err != nil {
return nil, nil, err
// EditPullRequest modify pull request with PR id and options
func (c *Client) EditPullRequest(owner, repo string, index int64, opt EditPullRequestOption) (*PullRequest, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := opt.Validate(c); err != nil {
return nil, nil, err
}
// MergePullRequest merge a PR to repository by PR id
func (c *Client) MergePullRequest(owner, repo string, index int64, opt MergePullRequestOption) (bool, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return false, nil, err
+ }
if err := opt.Validate(c); err != nil {
return false, nil, err
}
// IsPullRequestMerged test if one PR is merged to one repository
func (c *Client) IsPullRequestMerged(owner, repo string, index int64) (bool, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return false, nil, err
+ }
status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d/merge", owner, repo, index), nil, nil)
if err != nil {
// getPullRequestDiffOrPatch gets the patch or diff file as bytes for a PR
func (c *Client) getPullRequestDiffOrPatch(owner, repo, kind string, index int64) ([]byte, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo, &kind); err != nil {
+ return nil, nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_13_0); err != nil {
r, _, err2 := c.GetRepo(owner, repo)
if err2 != nil {
func (c *Client) GetPullRequestDiff(owner, repo string, index int64) ([]byte, *Response, error) {
return c.getPullRequestDiffOrPatch(owner, repo, "diff", index)
}
+
+// fixPullHeadSha is a workaround for https://github.com/go-gitea/gitea/issues/12675
+// When no head sha is available, this is because the branch got deleted in the base repo.
+// pr.Head.Ref points in this case not to the head repo branch name, but the base repo ref,
+// which stays available to resolve the commit sha. This is fixed for gitea >= 1.14.0
+func fixPullHeadSha(client *Client, pr *PullRequest) error {
+ if pr.Base != nil && pr.Base.Repository != nil && pr.Base.Repository.Owner != nil &&
+ pr.Head != nil && pr.Head.Ref != "" && pr.Head.Sha == "" {
+ owner := pr.Base.Repository.Owner.UserName
+ repo := pr.Base.Repository.Name
+ refs, _, err := client.GetRepoRefs(owner, repo, pr.Head.Ref)
+ if err != nil {
+ return err
+ } else if len(refs) == 0 {
+ return fmt.Errorf("unable to resolve PR ref '%s'", pr.Head.Ref)
+ }
+ pr.Head.Sha = refs[0].Object.SHA
+ }
+ return nil
+}
// PullReview represents a pull request review
type PullReview struct {
- ID int64 `json:"id"`
- Reviewer *User `json:"user"`
- State ReviewStateType `json:"state"`
- Body string `json:"body"`
- CommitID string `json:"commit_id"`
- Stale bool `json:"stale"`
- Official bool `json:"official"`
- CodeCommentsCount int `json:"comments_count"`
- Submitted time.Time `json:"submitted_at"`
+ ID int64 `json:"id"`
+ Reviewer *User `json:"user"`
+ ReviewerTeam *Team `json:"team"`
+ State ReviewStateType `json:"state"`
+ Body string `json:"body"`
+ CommitID string `json:"commit_id"`
+ // Stale indicates if the pull has changed since the review
+ Stale bool `json:"stale"`
+ // Official indicates if the review counts towards the required approval limit, if PR base is a protected branch
+ Official bool `json:"official"`
+ Dismissed bool `json:"dismissed"`
+ CodeCommentsCount int `json:"comments_count"`
+ Submitted time.Time `json:"submitted_at"`
HTMLURL string `json:"html_url"`
HTMLPullURL string `json:"pull_request_url"`
Body string `json:"body"`
}
+// DismissPullReviewOptions are options to dismiss a pull review
+type DismissPullReviewOptions struct {
+ Message string `json:"message"`
+}
+
+// PullReviewRequestOptions are options to add or remove pull review requests
+type PullReviewRequestOptions struct {
+ Reviewers []string `json:"reviewers"`
+ TeamReviewers []string `json:"team_reviewers"`
+}
+
// ListPullReviewsOptions options for listing PullReviews
type ListPullReviewsOptions struct {
ListOptions
// ListPullReviews lists all reviews of a pull request
func (c *Client) ListPullReviews(owner, repo string, index int64, opt ListPullReviewsOptions) ([]*PullReview, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return nil, nil, err
}
// GetPullReview gets a specific review of a pull request
func (c *Client) GetPullReview(owner, repo string, index, id int64) (*PullReview, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return nil, nil, err
}
// ListPullReviewComments lists all comments of a pull request review
func (c *Client) ListPullReviewComments(owner, repo string, index, id int64) ([]*PullReviewComment, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return nil, nil, err
}
// DeletePullReview delete a specific review from a pull request
func (c *Client) DeletePullReview(owner, repo string, index, id int64) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return nil, err
}
// CreatePullReview create a review to an pull request
func (c *Client) CreatePullReview(owner, repo string, index int64, opt CreatePullReviewOptions) (*PullReview, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return nil, nil, err
}
// SubmitPullReview submit a pending review to an pull request
func (c *Client) SubmitPullReview(owner, repo string, index, id int64, opt SubmitPullReviewOptions) (*PullReview, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return nil, nil, err
}
jsonHeader, bytes.NewReader(body), r)
return r, resp, err
}
+
+// CreateReviewRequests create review requests to an pull request
+func (c *Client) CreateReviewRequests(owner, repo string, index int64, opt PullReviewRequestOptions) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
+ if err := c.checkServerVersionGreaterThanOrEqual(version1_14_0); err != nil {
+ return nil, err
+ }
+ body, err := json.Marshal(&opt)
+ if err != nil {
+ return nil, err
+ }
+
+ _, resp, err := c.getResponse("POST",
+ fmt.Sprintf("/repos/%s/%s/pulls/%d/requested_reviewers", owner, repo, index),
+ jsonHeader, bytes.NewReader(body))
+ return resp, err
+}
+
+// DeleteReviewRequests delete review requests to an pull request
+func (c *Client) DeleteReviewRequests(owner, repo string, index int64, opt PullReviewRequestOptions) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
+ if err := c.checkServerVersionGreaterThanOrEqual(version1_14_0); err != nil {
+ return nil, err
+ }
+ body, err := json.Marshal(&opt)
+ if err != nil {
+ return nil, err
+ }
+
+ _, resp, err := c.getResponse("DELETE",
+ fmt.Sprintf("/repos/%s/%s/pulls/%d/requested_reviewers", owner, repo, index),
+ jsonHeader, bytes.NewReader(body))
+ return resp, err
+}
+
+// DismissPullReview dismiss a review for a pull request
+func (c *Client) DismissPullReview(owner, repo string, index, id int64, opt DismissPullReviewOptions) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
+ if err := c.checkServerVersionGreaterThanOrEqual(version1_14_0); err != nil {
+ return nil, err
+ }
+ body, err := json.Marshal(&opt)
+ if err != nil {
+ return nil, err
+ }
+
+ _, resp, err := c.getResponse("POST",
+ fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d/dismissals", owner, repo, index, id),
+ jsonHeader, bytes.NewReader(body))
+ return resp, err
+}
+
+// UnDismissPullReview cancel to dismiss a review for a pull request
+func (c *Client) UnDismissPullReview(owner, repo string, index, id int64) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
+ if err := c.checkServerVersionGreaterThanOrEqual(version1_14_0); err != nil {
+ return nil, err
+ }
+
+ _, resp, err := c.getResponse("POST",
+ fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d/undismissals", owner, repo, index, id),
+ jsonHeader, nil)
+ return resp, err
+}
Title string `json:"name"`
Note string `json:"body"`
URL string `json:"url"`
+ HTMLURL string `json:"html_url"`
TarURL string `json:"tarball_url"`
ZipURL string `json:"zipball_url"`
IsDraft bool `json:"draft"`
}
// ListReleases list releases of a repository
-func (c *Client) ListReleases(user, repo string, opt ListReleasesOptions) ([]*Release, *Response, error) {
+func (c *Client) ListReleases(owner, repo string, opt ListReleasesOptions) ([]*Release, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
releases := make([]*Release, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET",
- fmt.Sprintf("/repos/%s/%s/releases?%s", user, repo, opt.getURLQuery().Encode()),
+ fmt.Sprintf("/repos/%s/%s/releases?%s", owner, repo, opt.getURLQuery().Encode()),
nil, nil, &releases)
return releases, resp, err
}
// GetRelease get a release of a repository by id
-func (c *Client) GetRelease(user, repo string, id int64) (*Release, *Response, error) {
+func (c *Client) GetRelease(owner, repo string, id int64) (*Release, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
r := new(Release)
resp, err := c.getParsedResponse("GET",
- fmt.Sprintf("/repos/%s/%s/releases/%d", user, repo, id),
+ fmt.Sprintf("/repos/%s/%s/releases/%d", owner, repo, id),
jsonHeader, nil, &r)
return r, resp, err
}
// GetReleaseByTag get a release of a repository by tag
-func (c *Client) GetReleaseByTag(user, repo string, tag string) (*Release, *Response, error) {
+func (c *Client) GetReleaseByTag(owner, repo string, tag string) (*Release, *Response, error) {
if c.checkServerVersionGreaterThanOrEqual(version1_13_0) != nil {
- return c.fallbackGetReleaseByTag(user, repo, tag)
+ return c.fallbackGetReleaseByTag(owner, repo, tag)
+ }
+ if err := escapeValidatePathSegments(&owner, &repo, &tag); err != nil {
+ return nil, nil, err
}
r := new(Release)
resp, err := c.getParsedResponse("GET",
- fmt.Sprintf("/repos/%s/%s/releases/tags/%s", user, repo, tag),
+ fmt.Sprintf("/repos/%s/%s/releases/tags/%s", owner, repo, tag),
nil, nil, &r)
return r, resp, err
}
}
// CreateRelease create a release
-func (c *Client) CreateRelease(user, repo string, opt CreateReleaseOption) (*Release, *Response, error) {
+func (c *Client) CreateRelease(owner, repo string, opt CreateReleaseOption) (*Release, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := opt.Validate(); err != nil {
return nil, nil, err
}
}
r := new(Release)
resp, err := c.getParsedResponse("POST",
- fmt.Sprintf("/repos/%s/%s/releases", user, repo),
+ fmt.Sprintf("/repos/%s/%s/releases", owner, repo),
jsonHeader, bytes.NewReader(body), r)
return r, resp, err
}
}
// EditRelease edit a release
-func (c *Client) EditRelease(user, repo string, id int64, form EditReleaseOption) (*Release, *Response, error) {
+func (c *Client) EditRelease(owner, repo string, id int64, form EditReleaseOption) (*Release, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
body, err := json.Marshal(form)
if err != nil {
return nil, nil, err
}
r := new(Release)
resp, err := c.getParsedResponse("PATCH",
- fmt.Sprintf("/repos/%s/%s/releases/%d", user, repo, id),
+ fmt.Sprintf("/repos/%s/%s/releases/%d", owner, repo, id),
jsonHeader, bytes.NewReader(body), r)
return r, resp, err
}
-// DeleteRelease delete a release from a repository
+// DeleteRelease delete a release from a repository, keeping its tag
func (c *Client) DeleteRelease(user, repo string, id int64) (*Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE",
fmt.Sprintf("/repos/%s/%s/releases/%d", user, repo, id),
nil, nil)
return resp, err
}
+// DeleteReleaseByTag deletes a release frm a repository by tag
+func (c *Client) DeleteReleaseByTag(user, repo string, tag string) (*Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo, &tag); err != nil {
+ return nil, err
+ }
+ if err := c.checkServerVersionGreaterThanOrEqual(version1_14_0); err != nil {
+ return nil, err
+ }
+ _, resp, err := c.getResponse("DELETE",
+ fmt.Sprintf("/repos/%s/%s/releases/tags/%s", user, repo, tag),
+ nil, nil)
+ return resp, err
+}
+
// fallbackGetReleaseByTag is fallback for old gitea installations ( < 1.13.0 )
-func (c *Client) fallbackGetReleaseByTag(user, repo string, tag string) (*Release, *Response, error) {
+func (c *Client) fallbackGetReleaseByTag(owner, repo string, tag string) (*Release, *Response, error) {
for i := 1; ; i++ {
- rl, resp, err := c.ListReleases(user, repo, ListReleasesOptions{ListOptions{Page: i}})
+ rl, resp, err := c.ListReleases(owner, repo, ListReleasesOptions{ListOptions{Page: i}})
if err != nil {
return nil, resp, err
}
"bytes"
"encoding/json"
"fmt"
+ "io"
"net/url"
"strings"
"time"
Pull bool `json:"pull"`
}
+// InternalTracker represents settings for internal tracker
+type InternalTracker struct {
+ // Enable time tracking (Built-in issue tracker)
+ EnableTimeTracker bool `json:"enable_time_tracker"`
+ // Let only contributors track time (Built-in issue tracker)
+ AllowOnlyContributorsToTrackTime bool `json:"allow_only_contributors_to_track_time"`
+ // Enable dependencies for issues and pull requests (Built-in issue tracker)
+ EnableIssueDependencies bool `json:"enable_issue_dependencies"`
+}
+
+// ExternalTracker represents settings for external tracker
+type ExternalTracker struct {
+ // URL of external issue tracker.
+ ExternalTrackerURL string `json:"external_tracker_url"`
+ // External Issue Tracker URL Format. Use the placeholders {user}, {repo} and {index} for the username, repository name and issue index.
+ ExternalTrackerFormat string `json:"external_tracker_format"`
+ // External Issue Tracker Number Format, either `numeric` or `alphanumeric`
+ ExternalTrackerStyle string `json:"external_tracker_style"`
+}
+
+// ExternalWiki represents setting for external wiki
+type ExternalWiki struct {
+ // URL of external wiki.
+ ExternalWikiURL string `json:"external_wiki_url"`
+}
+
// Repository represents a repository
type Repository struct {
- ID int64 `json:"id"`
- Owner *User `json:"owner"`
- Name string `json:"name"`
- FullName string `json:"full_name"`
- Description string `json:"description"`
- Empty bool `json:"empty"`
- Private bool `json:"private"`
- Fork bool `json:"fork"`
- Parent *Repository `json:"parent"`
- Mirror bool `json:"mirror"`
- Size int `json:"size"`
- HTMLURL string `json:"html_url"`
- SSHURL string `json:"ssh_url"`
- CloneURL string `json:"clone_url"`
- OriginalURL string `json:"original_url"`
- Website string `json:"website"`
- Stars int `json:"stars_count"`
- Forks int `json:"forks_count"`
- Watchers int `json:"watchers_count"`
- OpenIssues int `json:"open_issues_count"`
- DefaultBranch string `json:"default_branch"`
- Archived bool `json:"archived"`
- Created time.Time `json:"created_at"`
- Updated time.Time `json:"updated_at"`
- Permissions *Permission `json:"permissions,omitempty"`
- HasIssues bool `json:"has_issues"`
- HasWiki bool `json:"has_wiki"`
- HasPullRequests bool `json:"has_pull_requests"`
- IgnoreWhitespaceConflicts bool `json:"ignore_whitespace_conflicts"`
- AllowMerge bool `json:"allow_merge_commits"`
- AllowRebase bool `json:"allow_rebase"`
- AllowRebaseMerge bool `json:"allow_rebase_explicit"`
- AllowSquash bool `json:"allow_squash_merge"`
- AvatarURL string `json:"avatar_url"`
+ ID int64 `json:"id"`
+ Owner *User `json:"owner"`
+ Name string `json:"name"`
+ FullName string `json:"full_name"`
+ Description string `json:"description"`
+ Empty bool `json:"empty"`
+ Private bool `json:"private"`
+ Fork bool `json:"fork"`
+ Template bool `json:"template"`
+ Parent *Repository `json:"parent"`
+ Mirror bool `json:"mirror"`
+ Size int `json:"size"`
+ HTMLURL string `json:"html_url"`
+ SSHURL string `json:"ssh_url"`
+ CloneURL string `json:"clone_url"`
+ OriginalURL string `json:"original_url"`
+ Website string `json:"website"`
+ Stars int `json:"stars_count"`
+ Forks int `json:"forks_count"`
+ Watchers int `json:"watchers_count"`
+ OpenIssues int `json:"open_issues_count"`
+ OpenPulls int `json:"open_pr_counter"`
+ Releases int `json:"release_counter"`
+ DefaultBranch string `json:"default_branch"`
+ Archived bool `json:"archived"`
+ Created time.Time `json:"created_at"`
+ Updated time.Time `json:"updated_at"`
+ Permissions *Permission `json:"permissions,omitempty"`
+ HasIssues bool `json:"has_issues"`
+ InternalTracker *InternalTracker `json:"internal_tracker,omitempty"`
+ ExternalTracker *ExternalTracker `json:"external_tracker,omitempty"`
+ HasWiki bool `json:"has_wiki"`
+ ExternalWiki *ExternalWiki `json:"external_wiki,omitempty"`
+ HasPullRequests bool `json:"has_pull_requests"`
+ HasProjects bool `json:"has_projects"`
+ IgnoreWhitespaceConflicts bool `json:"ignore_whitespace_conflicts"`
+ AllowMerge bool `json:"allow_merge_commits"`
+ AllowRebase bool `json:"allow_rebase"`
+ AllowRebaseMerge bool `json:"allow_rebase_explicit"`
+ AllowSquash bool `json:"allow_squash_merge"`
+ AvatarURL string `json:"avatar_url"`
+ Internal bool `json:"internal"`
+ MirrorInterval string `json:"mirror_interval"`
}
// RepoType represent repo type
// ListUserRepos list all repositories of one user by user's name
func (c *Client) ListUserRepos(user string, opt ListReposOptions) ([]*Repository, *Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
repos := make([]*Repository, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/repos?%s", user, opt.getURLQuery().Encode()), nil, nil, &repos)
// ListOrgRepos list all repositories of one organization by organization's name
func (c *Client) ListOrgRepos(org string, opt ListOrgReposOptions) ([]*Repository, *Response, error) {
+ if err := escapeValidatePathSegments(&org); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
repos := make([]*Repository, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/repos?%s", org, opt.getURLQuery().Encode()), nil, nil, &repos)
// CreateOrgRepo creates an organization repository for authenticated user.
func (c *Client) CreateOrgRepo(org string, opt CreateRepoOption) (*Repository, *Response, error) {
+ if err := escapeValidatePathSegments(&org); err != nil {
+ return nil, nil, err
+ }
if err := opt.Validate(c); err != nil {
return nil, nil, err
}
// GetRepo returns information of a repository of given owner.
func (c *Client) GetRepo(owner, reponame string) (*Repository, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &reponame); err != nil {
+ return nil, nil, err
+ }
repo := new(Repository)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s", owner, reponame), nil, nil, repo)
return repo, resp, err
// Note: you will get a 422 error if the organization restricts changing repository visibility to organization
// owners and a non-owner tries to change the value of private.
Private *bool `json:"private,omitempty"`
+ // either `true` to make this repository a template or `false` to make it a normal repository
+ Template *bool `json:"template,omitempty"`
// either `true` to enable issues for this repository or `false` to disable them.
HasIssues *bool `json:"has_issues,omitempty"`
+ // set this structure to configure internal issue tracker (requires has_issues)
+ InternalTracker *InternalTracker `json:"internal_tracker,omitempty"`
+ // set this structure to use external issue tracker (requires has_issues)
+ ExternalTracker *ExternalTracker `json:"external_tracker,omitempty"`
// either `true` to enable the wiki for this repository or `false` to disable it.
HasWiki *bool `json:"has_wiki,omitempty"`
+ // set this structure to use external wiki instead of internal (requires has_wiki)
+ ExternalWiki *ExternalWiki `json:"external_wiki,omitempty"`
// sets the default branch for this repository.
DefaultBranch *string `json:"default_branch,omitempty"`
// either `true` to allow pull requests, or `false` to prevent pull request.
HasPullRequests *bool `json:"has_pull_requests,omitempty"`
+ // either `true` to enable project unit, or `false` to disable them.
+ HasProjects *bool `json:"has_projects,omitempty"`
// either `true` to ignore whitespace for conflicts, or `false` to not ignore whitespace. `has_pull_requests` must be `true`.
IgnoreWhitespaceConflicts *bool `json:"ignore_whitespace_conflicts,omitempty"`
// either `true` to allow merging pull requests with a merge commit, or `false` to prevent merging pull requests with merge commits. `has_pull_requests` must be `true`.
AllowSquash *bool `json:"allow_squash_merge,omitempty"`
// set to `true` to archive this repository.
Archived *bool `json:"archived,omitempty"`
+ // set to a string like `8h30m0s` to set the mirror interval time
+ MirrorInterval *string `json:"mirror_interval,omitempty"`
}
// EditRepo edit the properties of a repository
func (c *Client) EditRepo(owner, reponame string, opt EditRepoOption) (*Repository, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &reponame); err != nil {
+ return nil, nil, err
+ }
body, err := json.Marshal(&opt)
if err != nil {
return nil, nil, err
// DeleteRepo deletes a repository of user or organization.
func (c *Client) DeleteRepo(owner, repo string) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s", owner, repo), nil, nil)
return resp, err
}
// MirrorSync adds a mirrored repository to the mirror sync queue.
func (c *Client) MirrorSync(owner, repo string) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/mirror-sync", owner, repo), nil, nil)
return resp, err
}
// GetRepoLanguages return language stats of a repo
func (c *Client) GetRepoLanguages(owner, repo string) (map[string]int64, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
langMap := make(map[string]int64)
data, resp, err := c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/languages", owner, repo), jsonHeader, nil)
// GetArchive get an archive of a repository by git reference
// e.g.: ref -> master, 70b7c74b33, v1.2.1, ...
func (c *Client) GetArchive(owner, repo, ref string, ext ArchiveType) ([]byte, *Response, error) {
- return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/archive/%s%s", owner, repo, url.PathEscape(ref), ext), nil, nil)
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
+ ref = pathEscapeSegments(ref)
+ return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/archive/%s%s", owner, repo, ref, ext), nil, nil)
+}
+
+// GetArchiveReader gets a `git archive` for a particular tree-ish git reference
+// such as a branch name (`master`), a commit hash (`70b7c74b33`), a tag
+// (`v1.2.1`). The archive is returned as a byte stream in a ReadCloser. It is
+// the responsibility of the client to close the reader.
+func (c *Client) GetArchiveReader(owner, repo, ref string, ext ArchiveType) (io.ReadCloser, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
+ ref = pathEscapeSegments(ref)
+ resp, err := c.doRequest("GET", fmt.Sprintf("/repos/%s/%s/archive/%s%s", owner, repo, ref, ext), nil, nil)
+ if err != nil {
+ return nil, resp, err
+ }
+
+ if _, err := statusCodeToErr(resp); err != nil {
+ return nil, resp, err
+ }
+
+ return resp.Body, resp, nil
}
UserName string `json:"username"`
}
-// FIXME: consider using same format as API when commits API are added.
-// applies to PayloadCommit and PayloadCommitVerification
-
// PayloadCommit represents a commit
type PayloadCommit struct {
// sha1 hash of the commit
// ListRepoBranches list all the branches of one repository
func (c *Client) ListRepoBranches(user, repo string, opt ListRepoBranchesOptions) ([]*Branch, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
branches := make([]*Branch, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branches?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &branches)
// GetRepoBranch get one branch's information of one repository
func (c *Client) GetRepoBranch(user, repo, branch string) (*Branch, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo, &branch); err != nil {
+ return nil, nil, err
+ }
b := new(Branch)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branches/%s", user, repo, branch), nil, nil, &b)
if err != nil {
// DeleteRepoBranch delete a branch in a repository
func (c *Client) DeleteRepoBranch(user, repo, branch string) (bool, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo, &branch); err != nil {
+ return false, nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return false, nil, err
}
// CreateBranch creates a branch for a user's repository
func (c *Client) CreateBranch(owner, repo string, opt CreateBranchOption) (*Branch, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_13_0); err != nil {
return nil, nil, err
}
// BranchProtection represents a branch protection for a repository
type BranchProtection struct {
- BranchName string `json:"branch_name"`
- EnablePush bool `json:"enable_push"`
- EnablePushWhitelist bool `json:"enable_push_whitelist"`
- PushWhitelistUsernames []string `json:"push_whitelist_usernames"`
- PushWhitelistTeams []string `json:"push_whitelist_teams"`
- PushWhitelistDeployKeys bool `json:"push_whitelist_deploy_keys"`
- EnableMergeWhitelist bool `json:"enable_merge_whitelist"`
- MergeWhitelistUsernames []string `json:"merge_whitelist_usernames"`
- MergeWhitelistTeams []string `json:"merge_whitelist_teams"`
- EnableStatusCheck bool `json:"enable_status_check"`
- StatusCheckContexts []string `json:"status_check_contexts"`
- RequiredApprovals int64 `json:"required_approvals"`
- EnableApprovalsWhitelist bool `json:"enable_approvals_whitelist"`
- ApprovalsWhitelistUsernames []string `json:"approvals_whitelist_username"`
- ApprovalsWhitelistTeams []string `json:"approvals_whitelist_teams"`
- BlockOnRejectedReviews bool `json:"block_on_rejected_reviews"`
- BlockOnOutdatedBranch bool `json:"block_on_outdated_branch"`
- DismissStaleApprovals bool `json:"dismiss_stale_approvals"`
- RequireSignedCommits bool `json:"require_signed_commits"`
- ProtectedFilePatterns string `json:"protected_file_patterns"`
- Created time.Time `json:"created_at"`
- Updated time.Time `json:"updated_at"`
+ BranchName string `json:"branch_name"`
+ EnablePush bool `json:"enable_push"`
+ EnablePushWhitelist bool `json:"enable_push_whitelist"`
+ PushWhitelistUsernames []string `json:"push_whitelist_usernames"`
+ PushWhitelistTeams []string `json:"push_whitelist_teams"`
+ PushWhitelistDeployKeys bool `json:"push_whitelist_deploy_keys"`
+ EnableMergeWhitelist bool `json:"enable_merge_whitelist"`
+ MergeWhitelistUsernames []string `json:"merge_whitelist_usernames"`
+ MergeWhitelistTeams []string `json:"merge_whitelist_teams"`
+ EnableStatusCheck bool `json:"enable_status_check"`
+ StatusCheckContexts []string `json:"status_check_contexts"`
+ RequiredApprovals int64 `json:"required_approvals"`
+ EnableApprovalsWhitelist bool `json:"enable_approvals_whitelist"`
+ ApprovalsWhitelistUsernames []string `json:"approvals_whitelist_username"`
+ ApprovalsWhitelistTeams []string `json:"approvals_whitelist_teams"`
+ BlockOnRejectedReviews bool `json:"block_on_rejected_reviews"`
+ BlockOnOfficialReviewRequests bool `json:"block_on_official_review_requests"`
+ BlockOnOutdatedBranch bool `json:"block_on_outdated_branch"`
+ DismissStaleApprovals bool `json:"dismiss_stale_approvals"`
+ RequireSignedCommits bool `json:"require_signed_commits"`
+ ProtectedFilePatterns string `json:"protected_file_patterns"`
+ Created time.Time `json:"created_at"`
+ Updated time.Time `json:"updated_at"`
}
// CreateBranchProtectionOption options for creating a branch protection
type CreateBranchProtectionOption struct {
- BranchName string `json:"branch_name"`
- EnablePush bool `json:"enable_push"`
- EnablePushWhitelist bool `json:"enable_push_whitelist"`
- PushWhitelistUsernames []string `json:"push_whitelist_usernames"`
- PushWhitelistTeams []string `json:"push_whitelist_teams"`
- PushWhitelistDeployKeys bool `json:"push_whitelist_deploy_keys"`
- EnableMergeWhitelist bool `json:"enable_merge_whitelist"`
- MergeWhitelistUsernames []string `json:"merge_whitelist_usernames"`
- MergeWhitelistTeams []string `json:"merge_whitelist_teams"`
- EnableStatusCheck bool `json:"enable_status_check"`
- StatusCheckContexts []string `json:"status_check_contexts"`
- RequiredApprovals int64 `json:"required_approvals"`
- EnableApprovalsWhitelist bool `json:"enable_approvals_whitelist"`
- ApprovalsWhitelistUsernames []string `json:"approvals_whitelist_username"`
- ApprovalsWhitelistTeams []string `json:"approvals_whitelist_teams"`
- BlockOnRejectedReviews bool `json:"block_on_rejected_reviews"`
- BlockOnOutdatedBranch bool `json:"block_on_outdated_branch"`
- DismissStaleApprovals bool `json:"dismiss_stale_approvals"`
- RequireSignedCommits bool `json:"require_signed_commits"`
- ProtectedFilePatterns string `json:"protected_file_patterns"`
+ BranchName string `json:"branch_name"`
+ EnablePush bool `json:"enable_push"`
+ EnablePushWhitelist bool `json:"enable_push_whitelist"`
+ PushWhitelistUsernames []string `json:"push_whitelist_usernames"`
+ PushWhitelistTeams []string `json:"push_whitelist_teams"`
+ PushWhitelistDeployKeys bool `json:"push_whitelist_deploy_keys"`
+ EnableMergeWhitelist bool `json:"enable_merge_whitelist"`
+ MergeWhitelistUsernames []string `json:"merge_whitelist_usernames"`
+ MergeWhitelistTeams []string `json:"merge_whitelist_teams"`
+ EnableStatusCheck bool `json:"enable_status_check"`
+ StatusCheckContexts []string `json:"status_check_contexts"`
+ RequiredApprovals int64 `json:"required_approvals"`
+ EnableApprovalsWhitelist bool `json:"enable_approvals_whitelist"`
+ ApprovalsWhitelistUsernames []string `json:"approvals_whitelist_username"`
+ ApprovalsWhitelistTeams []string `json:"approvals_whitelist_teams"`
+ BlockOnRejectedReviews bool `json:"block_on_rejected_reviews"`
+ BlockOnOfficialReviewRequests bool `json:"block_on_official_review_requests"`
+ BlockOnOutdatedBranch bool `json:"block_on_outdated_branch"`
+ DismissStaleApprovals bool `json:"dismiss_stale_approvals"`
+ RequireSignedCommits bool `json:"require_signed_commits"`
+ ProtectedFilePatterns string `json:"protected_file_patterns"`
}
// EditBranchProtectionOption options for editing a branch protection
type EditBranchProtectionOption struct {
- EnablePush *bool `json:"enable_push"`
- EnablePushWhitelist *bool `json:"enable_push_whitelist"`
- PushWhitelistUsernames []string `json:"push_whitelist_usernames"`
- PushWhitelistTeams []string `json:"push_whitelist_teams"`
- PushWhitelistDeployKeys *bool `json:"push_whitelist_deploy_keys"`
- EnableMergeWhitelist *bool `json:"enable_merge_whitelist"`
- MergeWhitelistUsernames []string `json:"merge_whitelist_usernames"`
- MergeWhitelistTeams []string `json:"merge_whitelist_teams"`
- EnableStatusCheck *bool `json:"enable_status_check"`
- StatusCheckContexts []string `json:"status_check_contexts"`
- RequiredApprovals *int64 `json:"required_approvals"`
- EnableApprovalsWhitelist *bool `json:"enable_approvals_whitelist"`
- ApprovalsWhitelistUsernames []string `json:"approvals_whitelist_username"`
- ApprovalsWhitelistTeams []string `json:"approvals_whitelist_teams"`
- BlockOnRejectedReviews *bool `json:"block_on_rejected_reviews"`
- BlockOnOutdatedBranch *bool `json:"block_on_outdated_branch"`
- DismissStaleApprovals *bool `json:"dismiss_stale_approvals"`
- RequireSignedCommits *bool `json:"require_signed_commits"`
- ProtectedFilePatterns *string `json:"protected_file_patterns"`
+ EnablePush *bool `json:"enable_push"`
+ EnablePushWhitelist *bool `json:"enable_push_whitelist"`
+ PushWhitelistUsernames []string `json:"push_whitelist_usernames"`
+ PushWhitelistTeams []string `json:"push_whitelist_teams"`
+ PushWhitelistDeployKeys *bool `json:"push_whitelist_deploy_keys"`
+ EnableMergeWhitelist *bool `json:"enable_merge_whitelist"`
+ MergeWhitelistUsernames []string `json:"merge_whitelist_usernames"`
+ MergeWhitelistTeams []string `json:"merge_whitelist_teams"`
+ EnableStatusCheck *bool `json:"enable_status_check"`
+ StatusCheckContexts []string `json:"status_check_contexts"`
+ RequiredApprovals *int64 `json:"required_approvals"`
+ EnableApprovalsWhitelist *bool `json:"enable_approvals_whitelist"`
+ ApprovalsWhitelistUsernames []string `json:"approvals_whitelist_username"`
+ ApprovalsWhitelistTeams []string `json:"approvals_whitelist_teams"`
+ BlockOnRejectedReviews *bool `json:"block_on_rejected_reviews"`
+ BlockOnOfficialReviewRequests *bool `json:"block_on_official_review_requests"`
+ BlockOnOutdatedBranch *bool `json:"block_on_outdated_branch"`
+ DismissStaleApprovals *bool `json:"dismiss_stale_approvals"`
+ RequireSignedCommits *bool `json:"require_signed_commits"`
+ ProtectedFilePatterns *string `json:"protected_file_patterns"`
}
// ListBranchProtectionsOptions list branch protection options
// ListBranchProtections list branch protections for a repo
func (c *Client) ListBranchProtections(owner, repo string, opt ListBranchProtectionsOptions) ([]*BranchProtection, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return nil, nil, err
}
// GetBranchProtection gets a branch protection
func (c *Client) GetBranchProtection(owner, repo, name string) (*BranchProtection, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo, &name); err != nil {
+ return nil, nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return nil, nil, err
}
// CreateBranchProtection creates a branch protection for a repo
func (c *Client) CreateBranchProtection(owner, repo string, opt CreateBranchProtectionOption) (*BranchProtection, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return nil, nil, err
}
// EditBranchProtection edits a branch protection for a repo
func (c *Client) EditBranchProtection(owner, repo, name string, opt EditBranchProtectionOption) (*BranchProtection, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo, &name); err != nil {
+ return nil, nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return nil, nil, err
}
// DeleteBranchProtection deletes a branch protection for a repo
func (c *Client) DeleteBranchProtection(owner, repo, name string) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo, &name); err != nil {
+ return nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return nil, err
}
// ListCollaborators list a repository's collaborators
func (c *Client) ListCollaborators(user, repo string, opt ListCollaboratorsOptions) ([]*User, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
collaborators := make([]*User, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET",
// IsCollaborator check if a user is a collaborator of a repository
func (c *Client) IsCollaborator(user, repo, collaborator string) (bool, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo, &collaborator); err != nil {
+ return false, nil, err
+ }
status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator), nil, nil)
if err != nil {
return false, resp, err
// AddCollaborator add some user as a collaborator of a repository
func (c *Client) AddCollaborator(user, repo, collaborator string, opt AddCollaboratorOption) (*Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo, &collaborator); err != nil {
+ return nil, err
+ }
if err := opt.Validate(); err != nil {
return nil, err
}
// DeleteCollaborator remove a collaborator from a repository
func (c *Client) DeleteCollaborator(user, repo, collaborator string) (*Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo, &collaborator); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE",
fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator), nil, nil)
return resp, err
// Commit contains information generated from a Git commit.
type Commit struct {
*CommitMeta
- HTMLURL string `json:"html_url"`
- RepoCommit *RepoCommit `json:"commit"`
- Author *User `json:"author"`
- Committer *User `json:"committer"`
- Parents []*CommitMeta `json:"parents"`
+ HTMLURL string `json:"html_url"`
+ RepoCommit *RepoCommit `json:"commit"`
+ Author *User `json:"author"`
+ Committer *User `json:"committer"`
+ Parents []*CommitMeta `json:"parents"`
+ Files []*CommitAffectedFiles `json:"files"`
}
// CommitDateOptions store dates for GIT_AUTHOR_DATE and GIT_COMMITTER_DATE
Committer time.Time `json:"committer"`
}
+// CommitAffectedFiles store information about files affected by the commit
+type CommitAffectedFiles struct {
+ Filename string `json:"filename"`
+}
+
// GetSingleCommit returns a single commit
func (c *Client) GetSingleCommit(user, repo, commitID string) (*Commit, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo, &commitID); err != nil {
+ return nil, nil, err
+ }
commit := new(Commit)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/commits/%s", user, repo, commitID), nil, nil, &commit)
return commit, resp, err
// ListRepoCommits return list of commits from a repo
func (c *Client) ListRepoCommits(user, repo string, opt ListCommitOptions) ([]*Commit, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/commits", user, repo))
opt.setDefaults()
commits := make([]*Commit, 0, opt.PageSize)
"bytes"
"encoding/json"
"fmt"
+ "net/url"
+ "strings"
)
// FileOptions options for all file APIs
Author Identity `json:"author"`
Committer Identity `json:"committer"`
Dates CommitDateOptions `json:"dates"`
+ // Add a Signed-off-by trailer by the committer at the end of the commit log message.
+ Signoff bool `json:"signoff"`
}
// CreateFileOptions options for creating files
}
// GetFile downloads a file of repository, ref can be branch/tag/commit.
-// e.g.: ref -> master, tree -> macaron.go(no leading slash)
-func (c *Client) GetFile(user, repo, ref, tree string) ([]byte, *Response, error) {
- return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/raw/%s/%s", user, repo, ref, tree), nil, nil)
+// e.g.: ref -> master, filepath -> README.md (no leading slash)
+func (c *Client) GetFile(owner, repo, ref, filepath string) ([]byte, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
+ filepath = pathEscapeSegments(filepath)
+ if c.checkServerVersionGreaterThanOrEqual(version1_14_0) != nil {
+ ref = pathEscapeSegments(ref)
+ return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/raw/%s/%s", owner, repo, ref, filepath), nil, nil)
+ }
+ return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/raw/%s?ref=%s", owner, repo, filepath, url.QueryEscape(ref)), nil, nil)
}
-// GetContents get the metadata and contents (if a file) of an entry in a repository, or a list of entries if a dir
+// GetContents get the metadata and contents of a file in a repository
// ref is optional
func (c *Client) GetContents(owner, repo, ref, filepath string) (*ContentsResponse, *Response, error) {
+ data, resp, err := c.getDirOrFileContents(owner, repo, ref, filepath)
+ if err != nil {
+ return nil, resp, err
+ }
cr := new(ContentsResponse)
- resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/contents/%s?ref=%s", owner, repo, filepath, ref), jsonHeader, nil, cr)
+ if json.Unmarshal(data, &cr) != nil {
+ return nil, resp, fmt.Errorf("expect file, got directory")
+ }
return cr, resp, err
}
+// ListContents gets a list of entries in a dir
+// ref is optional
+func (c *Client) ListContents(owner, repo, ref, filepath string) ([]*ContentsResponse, *Response, error) {
+ data, resp, err := c.getDirOrFileContents(owner, repo, ref, filepath)
+ if err != nil {
+ return nil, resp, err
+ }
+ crl := make([]*ContentsResponse, 0)
+ if json.Unmarshal(data, &crl) != nil {
+ return nil, resp, fmt.Errorf("expect directory, got file")
+ }
+ return crl, resp, err
+}
+
+func (c *Client) getDirOrFileContents(owner, repo, ref, filepath string) ([]byte, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
+ filepath = pathEscapeSegments(strings.TrimPrefix(filepath, "/"))
+ return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/contents/%s?ref=%s", owner, repo, filepath, url.QueryEscape(ref)), jsonHeader, nil)
+}
+
// CreateFile create a file in a repository
func (c *Client) CreateFile(owner, repo, filepath string, opt CreateFileOptions) (*FileResponse, *Response, error) {
var err error
if opt.BranchName, err = c.setDefaultBranchForOldVersions(owner, repo, opt.BranchName); err != nil {
return nil, nil, err
}
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
+ filepath = pathEscapeSegments(filepath)
body, err := json.Marshal(&opt)
if err != nil {
return nil, nil, err
}
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
+ filepath = pathEscapeSegments(filepath)
+
body, err := json.Marshal(&opt)
if err != nil {
return nil, nil, err
if opt.BranchName, err = c.setDefaultBranchForOldVersions(owner, repo, opt.BranchName); err != nil {
return nil, err
}
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
+ filepath = pathEscapeSegments(filepath)
body, err := json.Marshal(&opt)
if err != nil {
// ListDeployKeys list all the deploy keys of one repository
func (c *Client) ListDeployKeys(user, repo string, opt ListDeployKeysOptions) ([]*DeployKey, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/keys", user, repo))
opt.setDefaults()
link.RawQuery = opt.QueryEncode()
// GetDeployKey get one deploy key with key id
func (c *Client) GetDeployKey(user, repo string, keyID int64) (*DeployKey, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
key := new(DeployKey)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/keys/%d", user, repo, keyID), nil, nil, &key)
return key, resp, err
// CreateDeployKey options when create one deploy key
func (c *Client) CreateDeployKey(user, repo string, opt CreateKeyOption) (*DeployKey, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
body, err := json.Marshal(&opt)
if err != nil {
return nil, nil, err
// DeleteDeployKey delete deploy key with key id
func (c *Client) DeleteDeployKey(owner, repo string, keyID int64) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/keys/%d", owner, repo, keyID), nil, nil)
return resp, err
}
GitServiceGitlab GitServiceType = "gitlab"
// GitServiceGitea represents a gitea service
GitServiceGitea GitServiceType = "gitea"
-
- // Not supported jet
- // // GitServiceGogs represents a gogs service
- // GitServiceGogs GitServiceType = "gogs"
+ // GitServiceGogs represents a gogs service
+ GitServiceGogs GitServiceType = "gogs"
)
// MigrateRepoOption options for migrating a repository from an external service
RepoName string `json:"repo_name"`
RepoOwner string `json:"repo_owner"`
// deprecated use RepoOwner
- RepoOwnerID int64 `json:"uid"`
- CloneAddr string `json:"clone_addr"`
- Service GitServiceType `json:"service"`
- AuthUsername string `json:"auth_username"`
- AuthPassword string `json:"auth_password"`
- AuthToken string `json:"auth_token"`
- Mirror bool `json:"mirror"`
- Private bool `json:"private"`
- Description string `json:"description"`
- Wiki bool `json:"wiki"`
- Milestones bool `json:"milestones"`
- Labels bool `json:"labels"`
- Issues bool `json:"issues"`
- PullRequests bool `json:"pull_requests"`
- Releases bool `json:"releases"`
+ RepoOwnerID int64 `json:"uid"`
+ CloneAddr string `json:"clone_addr"`
+ Service GitServiceType `json:"service"`
+ AuthUsername string `json:"auth_username"`
+ AuthPassword string `json:"auth_password"`
+ AuthToken string `json:"auth_token"`
+ Mirror bool `json:"mirror"`
+ Private bool `json:"private"`
+ Description string `json:"description"`
+ Wiki bool `json:"wiki"`
+ Milestones bool `json:"milestones"`
+ Labels bool `json:"labels"`
+ Issues bool `json:"issues"`
+ PullRequests bool `json:"pull_requests"`
+ Releases bool `json:"releases"`
+ MirrorInterval string `json:"mirror_interval"`
}
// Validate the MigrateRepoOption struct
switch opt.Service {
case GitServiceGithub:
if len(opt.AuthToken) == 0 {
- return fmt.Errorf("github require token authentication")
+ return fmt.Errorf("github requires token authentication")
}
case GitServiceGitlab, GitServiceGitea:
if len(opt.AuthToken) == 0 {
- return fmt.Errorf("%s require token authentication", opt.Service)
+ return fmt.Errorf("%s requires token authentication", opt.Service)
}
// Gitlab is supported since 1.12.0 but api cant handle it until 1.13.0
// https://github.com/go-gitea/gitea/pull/12672
if c.checkServerVersionGreaterThanOrEqual(version1_13_0) != nil {
return fmt.Errorf("migrate from service %s need gitea >= 1.13.0", opt.Service)
}
+ case GitServiceGogs:
+ if len(opt.AuthToken) == 0 {
+ return fmt.Errorf("gogs requires token authentication")
+ }
+ if c.checkServerVersionGreaterThanOrEqual(version1_14_0) != nil {
+ return fmt.Errorf("migrate from service gogs need gitea >= 1.14.0")
+ }
}
return nil
}
// GetRepoRef get one ref's information of one repository
func (c *Client) GetRepoRef(user, repo, ref string) (*Reference, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
ref = strings.TrimPrefix(ref, "refs/")
+ ref = pathEscapeSegments(ref)
r := new(Reference)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/refs/%s", user, repo, ref), nil, nil, &r)
if _, ok := err.(*json.UnmarshalTypeError); ok {
// GetRepoRefs get list of ref's information of one repository
func (c *Client) GetRepoRefs(user, repo, ref string) ([]*Reference, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
ref = strings.TrimPrefix(ref, "refs/")
+ ref = pathEscapeSegments(ref)
+
data, resp, err := c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/git/refs/%s", user, repo, ref), nil, nil)
if err != nil {
return nil, resp, err
--- /dev/null
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+ "fmt"
+ "net/http"
+)
+
+// ListStargazersOptions options for listing a repository's stargazers
+type ListStargazersOptions struct {
+ ListOptions
+}
+
+// ListRepoStargazers list a repository's stargazers
+func (c *Client) ListRepoStargazers(user, repo string, opt ListStargazersOptions) ([]*User, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
+ opt.setDefaults()
+ stargazers := make([]*User, 0, opt.PageSize)
+ resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/stargazers?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &stargazers)
+ return stargazers, resp, err
+}
+
+// GetStarredRepos returns the repos that the given user has starred
+func (c *Client) GetStarredRepos(user string) ([]*Repository, *Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, nil, err
+ }
+ repos := make([]*Repository, 0, 10)
+ resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/starred", user), jsonHeader, nil, &repos)
+ return repos, resp, err
+}
+
+// GetMyStarredRepos returns the repos that the authenticated user has starred
+func (c *Client) GetMyStarredRepos() ([]*Repository, *Response, error) {
+ repos := make([]*Repository, 0, 10)
+ resp, err := c.getParsedResponse("GET", "/user/starred", jsonHeader, nil, &repos)
+ return repos, resp, err
+}
+
+// IsRepoStarring returns whether the authenticated user has starred the repo or not
+func (c *Client) IsRepoStarring(user, repo string) (bool, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return false, nil, err
+ }
+ _, resp, err := c.getResponse("GET", fmt.Sprintf("/user/starred/%s/%s", user, repo), jsonHeader, nil)
+ if resp != nil {
+ switch resp.StatusCode {
+ case http.StatusNotFound:
+ return false, resp, nil
+ case http.StatusNoContent:
+ return true, resp, nil
+ default:
+ return false, resp, fmt.Errorf("unexpected status code '%d'", resp.StatusCode)
+ }
+ }
+ return false, nil, err
+}
+
+// StarRepo star specified repo as the authenticated user
+func (c *Client) StarRepo(user, repo string) (*Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, err
+ }
+ _, resp, err := c.getResponse("PUT", fmt.Sprintf("/user/starred/%s/%s", user, repo), jsonHeader, nil)
+ if resp != nil {
+ switch resp.StatusCode {
+ case http.StatusNoContent:
+ return resp, nil
+ default:
+ return resp, fmt.Errorf("unexpected status code '%d'", resp.StatusCode)
+ }
+ }
+ return nil, err
+}
+
+// UnStarRepo remove star to specified repo as the authenticated user
+func (c *Client) UnStarRepo(user, repo string) (*Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, err
+ }
+ _, resp, err := c.getResponse("DELETE", fmt.Sprintf("/user/starred/%s/%s", user, repo), jsonHeader, nil)
+ if resp != nil {
+ switch resp.StatusCode {
+ case http.StatusNoContent:
+ return resp, nil
+ default:
+ return resp, fmt.Errorf("unexpected status code '%d'", resp.StatusCode)
+ }
+ }
+ return nil, err
+}
// ListRepoTags list all the branches of one repository
func (c *Client) ListRepoTags(user, repo string, opt ListRepoTagsOptions) ([]*Tag, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
tags := make([]*Tag, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/tags?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &tags)
return tags, resp, err
}
+
+// DeleteTag deletes a tag from a repository, if no release refers to it
+func (c *Client) DeleteTag(user, repo string, tag string) (*Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo, &tag); err != nil {
+ return nil, err
+ }
+ if err := c.checkServerVersionGreaterThanOrEqual(version1_14_0); err != nil {
+ return nil, err
+ }
+ _, resp, err := c.getResponse("DELETE",
+ fmt.Sprintf("/repos/%s/%s/tags/%s", user, repo, tag),
+ nil, nil)
+ return resp, err
+}
// ListRepoTopics list all repository's topics
func (c *Client) ListRepoTopics(user, repo string, opt ListRepoTopicsOptions) ([]string, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
list := new(topicsList)
// SetRepoTopics replaces the list of repo's topics
func (c *Client) SetRepoTopics(user, repo string, list []string) (*Response, error) {
-
+ if err := escapeValidatePathSegments(&user, &repo); err != nil {
+ return nil, err
+ }
l := topicsList{Topics: list}
-
body, err := json.Marshal(&l)
if err != nil {
return nil, err
// AddRepoTopic adds a topic to a repo's topics list
func (c *Client) AddRepoTopic(user, repo, topic string) (*Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo, &topic); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("PUT", fmt.Sprintf("/repos/%s/%s/topics/%s", user, repo, topic), nil, nil)
return resp, err
}
// DeleteRepoTopic deletes a topic from repo's topics list
func (c *Client) DeleteRepoTopic(user, repo, topic string) (*Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo, &topic); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/topics/%s", user, repo, topic), nil, nil)
return resp, err
}
// TransferRepo transfers the ownership of a repository
func (c *Client) TransferRepo(owner, reponame string, opt TransferRepoOption) (*Repository, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &reponame); err != nil {
+ return nil, nil, err
+ }
if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
return nil, nil, err
}
// GetTrees downloads a file of repository, ref can be branch/tag/commit.
// e.g.: ref -> master, tree -> macaron.go(no leading slash)
func (c *Client) GetTrees(user, repo, ref string, recursive bool) (*GitTreeResponse, *Response, error) {
+ if err := escapeValidatePathSegments(&user, &repo, &ref); err != nil {
+ return nil, nil, err
+ }
trees := new(GitTreeResponse)
var path = fmt.Sprintf("/repos/%s/%s/git/trees/%s", user, repo, ref)
if recursive {
// GetWatchedRepos list all the watched repos of user
func (c *Client) GetWatchedRepos(user string) ([]*Repository, *Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, nil, err
+ }
repos := make([]*Repository, 0, 10)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/subscriptions", user), nil, nil, &repos)
return repos, resp, err
}
// CheckRepoWatch check if the current user is watching a repo
-func (c *Client) CheckRepoWatch(repoUser, repoName string) (bool, *Response, error) {
- status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/subscription", repoUser, repoName), nil, nil)
+func (c *Client) CheckRepoWatch(owner, repo string) (bool, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return false, nil, err
+ }
+ status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/subscription", owner, repo), nil, nil)
if err != nil {
return false, resp, err
}
}
// WatchRepo start to watch a repository
-func (c *Client) WatchRepo(repoUser, repoName string) (*Response, error) {
- status, resp, err := c.getStatusCode("PUT", fmt.Sprintf("/repos/%s/%s/subscription", repoUser, repoName), nil, nil)
+func (c *Client) WatchRepo(owner, repo string) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
+ status, resp, err := c.getStatusCode("PUT", fmt.Sprintf("/repos/%s/%s/subscription", owner, repo), nil, nil)
if err != nil {
return resp, err
}
}
// UnWatchRepo stop to watch a repository
-func (c *Client) UnWatchRepo(repoUser, repoName string) (*Response, error) {
- status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/subscription", repoUser, repoName), nil, nil)
+func (c *Client) UnWatchRepo(owner, repo string) (*Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, err
+ }
+ status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/subscription", owner, repo), nil, nil)
if err != nil {
return resp, err
}
// GlobalUISettings represent the global ui settings of a gitea instance witch is exposed by API
type GlobalUISettings struct {
+ DefaultTheme string `json:"default_theme"`
AllowedReactions []string `json:"allowed_reactions"`
}
// GlobalRepoSettings represent the global repository settings of a gitea instance witch is exposed by API
type GlobalRepoSettings struct {
- MirrorsDisabled bool `json:"mirrors_disabled"`
- HTTPGitDisabled bool `json:"http_git_disabled"`
+ MirrorsDisabled bool `json:"mirrors_disabled"`
+ HTTPGitDisabled bool `json:"http_git_disabled"`
+ MigrationsDisabled bool `json:"migrations_disabled"`
}
// GlobalAPISettings contains global api settings exposed by it
"bytes"
"encoding/json"
"fmt"
+ "net/url"
"time"
)
// CreateStatus creates a new Status for a given Commit
func (c *Client) CreateStatus(owner, repo, sha string, opts CreateStatusOption) (*Status, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+ return nil, nil, err
+ }
body, err := json.Marshal(&opts)
if err != nil {
return nil, nil, err
}
status := new(Status)
- resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/statuses/%s", owner, repo, sha), jsonHeader, bytes.NewReader(body), status)
+ resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/statuses/%s", owner, repo, url.QueryEscape(sha)), jsonHeader, bytes.NewReader(body), status)
return status, resp, err
}
ListOptions
}
-// ListStatuses returns all statuses for a given Commit
-func (c *Client) ListStatuses(owner, repo, sha string, opt ListStatusesOption) ([]*Status, *Response, error) {
+// ListStatuses returns all statuses for a given Commit by ref
+func (c *Client) ListStatuses(owner, repo, ref string, opt ListStatusesOption) ([]*Status, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo, &ref); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
statuses := make([]*Status, 0, opt.PageSize)
- resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/commits/%s/statuses?%s", owner, repo, sha, opt.getURLQuery().Encode()), nil, nil, &statuses)
+ resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/commits/%s/statuses?%s", owner, repo, ref, opt.getURLQuery().Encode()), jsonHeader, nil, &statuses)
return statuses, resp, err
}
}
// GetCombinedStatus returns the CombinedStatus for a given Commit
-func (c *Client) GetCombinedStatus(owner, repo, sha string) (*CombinedStatus, *Response, error) {
+func (c *Client) GetCombinedStatus(owner, repo, ref string) (*CombinedStatus, *Response, error) {
+ if err := escapeValidatePathSegments(&owner, &repo, &ref); err != nil {
+ return nil, nil, err
+ }
status := new(CombinedStatus)
- resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/commits/%s/status", owner, repo, sha), nil, nil, status)
+ resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/commits/%s/status", owner, repo, ref), jsonHeader, nil, status)
+
+ // gitea api return empty body if nothing here jet
+ if resp != nil && resp.StatusCode == 200 && err != nil {
+ return status, resp, nil
+ }
+
return status, resp, err
}
// GetUserInfo get user info by user's name
func (c *Client) GetUserInfo(user string) (*User, *Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, nil, err
+ }
u := new(User)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s", user), nil, nil, u)
return u, resp, err
"bytes"
"encoding/json"
"fmt"
+ "net/url"
"reflect"
)
// ListAccessTokens lists all the access tokens of user
func (c *Client) ListAccessTokens(opts ListAccessTokensOptions) ([]*AccessToken, *Response, error) {
- if len(c.username) == 0 {
+ c.mutex.RLock()
+ username := c.username
+ c.mutex.RUnlock()
+ if len(username) == 0 {
return nil, nil, fmt.Errorf("\"username\" not set: only BasicAuth allowed")
}
opts.setDefaults()
tokens := make([]*AccessToken, 0, opts.PageSize)
- resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/tokens?%s", c.username, opts.getURLQuery().Encode()), jsonHeader, nil, &tokens)
+ resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/tokens?%s", url.PathEscape(username), opts.getURLQuery().Encode()), jsonHeader, nil, &tokens)
return tokens, resp, err
}
// CreateAccessToken create one access token with options
func (c *Client) CreateAccessToken(opt CreateAccessTokenOption) (*AccessToken, *Response, error) {
- if len(c.username) == 0 {
+ c.mutex.RLock()
+ username := c.username
+ c.mutex.RUnlock()
+ if len(username) == 0 {
return nil, nil, fmt.Errorf("\"username\" not set: only BasicAuth allowed")
}
body, err := json.Marshal(&opt)
return nil, nil, err
}
t := new(AccessToken)
- resp, err := c.getParsedResponse("POST", fmt.Sprintf("/users/%s/tokens", c.username), jsonHeader, bytes.NewReader(body), t)
+ resp, err := c.getParsedResponse("POST", fmt.Sprintf("/users/%s/tokens", url.PathEscape(username)), jsonHeader, bytes.NewReader(body), t)
return t, resp, err
}
// DeleteAccessToken delete token, identified by ID and if not available by name
func (c *Client) DeleteAccessToken(value interface{}) (*Response, error) {
- if len(c.username) == 0 {
+ c.mutex.RLock()
+ username := c.username
+ c.mutex.RUnlock()
+ if len(username) == 0 {
return nil, fmt.Errorf("\"username\" not set: only BasicAuth allowed")
}
return nil, fmt.Errorf("only string and int64 supported")
}
- _, resp, err := c.getResponse("DELETE", fmt.Sprintf("/users/%s/tokens/%s", c.username, token), jsonHeader, nil)
+ _, resp, err := c.getResponse("DELETE", fmt.Sprintf("/users/%s/tokens/%s", url.PathEscape(username), url.PathEscape(token)), jsonHeader, nil)
return resp, err
}
// ListFollowers list all the followers of one user
func (c *Client) ListFollowers(user string, opt ListFollowersOptions) ([]*User, *Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
users := make([]*User, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/followers?%s", user, opt.getURLQuery().Encode()), nil, nil, &users)
// ListFollowing list all the users the user followed
func (c *Client) ListFollowing(user string, opt ListFollowingOptions) ([]*User, *Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
users := make([]*User, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/following?%s", user, opt.getURLQuery().Encode()), nil, nil, &users)
// IsFollowing if current user followed the target
func (c *Client) IsFollowing(target string) (bool, *Response) {
+ if err := escapeValidatePathSegments(&target); err != nil {
+ // ToDo return err
+ return false, nil
+ }
_, resp, err := c.getResponse("GET", fmt.Sprintf("/user/following/%s", target), nil, nil)
return err == nil, resp
}
// IsUserFollowing if the user followed the target
func (c *Client) IsUserFollowing(user, target string) (bool, *Response) {
+ if err := escapeValidatePathSegments(&user, &target); err != nil {
+ // ToDo return err
+ return false, nil
+ }
_, resp, err := c.getResponse("GET", fmt.Sprintf("/users/%s/following/%s", user, target), nil, nil)
return err == nil, resp
}
// Follow set current user follow the target
func (c *Client) Follow(target string) (*Response, error) {
+ if err := escapeValidatePathSegments(&target); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("PUT", fmt.Sprintf("/user/following/%s", target), nil, nil)
return resp, err
}
// Unfollow set current user unfollow the target
func (c *Client) Unfollow(target string) (*Response, error) {
+ if err := escapeValidatePathSegments(&target); err != nil {
+ return nil, err
+ }
_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/user/following/%s", target), nil, nil)
return resp, err
}
// ListGPGKeys list all the GPG keys of the user
func (c *Client) ListGPGKeys(user string, opt ListGPGKeysOptions) ([]*GPGKey, *Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
keys := make([]*GPGKey, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/gpg_keys?%s", user, opt.getURLQuery().Encode()), nil, nil, &keys)
// ListPublicKeys list all the public keys of the user
func (c *Client) ListPublicKeys(user string, opt ListPublicKeysOptions) ([]*PublicKey, *Response, error) {
+ if err := escapeValidatePathSegments(&user); err != nil {
+ return nil, nil, err
+ }
opt.setDefaults()
keys := make([]*PublicKey, 0, opt.PageSize)
resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/keys?%s", user, opt.getURLQuery().Encode()), nil, nil, &keys)
// CheckServerVersionConstraint validates that the login's server satisfies a
// given version constraint such as ">= 1.11.0+dev"
func (c *Client) CheckServerVersionConstraint(constraint string) error {
- c.versionLock.RLock()
- if c.serverVersion == nil {
- c.versionLock.RUnlock()
- if err := c.loadClientServerVersion(); err != nil {
- return err
- }
- } else {
- c.versionLock.RUnlock()
+ if err := c.loadServerVersion(); err != nil {
+ return err
}
check, err := version.NewConstraint(constraint)
return err
}
if !check.Check(c.serverVersion) {
- return fmt.Errorf("gitea server at %s does not satisfy version constraint %s", c.url, constraint)
+ c.mutex.RLock()
+ url := c.url
+ c.mutex.RUnlock()
+ return fmt.Errorf("gitea server at %s does not satisfy version constraint %s", url, constraint)
}
return nil
}
// predefined versions only have to be parsed by library once
var (
- version1_10_0, _ = version.NewVersion("1.10.0")
version1_11_0, _ = version.NewVersion("1.11.0")
version1_12_0, _ = version.NewVersion("1.12.0")
version1_13_0, _ = version.NewVersion("1.13.0")
+ version1_14_0, _ = version.NewVersion("1.14.0")
)
// checkServerVersionGreaterThanOrEqual is internally used to speed up things and ignore issues with prerelease
func (c *Client) checkServerVersionGreaterThanOrEqual(v *version.Version) error {
- c.versionLock.RLock()
- if c.serverVersion == nil {
- c.versionLock.RUnlock()
- if err := c.loadClientServerVersion(); err != nil {
- return err
- }
- } else {
- c.versionLock.RUnlock()
+ if err := c.loadServerVersion(); err != nil {
+ return err
}
if !c.serverVersion.GreaterThanOrEqual(v) {
- return fmt.Errorf("gitea server at %s is older than %s", c.url, v.Original())
+ c.mutex.RLock()
+ url := c.url
+ c.mutex.RUnlock()
+ return fmt.Errorf("gitea server at %s is older than %s", url, v.Original())
}
return nil
}
-// loadClientServerVersion init the serverVersion variable
-func (c *Client) loadClientServerVersion() error {
- c.versionLock.Lock()
- defer c.versionLock.Unlock()
-
- raw, _, err := c.ServerVersion()
- if err != nil {
- return err
- }
- if c.serverVersion, err = version.NewVersion(raw); err != nil {
- return err
- }
- return nil
+// loadServerVersion init the serverVersion variable
+func (c *Client) loadServerVersion() (err error) {
+ c.getVersionOnce.Do(func() {
+ raw, _, err2 := c.ServerVersion()
+ if err2 != nil {
+ err = err2
+ return
+ }
+ if c.serverVersion, err = version.NewVersion(raw); err != nil {
+ return
+ }
+ })
+ return
}
## explicit
code.gitea.io/gitea-vet
code.gitea.io/gitea-vet/checks
-# code.gitea.io/sdk/gitea v0.13.2
+# code.gitea.io/sdk/gitea v0.14.0
## explicit
code.gitea.io/sdk/gitea
# gitea.com/go-chi/binding v0.0.0-20210301195521-1fe1c9a555e7
projects / gitea.git / commitdiff