127 lines
3.4 KiB
Go
127 lines
3.4 KiB
Go
// Client to Gitea API
|
|
package gitea
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"path"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"sirherobrine23.com.br/go-bds/request/v2"
|
|
)
|
|
|
|
var (
|
|
ErrToken error = errors.New("require Token to request")
|
|
ErrBackend error = errors.New("catch 500 error in server api")
|
|
ErrNoExist error = errors.New("repository, organization or endpoint dont exists")
|
|
|
|
processCodes = request.MapCode{
|
|
500: errRes5xx("500 error"),
|
|
501: errRes5xx("501 error"),
|
|
401: func(res *http.Response) (*http.Response, error) {
|
|
if res.Body != nil {
|
|
res.Body.Close()
|
|
}
|
|
return nil, ErrToken
|
|
},
|
|
403: func(res *http.Response) (*http.Response, error) {
|
|
if res.Body != nil {
|
|
res.Body.Close()
|
|
}
|
|
return nil, errors.New("cannot process request, authorization or not have permission")
|
|
},
|
|
429: func(res *http.Response) (*http.Response, error) {
|
|
if res.Body != nil {
|
|
res.Body.Close()
|
|
}
|
|
// x-ratelimit-reset
|
|
if window, err := strconv.Atoi(res.Header.Get("x-ratelimit-reset")); err == nil {
|
|
<-time.After(time.Duration(window))
|
|
} else {
|
|
<-time.After(time.Second)
|
|
}
|
|
return request.ReRequest(res)
|
|
},
|
|
}
|
|
)
|
|
|
|
type giteaError struct {
|
|
Errors []string `json:"errors"`
|
|
TeaError string `json:"error"`
|
|
Message string `json:"message"`
|
|
Url string `json:"url"`
|
|
}
|
|
|
|
func errRes5xx(txt string) func(res *http.Response) (*http.Response, error) {
|
|
return func(res *http.Response) (*http.Response, error) {
|
|
if strings.Contains(res.Header.Get("Content-Type"), "application/json") {
|
|
var data giteaError
|
|
defer res.Body.Close()
|
|
bodyBuff, err := io.ReadAll(res.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf(txt, ErrBackend, err)
|
|
}
|
|
|
|
if err := json.Unmarshal(bodyBuff, &data); err != nil {
|
|
return nil, fmt.Errorf(txt, ErrBackend, ErrNoExist)
|
|
} else if len(data.Errors) > 0 {
|
|
return nil, fmt.Errorf(txt, ErrBackend, fmt.Errorf("gitea api, errors: %s, %s", data.Message, strings.Join(data.Errors, ", ")))
|
|
} else if data.Message != "" {
|
|
return nil, fmt.Errorf(txt, ErrBackend, fmt.Errorf("backed error: %s", data.Message))
|
|
}
|
|
}
|
|
return nil, fmt.Errorf(txt, ErrBackend)
|
|
}
|
|
}
|
|
|
|
// Make new gitea client to Make API requests, host example: "https://gitea.com/api"
|
|
func NewClient(giteaHost, Owner, Repository, Token string) (*Gitea, error) {
|
|
apiUrl, err := url.Parse(giteaHost)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
client := &Gitea{
|
|
Host: apiUrl,
|
|
Username: Owner,
|
|
Repository: Repository,
|
|
Token: Token,
|
|
}
|
|
|
|
// Check if API is OK
|
|
reqOptions := &request.Options{Method: "GET", Header: request.Header{}, CodeProcess: processCodes}
|
|
client.authHeader(&reqOptions.Header)
|
|
res, err := request.MakeRequestWithStatus(apiUrl.ResolveReference(&url.URL{Path: path.Join(apiUrl.Path, "v1/version")}), reqOptions)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("cannot get gitea version: %s", err)
|
|
}
|
|
res.Body.Close()
|
|
|
|
return client, nil
|
|
}
|
|
|
|
// Gitea client
|
|
type Gitea struct {
|
|
Host *url.URL // Gitea api host
|
|
Username, Repository string // Repository and owner names
|
|
Token string // Gitea token
|
|
}
|
|
|
|
// Return escapated Owner+/+Repository
|
|
func (client Gitea) repoPath() string {
|
|
return fmt.Sprintf("%s/%s", url.PathEscape(client.Username), url.PathEscape(client.Repository))
|
|
}
|
|
|
|
// Set token to header
|
|
func (client Gitea) authHeader(header *request.Header) {
|
|
if client.Token != "" {
|
|
(*header)["Authorization"] = fmt.Sprintf("token %s", client.Token)
|
|
}
|
|
}
|