request/gitea/gitea.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/gitea/structs"
	"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 = structs.APIError

// Gitea client
type Gitea struct {
	Host                 *url.URL                    // Gitea api host
	Username, Repository string                      // Repository and owner names
	Token                string                      // Gitea token
	Settings             *structs.GeneralAPISettings // API settings
}

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 data.Message != "" {
				return nil, fmt.Errorf(txt, ErrBackend, fmt.Errorf("backed error: %s", data.Message))
			}
		}
		return nil, fmt.Errorf(txt, ErrBackend)
	}
}

// Return escapated Owner+/+Repository
func (client Gitea) repoPath() string {
	return fmt.Sprintf("%s/%s", url.PathEscape(client.Username), url.PathEscape(client.Repository))
}

func (client Gitea) pathJoin(nodes ...string) *url.URL {
	return client.Host.ResolveReference(&url.URL{Path: path.Join(client.Host.Path, path.Join(nodes...))})
}

// Set token to header
func (client Gitea) authHeader(header *request.Header) {
	if client.Token != "" {
		(*header)["Authorization"] = fmt.Sprintf("token %s", client.Token)
	}
}

// Make new gitea client api rest from env info
func DefaultClient() (*Gitea, error) {
	Owner, Repository := EnvRepository()
	return NewClient(EnvApiHost(), Owner, Repository, EnvToken())
}

// 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,
	}

	appendApi := true
retry: // to attemp with api path append

	// Check if API is OK
	reqOptions := &request.Options{Method: "GET", Header: request.Header{}, CodeProcess: processCodes}
	client.authHeader(&reqOptions.Header)
	res, err := request.MakeRequest(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)
	} else if res.StatusCode != 200 {
		if appendApi {
			appendApi = false
			apiUrl.Path = path.Join(apiUrl.Path, "api")
			goto retry
		}
		return nil, ErrNoExist
	}
	res.Body.Close()

	client.Settings = new(structs.GeneralAPISettings)
	if _, err = request.MakeDoJSON(client.pathJoin("v1/settings/api"), client.Settings, reqOptions); err != nil {
		client.Settings = nil // ignore api info
	}

	return client, nil
}