Files
sdk/api_git.go

6197 lines
218 KiB
Go

/*
Hanzo Cloud API
The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
API version: v1
*/
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
package hanzoai
import (
"bytes"
"context"
"io"
"net/http"
"net/url"
"os"
"strings"
)
// GitAPIService GitAPI service
type GitAPIService service
type GitAPIDeleteGitReposByNameRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
}
func (r GitAPIDeleteGitReposByNameRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteGitReposByNameExecute(r)
}
/*
DeleteGitReposByName Removes a repo's metadata and purges its storage.
Removes a repo's metadata and purges its storage. Answers 204 with
no body. The metadata row is the source of truth for existence, so a storage
purge that fails is logged and the delete still succeeds — and a second call
is a 404, not a second delete. A repository this app does not hold is looked
for where getRepo looks next, the org's made workspace on the forge, so a
customer's own repository (or the copy a GitHub link made there) is one a
delete can reach, as their list already shows it.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo's org-unique handle, from the :name path segment. A trailing \".git\" is stripped.
@return GitAPIDeleteGitReposByNameRequest
*/
func (a *GitAPIService) DeleteGitReposByName(ctx context.Context, name string) GitAPIDeleteGitReposByNameRequest {
return GitAPIDeleteGitReposByNameRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
func (a *GitAPIService) DeleteGitReposByNameExecute(r GitAPIDeleteGitReposByNameRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.DeleteGitReposByName")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type GitAPIDeleteGitReposByNameSubscriptionsByIdRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
id string
}
func (r GitAPIDeleteGitReposByNameSubscriptionsByIdRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteGitReposByNameSubscriptionsByIdExecute(r)
}
/*
DeleteGitReposByNameSubscriptionsById Removes one Slack subscription from a repo; the notifier stops posting that repo's events to that channel.
Removes one Slack subscription from a repo; the notifier stops
posting that repo's events to that channel. Answers 204 with no body. An id
that is not this repo's subscription is not found.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo, from the :name path segment.
@param id ID is the row to remove, from the :id path segment.
@return GitAPIDeleteGitReposByNameSubscriptionsByIdRequest
*/
func (a *GitAPIService) DeleteGitReposByNameSubscriptionsById(ctx context.Context, name string, id string) GitAPIDeleteGitReposByNameSubscriptionsByIdRequest {
return GitAPIDeleteGitReposByNameSubscriptionsByIdRequest{
ApiService: a,
ctx: ctx,
name: name,
id: id,
}
}
// Execute executes the request
func (a *GitAPIService) DeleteGitReposByNameSubscriptionsByIdExecute(r GitAPIDeleteGitReposByNameSubscriptionsByIdRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.DeleteGitReposByNameSubscriptionsById")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/subscriptions/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type GitAPIDeleteGitReposByNameTargetsByIdRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
id string
}
func (r GitAPIDeleteGitReposByNameTargetsByIdRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteGitReposByNameTargetsByIdExecute(r)
}
/*
DeleteGitReposByNameTargetsById Removes one outbound mirror target; later pushes stop being forwarded to it.
Removes one outbound mirror target; later pushes stop being
forwarded to it. Answers 204 with no body. Nothing is done to the downstream
remote itself — only this repo's intent to push there is dropped.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo, from the :name path segment.
@param id ID is the row to remove, from the :id path segment.
@return GitAPIDeleteGitReposByNameTargetsByIdRequest
*/
func (a *GitAPIService) DeleteGitReposByNameTargetsById(ctx context.Context, name string, id string) GitAPIDeleteGitReposByNameTargetsByIdRequest {
return GitAPIDeleteGitReposByNameTargetsByIdRequest{
ApiService: a,
ctx: ctx,
name: name,
id: id,
}
}
// Execute executes the request
func (a *GitAPIService) DeleteGitReposByNameTargetsByIdExecute(r GitAPIDeleteGitReposByNameTargetsByIdRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.DeleteGitReposByNameTargetsById")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/targets/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type GitAPIGetGitRequest struct {
ctx context.Context
ApiService *GitAPIService
}
func (r GitAPIGetGitRequest) Execute() (*http.Response, error) {
return r.ApiService.GetGitExecute(r)
}
/*
GetGit Browse your org's repositories
The repository list for the signed-in caller's org — each repo with its description, default branch, size and last update. SIGNED OUT it renders the public explore page instead of refusing, because most Hanzo repos are open source and the open face is the default one; signed in, the caller's own org shows its private repositories alongside its public ones. This is a server-rendered browser page, not JSON — the console repo-browser reads the same repository through the JSON ops under /v1/git/repos. Repository names, paths and file contents all render through auto-escaping templates rather than being concatenated into HTML.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIGetGitRequest
*/
func (a *GitAPIService) GetGit(ctx context.Context) GitAPIGetGitRequest {
return GitAPIGetGitRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *GitAPIService) GetGitExecute(r GitAPIGetGitRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGit")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type GitAPIGetGitActivityRequest struct {
ctx context.Context
ApiService *GitAPIService
org *string
group *string
page *int64
limit *int64
}
// Org lists one org's repositories; empty lists every org's.
func (r GitAPIGetGitActivityRequest) Org(org string) GitAPIGetGitActivityRequest {
r.org = &org
return r
}
// Group lists one group's repositories (hanzo, lux, zoo); empty lists every group's.
func (r GitAPIGetGitActivityRequest) Group(group string) GitAPIGetGitActivityRequest {
r.group = &group
return r
}
// Page is the repository page, from 1. Anything not positive means 1.
func (r GitAPIGetGitActivityRequest) Page(page int64) GitAPIGetGitActivityRequest {
r.page = &page
return r
}
// Limit is the page size. Anything not positive means 50; the cap is 200.
func (r GitAPIGetGitActivityRequest) Limit(limit int64) GitAPIGetGitActivityRequest {
r.limit = &limit
return r
}
func (r GitAPIGetGitActivityRequest) Execute() (*GitActivityOut, *http.Response, error) {
return r.ApiService.GetGitActivityExecute(r)
}
/*
GetGitActivity Answers the estate's last 365 days: distinct commits, merges, active repositories and contributors, for the whole estate, each group and each org, a commit count per day, the newest public commits, and one page of public repositories.
Answers the estate's last 365 days: distinct commits, merges,
active repositories and contributors, for the whole estate, each group and
each org, a commit count per day, the newest public commits, and one page of
public repositories. Public: private repositories are counted and never named.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIGetGitActivityRequest
*/
func (a *GitAPIService) GetGitActivity(ctx context.Context) GitAPIGetGitActivityRequest {
return GitAPIGetGitActivityRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return GitActivityOut
func (a *GitAPIService) GetGitActivityExecute(r GitAPIGetGitActivityRequest) (*GitActivityOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitActivityOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitActivity")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/activity"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.org != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "org", r.org, "form", "")
}
if r.group != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "group", r.group, "form", "")
}
if r.page != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "page", r.page, "form", "")
}
if r.limit != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitByOrgByProjectByRepoInfoRefsRequest struct {
ctx context.Context
ApiService *GitAPIService
org string
project string
repo string
}
func (r GitAPIGetGitByOrgByProjectByRepoInfoRefsRequest) Execute() (*http.Response, error) {
return r.ApiService.GetGitByOrgByProjectByRepoInfoRefsExecute(r)
}
/*
GetGitByOrgByProjectByRepoInfoRefs Advertise a repository's refs to a git client
The ref-advertisement phase of git's smart-HTTP protocol — the first request a clone, a fetch and a push all make. `?service=` selects which: `git-upload-pack` advertises for a fetch, `git-receive-pack` for a push, and any other value is 400.
ANONYMOUS ONLY FOR FETCH, AND ONLY ON A PUBLIC REPOSITORY. The push advertisement always requires an authenticated org, and where a path org is present it must equal the authenticated one. A private repository reached without its org is 404, indistinguishable from one that does not exist. Addressed under the API prefix, with the PROJECT as a middle path segment: project scope otherwise rides a header a git client cannot send, so this path is the only usable remote for a project-scoped repository. This is git's own wire protocol, not an API call to make by hand: point a git client at the clone URL and it makes this request itself.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param org
@param project
@param repo
@return GitAPIGetGitByOrgByProjectByRepoInfoRefsRequest
*/
func (a *GitAPIService) GetGitByOrgByProjectByRepoInfoRefs(ctx context.Context, org string, project string, repo string) GitAPIGetGitByOrgByProjectByRepoInfoRefsRequest {
return GitAPIGetGitByOrgByProjectByRepoInfoRefsRequest{
ApiService: a,
ctx: ctx,
org: org,
project: project,
repo: repo,
}
}
// Execute executes the request
func (a *GitAPIService) GetGitByOrgByProjectByRepoInfoRefsExecute(r GitAPIGetGitByOrgByProjectByRepoInfoRefsRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitByOrgByProjectByRepoInfoRefs")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/{org}/{project}/{repo}/info/refs"
localVarPath = strings.Replace(localVarPath, "{"+"org"+"}", url.PathEscape(parameterValueToString(r.org, "org")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"project"+"}", url.PathEscape(parameterValueToString(r.project, "project")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type GitAPIGetGitByOrgByRepoRequest struct {
ctx context.Context
ApiService *GitAPIService
org string
repo string
}
func (r GitAPIGetGitByOrgByRepoRequest) Execute() (*http.Response, error) {
return r.ApiService.GetGitByOrgByRepoExecute(r)
}
/*
GetGitByOrgByRepo Open a repository's home page
A repository at a glance: its branches, the tree at the tip, its most recent commits, its README rendered, and the HTTPS and SSH clone URLs. `?ref=` selects a branch, tag or commit; the default branch is used when it is omitted. A repository with no commits yet renders its clone instructions rather than an error, which is what a caller who has just created one needs to see. A public repository is readable by anyone; a private one only by its own org. A repository that does not exist and one belonging to another org answer the SAME 404, so the page is never an existence oracle. This is a server-rendered browser page, not JSON — the console repo-browser reads the same repository through the JSON ops under /v1/git/repos. Repository names, paths and file contents all render through auto-escaping templates rather than being concatenated into HTML.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param org
@param repo
@return GitAPIGetGitByOrgByRepoRequest
*/
func (a *GitAPIService) GetGitByOrgByRepo(ctx context.Context, org string, repo string) GitAPIGetGitByOrgByRepoRequest {
return GitAPIGetGitByOrgByRepoRequest{
ApiService: a,
ctx: ctx,
org: org,
repo: repo,
}
}
// Execute executes the request
func (a *GitAPIService) GetGitByOrgByRepoExecute(r GitAPIGetGitByOrgByRepoRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitByOrgByRepo")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/{org}/{repo}"
localVarPath = strings.Replace(localVarPath, "{"+"org"+"}", url.PathEscape(parameterValueToString(r.org, "org")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type GitAPIGetGitByOrgByRepoCommitsRequest struct {
ctx context.Context
ApiService *GitAPIService
org string
repo string
}
func (r GitAPIGetGitByOrgByRepoCommitsRequest) Execute() (*http.Response, error) {
return r.ApiService.GetGitByOrgByRepoCommitsExecute(r)
}
/*
GetGitByOrgByRepoCommits Read a repository's commit log
The hundred most recent commits on one ref, each with its author, message and date. `?ref=` selects the branch, tag or commit, defaulting to the repository's default branch; an unknown one is 404. A public repository is readable by anyone; a private one only by its own org. A repository that does not exist and one belonging to another org answer the SAME 404, so the page is never an existence oracle. This is a server-rendered browser page, not JSON — the console repo-browser reads the same repository through the JSON ops under /v1/git/repos. Repository names, paths and file contents all render through auto-escaping templates rather than being concatenated into HTML.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param org
@param repo
@return GitAPIGetGitByOrgByRepoCommitsRequest
*/
func (a *GitAPIService) GetGitByOrgByRepoCommits(ctx context.Context, org string, repo string) GitAPIGetGitByOrgByRepoCommitsRequest {
return GitAPIGetGitByOrgByRepoCommitsRequest{
ApiService: a,
ctx: ctx,
org: org,
repo: repo,
}
}
// Execute executes the request
func (a *GitAPIService) GetGitByOrgByRepoCommitsExecute(r GitAPIGetGitByOrgByRepoCommitsRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitByOrgByRepoCommits")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/{org}/{repo}/commits"
localVarPath = strings.Replace(localVarPath, "{"+"org"+"}", url.PathEscape(parameterValueToString(r.org, "org")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type GitAPIGetGitByOrgByRepoInfoRefsRequest struct {
ctx context.Context
ApiService *GitAPIService
org string
repo string
}
func (r GitAPIGetGitByOrgByRepoInfoRefsRequest) Execute() (*http.Response, error) {
return r.ApiService.GetGitByOrgByRepoInfoRefsExecute(r)
}
/*
GetGitByOrgByRepoInfoRefs Advertise a repository's refs to a git client
The ref-advertisement phase of git's smart-HTTP protocol — the first request a clone, a fetch and a push all make. `?service=` selects which: `git-upload-pack` advertises for a fetch, `git-receive-pack` for a push, and any other value is 400.
ANONYMOUS ONLY FOR FETCH, AND ONLY ON A PUBLIC REPOSITORY. The push advertisement always requires an authenticated org, and where a path org is present it must equal the authenticated one. A private repository reached without its org is 404, indistinguishable from one that does not exist. Addressed under the API prefix, so `git clone https://<host>/v1/git/<org>/<repo>.git` works on any host the binary serves. This is git's own wire protocol, not an API call to make by hand: point a git client at the clone URL and it makes this request itself.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param org
@param repo
@return GitAPIGetGitByOrgByRepoInfoRefsRequest
*/
func (a *GitAPIService) GetGitByOrgByRepoInfoRefs(ctx context.Context, org string, repo string) GitAPIGetGitByOrgByRepoInfoRefsRequest {
return GitAPIGetGitByOrgByRepoInfoRefsRequest{
ApiService: a,
ctx: ctx,
org: org,
repo: repo,
}
}
// Execute executes the request
func (a *GitAPIService) GetGitByOrgByRepoInfoRefsExecute(r GitAPIGetGitByOrgByRepoInfoRefsRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitByOrgByRepoInfoRefs")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/{org}/{repo}/info/refs"
localVarPath = strings.Replace(localVarPath, "{"+"org"+"}", url.PathEscape(parameterValueToString(r.org, "org")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type GitAPIGetGitExploreRequest struct {
ctx context.Context
ApiService *GitAPIService
}
func (r GitAPIGetGitExploreRequest) Execute() (*http.Response, error) {
return r.ApiService.GetGitExploreExecute(r)
}
/*
GetGitExplore Discover public repositories across every org
The open, unauthenticated face of the git host: every PUBLIC repository in the fleet, org-qualified, so a project can be found and cloned with no account at all — signing in is for private repos and for writes. Repositories live in per-org stores with no global index, so this unions each org's public rows and is bounded to a fixed number of stores per request, keeping discovery quick however many orgs exist. A fleet with no orgs yet is an empty page, not an error. This is a server-rendered browser page, not JSON — the console repo-browser reads the same repository through the JSON ops under /v1/git/repos. Repository names, paths and file contents all render through auto-escaping templates rather than being concatenated into HTML.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIGetGitExploreRequest
*/
func (a *GitAPIService) GetGitExplore(ctx context.Context) GitAPIGetGitExploreRequest {
return GitAPIGetGitExploreRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *GitAPIService) GetGitExploreExecute(r GitAPIGetGitExploreRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitExplore")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/explore"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type GitAPIGetGitPoolsRequest struct {
ctx context.Context
ApiService *GitAPIService
}
func (r GitAPIGetGitPoolsRequest) Execute() (*GitPoolList, *http.Response, error) {
return r.ApiService.GetGitPoolsExecute(r)
}
/*
GetGitPools Returns the capacity this org has declared and how many daemons have entered each pool.
Returns the capacity this org has declared and how many daemons have
entered each pool.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIGetGitPoolsRequest
*/
func (a *GitAPIService) GetGitPools(ctx context.Context) GitAPIGetGitPoolsRequest {
return GitAPIGetGitPoolsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return GitPoolList
func (a *GitAPIService) GetGitPoolsExecute(r GitAPIGetGitPoolsRequest) (*GitPoolList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitPoolList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitPools")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/pools"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitReposRequest struct {
ctx context.Context
ApiService *GitAPIService
}
func (r GitAPIGetGitReposRequest) Execute() (*GitRepoList, *http.Response, error) {
return r.ApiService.GetGitReposExecute(r)
}
/*
GetGitRepos Returns the repos in the caller's scope, most recently updated first.
Returns the repos in the caller's scope, most recently updated
first. The scope is the request principal's — the gateway-minted org and its
optional project — never anything off the wire, so a caller only ever sees its
own. Rows carry no branches or HEAD; read one repo for those.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIGetGitReposRequest
*/
func (a *GitAPIService) GetGitRepos(ctx context.Context) GitAPIGetGitReposRequest {
return GitAPIGetGitReposRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return GitRepoList
func (a *GitAPIService) GetGitReposExecute(r GitAPIGetGitReposRequest) (*GitRepoList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitRepoList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitRepos")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitReposByNameRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
}
func (r GitAPIGetGitReposByNameRequest) Execute() (*GitRepoView, *http.Response, error) {
return r.ApiService.GetGitReposByNameExecute(r)
}
/*
GetGitReposByName Returns one repo with its live ref state: every branch name and the resolved HEAD commit.
Returns one repo with its live ref state: every branch name and the
resolved HEAD commit. Both are read from the object store on each call, so an
empty repo reports no branches and an empty head rather than failing. A repo
outside the caller's scope is not found.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo's org-unique handle, from the :name path segment. A trailing \".git\" is stripped.
@return GitAPIGetGitReposByNameRequest
*/
func (a *GitAPIService) GetGitReposByName(ctx context.Context, name string) GitAPIGetGitReposByNameRequest {
return GitAPIGetGitReposByNameRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitRepoView
func (a *GitAPIService) GetGitReposByNameExecute(r GitAPIGetGitReposByNameRequest) (*GitRepoView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitRepoView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitReposByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitReposByNameBlobRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
ref *string
path *string
}
// Ref is a branch, tag or commit; empty means the repo&#39;s HEAD.
func (r GitAPIGetGitReposByNameBlobRequest) Ref(ref string) GitAPIGetGitReposByNameBlobRequest {
r.ref = &ref
return r
}
// Path is repo-relative; empty is the tree root. Traversal is stripped.
func (r GitAPIGetGitReposByNameBlobRequest) Path(path string) GitAPIGetGitReposByNameBlobRequest {
r.path = &path
return r
}
func (r GitAPIGetGitReposByNameBlobRequest) Execute() (*GitBlobJSON, *http.Response, error) {
return r.ApiService.GetGitReposByNameBlobExecute(r)
}
/*
GetGitReposByNameBlob Returns one file's bytes at one revision.
Returns one file's bytes at one revision. Text comes back verbatim,
binary comes back base64, and a file past the 1 MiB view cap comes back marked
truncated with NO content — the client is expected to clone instead. A
repository in the organization's own code workspace on the forge is read from
there.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo to read, from the :name path segment.
@return GitAPIGetGitReposByNameBlobRequest
*/
func (a *GitAPIService) GetGitReposByNameBlob(ctx context.Context, name string) GitAPIGetGitReposByNameBlobRequest {
return GitAPIGetGitReposByNameBlobRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitBlobJSON
func (a *GitAPIService) GetGitReposByNameBlobExecute(r GitAPIGetGitReposByNameBlobRequest) (*GitBlobJSON, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitBlobJSON
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitReposByNameBlob")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/blob"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.ref != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "ref", r.ref, "form", "")
}
if r.path != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "path", r.path, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitReposByNameCommitsRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
ref *string
path *string
limit *int64
}
// Ref is the branch, tag or commit to walk back from; empty means HEAD.
func (r GitAPIGetGitReposByNameCommitsRequest) Ref(ref string) GitAPIGetGitReposByNameCommitsRequest {
r.ref = &ref
return r
}
// Path narrows the history to commits touching it; empty walks the whole ref.
func (r GitAPIGetGitReposByNameCommitsRequest) Path(path string) GitAPIGetGitReposByNameCommitsRequest {
r.path = &path
return r
}
// Limit caps the page. Anything not positive means 50; the cap is 100.
func (r GitAPIGetGitReposByNameCommitsRequest) Limit(limit int64) GitAPIGetGitReposByNameCommitsRequest {
r.limit = &limit
return r
}
func (r GitAPIGetGitReposByNameCommitsRequest) Execute() (*GitCommitsJSON, *http.Response, error) {
return r.ApiService.GetGitReposByNameCommitsExecute(r)
}
/*
GetGitReposByNameCommits Walks a ref's history newest first, or one path's history when a path is given.
Walks a ref's history newest first, or one path's history when a
path is given. There is no cursor: the page is the newest `limit` commits.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo to read, from the :name path segment.
@return GitAPIGetGitReposByNameCommitsRequest
*/
func (a *GitAPIService) GetGitReposByNameCommits(ctx context.Context, name string) GitAPIGetGitReposByNameCommitsRequest {
return GitAPIGetGitReposByNameCommitsRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitCommitsJSON
func (a *GitAPIService) GetGitReposByNameCommitsExecute(r GitAPIGetGitReposByNameCommitsRequest) (*GitCommitsJSON, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitCommitsJSON
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitReposByNameCommits")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/commits"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.ref != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "ref", r.ref, "form", "")
}
if r.path != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "path", r.path, "form", "")
}
if r.limit != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitReposByNameFilesRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
ref *string
glob *string
}
// Ref is a branch, tag or commit; empty means the repo&#39;s HEAD.
func (r GitAPIGetGitReposByNameFilesRequest) Ref(ref string) GitAPIGetGitReposByNameFilesRequest {
r.ref = &ref
return r
}
// Glob selects files, matched segment by segment so &#x60;*&#x60; never crosses a &#x60;/&#x60;. &#x60;**&#x60; matches zero or more whole segments.
func (r GitAPIGetGitReposByNameFilesRequest) Glob(glob string) GitAPIGetGitReposByNameFilesRequest {
r.glob = &glob
return r
}
func (r GitAPIGetGitReposByNameFilesRequest) Execute() (*GitFilesJSON, *http.Response, error) {
return r.ApiService.GetGitReposByNameFilesExecute(r)
}
/*
GetGitReposByNameFiles Returns every file a glob selects at one revision, WITH its bytes and the revision they came from.
Returns every file a glob selects at one revision, WITH its bytes
and the revision they came from. It is the read a delivery generator makes:
one call answers "what is the inventory at this commit, and what does it say",
where listing and then fetching would be a request per file.
Returning the resolved revision matters as much as the bytes. A generator that
lists at `main` and then reads at `main` can straddle a push and assemble half
its inventory from one commit and half from the next; resolving once makes the
whole read consistent by construction.
A file past the read cap comes back Truncated with no content rather than
being dropped. A caller building a desired set has to know the difference
between "this file is empty" and "this file was not read" — silently omitting
it is how a pruning reconcile deletes what the missing file declared.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo to read, from the :name path segment.
@return GitAPIGetGitReposByNameFilesRequest
*/
func (a *GitAPIService) GetGitReposByNameFiles(ctx context.Context, name string) GitAPIGetGitReposByNameFilesRequest {
return GitAPIGetGitReposByNameFilesRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitFilesJSON
func (a *GitAPIService) GetGitReposByNameFilesExecute(r GitAPIGetGitReposByNameFilesRequest) (*GitFilesJSON, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitFilesJSON
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitReposByNameFiles")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/files"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.ref != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "ref", r.ref, "form", "")
}
if r.glob != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "glob", r.glob, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitReposByNamePullsRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
state *string
}
// State narrows the list to \&quot;open\&quot; or \&quot;merged\&quot;. Omit it for every proposal.
func (r GitAPIGetGitReposByNamePullsRequest) State(state string) GitAPIGetGitReposByNamePullsRequest {
r.state = &state
return r
}
func (r GitAPIGetGitReposByNamePullsRequest) Execute() (*GitPullList, *http.Response, error) {
return r.ApiService.GetGitReposByNamePullsExecute(r)
}
/*
GetGitReposByNamePulls Returns a repo's pull requests, newest number first — what is waiting to be reviewed, and what has already landed.
Returns a repo's pull requests, newest number first — what is
waiting to be reviewed, and what has already landed. Narrow it with
?state=open or ?state=merged; omit state for every proposal.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo, from the :name path segment.
@return GitAPIGetGitReposByNamePullsRequest
*/
func (a *GitAPIService) GetGitReposByNamePulls(ctx context.Context, name string) GitAPIGetGitReposByNamePullsRequest {
return GitAPIGetGitReposByNamePullsRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitPullList
func (a *GitAPIService) GetGitReposByNamePullsExecute(r GitAPIGetGitReposByNamePullsRequest) (*GitPullList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitPullList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitReposByNamePulls")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/pulls"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.state != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "state", r.state, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitReposByNamePullsByNumberRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
number int64
}
func (r GitAPIGetGitReposByNamePullsByNumberRequest) Execute() (*GitPullView, *http.Response, error) {
return r.ApiService.GetGitReposByNamePullsByNumberExecute(r)
}
/*
GetGitReposByNamePullsByNumber Returns one pull request by its per-repo number.
Returns one pull request by its per-repo number. A number belonging to
another tenant's repo is not found, exactly as the repo itself is not.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo, from the :name path segment.
@param number Number is the proposal's per-repo number, from the :number path segment.
@return GitAPIGetGitReposByNamePullsByNumberRequest
*/
func (a *GitAPIService) GetGitReposByNamePullsByNumber(ctx context.Context, name string, number int64) GitAPIGetGitReposByNamePullsByNumberRequest {
return GitAPIGetGitReposByNamePullsByNumberRequest{
ApiService: a,
ctx: ctx,
name: name,
number: number,
}
}
// Execute executes the request
//
// @return GitPullView
func (a *GitAPIService) GetGitReposByNamePullsByNumberExecute(r GitAPIGetGitReposByNamePullsByNumberRequest) (*GitPullView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitPullView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitReposByNamePullsByNumber")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/pulls/{number}"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"number"+"}", url.PathEscape(parameterValueToString(r.number, "number")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitReposByNameReadmeRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
ref *string
}
// Ref is a branch, tag or commit; empty means the repo&#39;s HEAD.
func (r GitAPIGetGitReposByNameReadmeRequest) Ref(ref string) GitAPIGetGitReposByNameReadmeRequest {
r.ref = &ref
return r
}
func (r GitAPIGetGitReposByNameReadmeRequest) Execute() (*GitReadmeJSON, *http.Response, error) {
return r.ApiService.GetGitReposByNameReadmeExecute(r)
}
/*
GetGitReposByNameReadme Returns the README at the tree root as plain text — unrendered, so the caller decides how to present it.
Returns the README at the tree root as plain text — unrendered, so
the caller decides how to present it. A repo with no README is not found.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo to read, from the :name path segment.
@return GitAPIGetGitReposByNameReadmeRequest
*/
func (a *GitAPIService) GetGitReposByNameReadme(ctx context.Context, name string) GitAPIGetGitReposByNameReadmeRequest {
return GitAPIGetGitReposByNameReadmeRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitReadmeJSON
func (a *GitAPIService) GetGitReposByNameReadmeExecute(r GitAPIGetGitReposByNameReadmeRequest) (*GitReadmeJSON, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitReadmeJSON
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitReposByNameReadme")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/readme"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.ref != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "ref", r.ref, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitReposByNameRefsRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
}
func (r GitAPIGetGitReposByNameRefsRequest) Execute() (*GitRefsJSON, *http.Response, error) {
return r.ApiService.GetGitReposByNameRefsExecute(r)
}
/*
GetGitReposByNameRefs Lists a repo's branches, tags and default branch — what a branch picker needs in one call.
Lists a repo's branches, tags and default branch — what a branch
picker needs in one call. Unlike the other read ops it tolerates a repo with no
commits: the ref sets come back empty and the default branch is still named.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo's org-unique handle, from the :name path segment. A trailing \".git\" is stripped.
@return GitAPIGetGitReposByNameRefsRequest
*/
func (a *GitAPIService) GetGitReposByNameRefs(ctx context.Context, name string) GitAPIGetGitReposByNameRefsRequest {
return GitAPIGetGitReposByNameRefsRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitRefsJSON
func (a *GitAPIService) GetGitReposByNameRefsExecute(r GitAPIGetGitReposByNameRefsRequest) (*GitRefsJSON, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitRefsJSON
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitReposByNameRefs")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/refs"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitReposByNameSubscriptionsRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
}
func (r GitAPIGetGitReposByNameSubscriptionsRequest) Execute() (*GitSubscriptionList, *http.Response, error) {
return r.ApiService.GetGitReposByNameSubscriptionsExecute(r)
}
/*
GetGitReposByNameSubscriptions Returns a repo's Slack subscriptions — which channels the lifecycle notifier posts this repo's push and deploy events to.
Returns a repo's Slack subscriptions — which channels the
lifecycle notifier posts this repo's push and deploy events to.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo's org-unique handle, from the :name path segment. A trailing \".git\" is stripped.
@return GitAPIGetGitReposByNameSubscriptionsRequest
*/
func (a *GitAPIService) GetGitReposByNameSubscriptions(ctx context.Context, name string) GitAPIGetGitReposByNameSubscriptionsRequest {
return GitAPIGetGitReposByNameSubscriptionsRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitSubscriptionList
func (a *GitAPIService) GetGitReposByNameSubscriptionsExecute(r GitAPIGetGitReposByNameSubscriptionsRequest) (*GitSubscriptionList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitSubscriptionList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitReposByNameSubscriptions")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/subscriptions"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitReposByNameTargetsRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
}
func (r GitAPIGetGitReposByNameTargetsRequest) Execute() (*GitMirrorList, *http.Response, error) {
return r.ApiService.GetGitReposByNameTargetsExecute(r)
}
/*
GetGitReposByNameTargets Returns a repo's outbound mirror targets — the downstream remotes the mirror reactor pushes to whenever a push lands here.
Returns a repo's outbound mirror targets — the downstream remotes
the mirror reactor pushes to whenever a push lands here.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo's org-unique handle, from the :name path segment. A trailing \".git\" is stripped.
@return GitAPIGetGitReposByNameTargetsRequest
*/
func (a *GitAPIService) GetGitReposByNameTargets(ctx context.Context, name string) GitAPIGetGitReposByNameTargetsRequest {
return GitAPIGetGitReposByNameTargetsRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitMirrorList
func (a *GitAPIService) GetGitReposByNameTargetsExecute(r GitAPIGetGitReposByNameTargetsRequest) (*GitMirrorList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitMirrorList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitReposByNameTargets")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/targets"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitReposByNameTreeRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
ref *string
path *string
}
// Ref is a branch, tag or commit; empty means the repo&#39;s HEAD.
func (r GitAPIGetGitReposByNameTreeRequest) Ref(ref string) GitAPIGetGitReposByNameTreeRequest {
r.ref = &ref
return r
}
// Path is repo-relative; empty is the tree root. Traversal is stripped.
func (r GitAPIGetGitReposByNameTreeRequest) Path(path string) GitAPIGetGitReposByNameTreeRequest {
r.path = &path
return r
}
func (r GitAPIGetGitReposByNameTreeRequest) Execute() (*GitTreeJSON, *http.Response, error) {
return r.ApiService.GetGitReposByNameTreeExecute(r)
}
/*
GetGitReposByNameTree Lists the immediate children of one directory at one revision, directories before files.
Lists the immediate children of one directory at one revision,
directories before files. It does not recurse — walk down a level at a time.
A repository in the organization's own code workspace on the forge is listed
from there.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo to read, from the :name path segment.
@return GitAPIGetGitReposByNameTreeRequest
*/
func (a *GitAPIService) GetGitReposByNameTree(ctx context.Context, name string) GitAPIGetGitReposByNameTreeRequest {
return GitAPIGetGitReposByNameTreeRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitTreeJSON
func (a *GitAPIService) GetGitReposByNameTreeExecute(r GitAPIGetGitReposByNameTreeRequest) (*GitTreeJSON, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitTreeJSON
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitReposByNameTree")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/tree"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.ref != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "ref", r.ref, "form", "")
}
if r.path != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "path", r.path, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitRunnersRequest struct {
ctx context.Context
ApiService *GitAPIService
}
func (r GitAPIGetGitRunnersRequest) Execute() (*GitRunnerList, *http.Response, error) {
return r.ApiService.GetGitRunnersExecute(r)
}
/*
GetGitRunners Returns the daemons registered into this org's pools, newest first, with when each was last heard from.
Returns the daemons registered into this org's pools, newest
first, with when each was last heard from.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIGetGitRunnersRequest
*/
func (a *GitAPIService) GetGitRunners(ctx context.Context) GitAPIGetGitRunnersRequest {
return GitAPIGetGitRunnersRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return GitRunnerList
func (a *GitAPIService) GetGitRunnersExecute(r GitAPIGetGitRunnersRequest) (*GitRunnerList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitRunnerList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitRunners")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/runners"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitRunsRequest struct {
ctx context.Context
ApiService *GitAPIService
repo *string
limit *int64
}
// Repo restricts the listing to one repository. Empty lists the whole org.
func (r GitAPIGetGitRunsRequest) Repo(repo string) GitAPIGetGitRunsRequest {
r.repo = &repo
return r
}
// Limit caps the answer; 0 means the default of 50, and 200 is the ceiling.
func (r GitAPIGetGitRunsRequest) Limit(limit int64) GitAPIGetGitRunsRequest {
r.limit = &limit
return r
}
func (r GitAPIGetGitRunsRequest) Execute() (*GitWorkflowRuns, *http.Response, error) {
return r.ApiService.GetGitRunsExecute(r)
}
/*
GetGitRuns Returns this org's runs, newest first.
Returns this org's runs, newest first.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIGetGitRunsRequest
*/
func (a *GitAPIService) GetGitRuns(ctx context.Context) GitAPIGetGitRunsRequest {
return GitAPIGetGitRunsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return GitWorkflowRuns
func (a *GitAPIService) GetGitRunsExecute(r GitAPIGetGitRunsRequest) (*GitWorkflowRuns, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitWorkflowRuns
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitRuns")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/runs"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.repo != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "repo", r.repo, "form", "")
}
if r.limit != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitRunsByIdRequest struct {
ctx context.Context
ApiService *GitAPIService
id string
}
func (r GitAPIGetGitRunsByIdRequest) Execute() (*GitWorkflowRun, *http.Response, error) {
return r.ApiService.GetGitRunsByIdExecute(r)
}
/*
GetGitRunsById Returns one run.
Returns one run.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the run to read, from the :id path segment.
@return GitAPIGetGitRunsByIdRequest
*/
func (a *GitAPIService) GetGitRunsById(ctx context.Context, id string) GitAPIGetGitRunsByIdRequest {
return GitAPIGetGitRunsByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return GitWorkflowRun
func (a *GitAPIService) GetGitRunsByIdExecute(r GitAPIGetGitRunsByIdRequest) (*GitWorkflowRun, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitWorkflowRun
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitRunsById")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/runs/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitUsageRequest struct {
ctx context.Context
ApiService *GitAPIService
}
func (r GitAPIGetGitUsageRequest) Execute() (*GitUsageView, *http.Response, error) {
return r.ApiService.GetGitUsageExecute(r)
}
/*
GetGitUsage Returns per-repo and total storage bytes for the caller's org — the queryable, per-tenant number commerce and o11y meter on.
Returns per-repo and total storage bytes for the caller's org — the
queryable, per-tenant number commerce and o11y meter on. It spans EVERY
project sub-scope, unlike the repo list, so a billing consumer sees the whole
tenant footprint in one call. Sizes are last-measured values (create, push,
mirror and gc each re-measure), not a live walk of the disk.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIGetGitUsageRequest
*/
func (a *GitAPIService) GetGitUsage(ctx context.Context) GitAPIGetGitUsageRequest {
return GitAPIGetGitUsageRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return GitUsageView
func (a *GitAPIService) GetGitUsageExecute(r GitAPIGetGitUsageRequest) (*GitUsageView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitUsageView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitUsage")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/usage"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIGetGitWorkflowsRequest struct {
ctx context.Context
ApiService *GitAPIService
repo *string
ref *string
}
// Repo is the repository whose workflows to read.
func (r GitAPIGetGitWorkflowsRequest) Repo(repo string) GitAPIGetGitWorkflowsRequest {
r.repo = &repo
return r
}
// Ref is the branch to read them at; empty means the default.
func (r GitAPIGetGitWorkflowsRequest) Ref(ref string) GitAPIGetGitWorkflowsRequest {
r.ref = &ref
return r
}
func (r GitAPIGetGitWorkflowsRequest) Execute() (*GitWorkflowList, *http.Response, error) {
return r.ApiService.GetGitWorkflowsExecute(r)
}
/*
GetGitWorkflows Reports the workflows a repository declares at a ref and which declared pool would execute each job — the answer to \"would a push here run, and where\".
Reports the workflows a repository declares at a ref and which
declared pool would execute each job — the answer to "would a push here run,
and where".
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIGetGitWorkflowsRequest
*/
func (a *GitAPIService) GetGitWorkflows(ctx context.Context) GitAPIGetGitWorkflowsRequest {
return GitAPIGetGitWorkflowsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return GitWorkflowList
func (a *GitAPIService) GetGitWorkflowsExecute(r GitAPIGetGitWorkflowsRequest) (*GitWorkflowList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitWorkflowList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.GetGitWorkflows")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/workflows"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.repo != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "repo", r.repo, "form", "")
}
if r.ref != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "ref", r.ref, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPatchGitReposByNameRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
gitPatchIn *GitPatchIn
}
func (r GitAPIPatchGitReposByNameRequest) GitPatchIn(gitPatchIn GitPatchIn) GitAPIPatchGitReposByNameRequest {
r.gitPatchIn = &gitPatchIn
return r
}
func (r GitAPIPatchGitReposByNameRequest) Execute() (*GitRepoView, *http.Response, error) {
return r.ApiService.PatchGitReposByNameExecute(r)
}
/*
PatchGitReposByName Flips a repo's public bit, the one mutable repo setting today.
Flips a repo's public bit, the one mutable repo setting today.
Public grants ANONYMOUS fetch only; push and the whole control plane stay
org-authed. Returns the updated repo.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo to update, from the :name path segment.
@return GitAPIPatchGitReposByNameRequest
*/
func (a *GitAPIService) PatchGitReposByName(ctx context.Context, name string) GitAPIPatchGitReposByNameRequest {
return GitAPIPatchGitReposByNameRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitRepoView
func (a *GitAPIService) PatchGitReposByNameExecute(r GitAPIPatchGitReposByNameRequest) (*GitRepoView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPatch
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitRepoView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PatchGitReposByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.gitPatchIn == nil {
return localVarReturnValue, nil, reportError("gitPatchIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.gitPatchIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostGitByOrgByProjectByRepoGitReceivePackRequest struct {
ctx context.Context
ApiService *GitAPIService
org string
project string
repo string
body *os.File
}
func (r GitAPIPostGitByOrgByProjectByRepoGitReceivePackRequest) Body(body *os.File) GitAPIPostGitByOrgByProjectByRepoGitReceivePackRequest {
r.body = body
return r
}
func (r GitAPIPostGitByOrgByProjectByRepoGitReceivePackRequest) Execute() (*http.Response, error) {
return r.ApiService.PostGitByOrgByProjectByRepoGitReceivePackExecute(r)
}
/*
PostGitByOrgByProjectByRepoGitReceivePack Accept a push, and turn it into a build
The pack-transfer phase of a push, and the point at which a push becomes an EVENT. NEVER ANONYMOUS: a push always requires an authenticated org, and the org in the path must equal it.
Once the pack is on disk the repository's storage usage is metered and a build is fired for every branch whose tip actually moved, computed from the before/after branch diff rather than from what the client claimed. That runs on a cancel-immune context, so a client that hangs up the moment its push lands still gets its build, and it runs even when git itself exited non-zero — the refs on disk are the ground truth. Repacking housekeeping is detached and never blocks the response.
A Content-Type other than `application/x-git-receive-pack-request` is 400. Addressed under the API prefix, with the PROJECT as a middle path segment: project scope otherwise rides a header a git client cannot send, so this path is the only usable remote for a project-scoped repository. This is git's own wire protocol, not an API call to make by hand: point a git client at the clone URL and it makes this request itself.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param org
@param project
@param repo
@return GitAPIPostGitByOrgByProjectByRepoGitReceivePackRequest
*/
func (a *GitAPIService) PostGitByOrgByProjectByRepoGitReceivePack(ctx context.Context, org string, project string, repo string) GitAPIPostGitByOrgByProjectByRepoGitReceivePackRequest {
return GitAPIPostGitByOrgByProjectByRepoGitReceivePackRequest{
ApiService: a,
ctx: ctx,
org: org,
project: project,
repo: repo,
}
}
// Execute executes the request
func (a *GitAPIService) PostGitByOrgByProjectByRepoGitReceivePackExecute(r GitAPIPostGitByOrgByProjectByRepoGitReceivePackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitByOrgByProjectByRepoGitReceivePack")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/{org}/{project}/{repo}/git-receive-pack"
localVarPath = strings.Replace(localVarPath, "{"+"org"+"}", url.PathEscape(parameterValueToString(r.org, "org")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"project"+"}", url.PathEscape(parameterValueToString(r.project, "project")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/octet-stream"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.body
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type GitAPIPostGitByOrgByProjectByRepoGitUploadPackRequest struct {
ctx context.Context
ApiService *GitAPIService
org string
project string
repo string
body *os.File
}
func (r GitAPIPostGitByOrgByProjectByRepoGitUploadPackRequest) Body(body *os.File) GitAPIPostGitByOrgByProjectByRepoGitUploadPackRequest {
r.body = body
return r
}
func (r GitAPIPostGitByOrgByProjectByRepoGitUploadPackRequest) Execute() (*http.Response, error) {
return r.ApiService.PostGitByOrgByProjectByRepoGitUploadPackExecute(r)
}
/*
PostGitByOrgByProjectByRepoGitUploadPack Serve a clone or fetch
The pack-transfer phase of a clone or fetch: the request and the response are git's binary pack protocol, streamed straight through git itself — request body to git's stdin, git's stdout to the response — so a multi-gigabyte clone never lands in this process's memory.
A PUBLIC repository is fetched anonymously; a private one requires its own org, and a wrong or absent org is 404 rather than a hint that the repository exists. A Content-Type other than `application/x-git-upload-pack-request` is 400. Addressed under the API prefix, with the PROJECT as a middle path segment: project scope otherwise rides a header a git client cannot send, so this path is the only usable remote for a project-scoped repository. This is git's own wire protocol, not an API call to make by hand: point a git client at the clone URL and it makes this request itself.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param org
@param project
@param repo
@return GitAPIPostGitByOrgByProjectByRepoGitUploadPackRequest
*/
func (a *GitAPIService) PostGitByOrgByProjectByRepoGitUploadPack(ctx context.Context, org string, project string, repo string) GitAPIPostGitByOrgByProjectByRepoGitUploadPackRequest {
return GitAPIPostGitByOrgByProjectByRepoGitUploadPackRequest{
ApiService: a,
ctx: ctx,
org: org,
project: project,
repo: repo,
}
}
// Execute executes the request
func (a *GitAPIService) PostGitByOrgByProjectByRepoGitUploadPackExecute(r GitAPIPostGitByOrgByProjectByRepoGitUploadPackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitByOrgByProjectByRepoGitUploadPack")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/{org}/{project}/{repo}/git-upload-pack"
localVarPath = strings.Replace(localVarPath, "{"+"org"+"}", url.PathEscape(parameterValueToString(r.org, "org")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"project"+"}", url.PathEscape(parameterValueToString(r.project, "project")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/octet-stream"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.body
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type GitAPIPostGitByOrgByRepoGitReceivePackRequest struct {
ctx context.Context
ApiService *GitAPIService
org string
repo string
body *os.File
}
func (r GitAPIPostGitByOrgByRepoGitReceivePackRequest) Body(body *os.File) GitAPIPostGitByOrgByRepoGitReceivePackRequest {
r.body = body
return r
}
func (r GitAPIPostGitByOrgByRepoGitReceivePackRequest) Execute() (*http.Response, error) {
return r.ApiService.PostGitByOrgByRepoGitReceivePackExecute(r)
}
/*
PostGitByOrgByRepoGitReceivePack Accept a push, and turn it into a build
The pack-transfer phase of a push, and the point at which a push becomes an EVENT. NEVER ANONYMOUS: a push always requires an authenticated org, and the org in the path must equal it.
Once the pack is on disk the repository's storage usage is metered and a build is fired for every branch whose tip actually moved, computed from the before/after branch diff rather than from what the client claimed. That runs on a cancel-immune context, so a client that hangs up the moment its push lands still gets its build, and it runs even when git itself exited non-zero — the refs on disk are the ground truth. Repacking housekeeping is detached and never blocks the response.
A Content-Type other than `application/x-git-receive-pack-request` is 400. Addressed under the API prefix, so `git clone https://<host>/v1/git/<org>/<repo>.git` works on any host the binary serves. This is git's own wire protocol, not an API call to make by hand: point a git client at the clone URL and it makes this request itself.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param org
@param repo
@return GitAPIPostGitByOrgByRepoGitReceivePackRequest
*/
func (a *GitAPIService) PostGitByOrgByRepoGitReceivePack(ctx context.Context, org string, repo string) GitAPIPostGitByOrgByRepoGitReceivePackRequest {
return GitAPIPostGitByOrgByRepoGitReceivePackRequest{
ApiService: a,
ctx: ctx,
org: org,
repo: repo,
}
}
// Execute executes the request
func (a *GitAPIService) PostGitByOrgByRepoGitReceivePackExecute(r GitAPIPostGitByOrgByRepoGitReceivePackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitByOrgByRepoGitReceivePack")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/{org}/{repo}/git-receive-pack"
localVarPath = strings.Replace(localVarPath, "{"+"org"+"}", url.PathEscape(parameterValueToString(r.org, "org")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/octet-stream"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.body
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type GitAPIPostGitByOrgByRepoGitUploadPackRequest struct {
ctx context.Context
ApiService *GitAPIService
org string
repo string
body *os.File
}
func (r GitAPIPostGitByOrgByRepoGitUploadPackRequest) Body(body *os.File) GitAPIPostGitByOrgByRepoGitUploadPackRequest {
r.body = body
return r
}
func (r GitAPIPostGitByOrgByRepoGitUploadPackRequest) Execute() (*http.Response, error) {
return r.ApiService.PostGitByOrgByRepoGitUploadPackExecute(r)
}
/*
PostGitByOrgByRepoGitUploadPack Serve a clone or fetch
The pack-transfer phase of a clone or fetch: the request and the response are git's binary pack protocol, streamed straight through git itself — request body to git's stdin, git's stdout to the response — so a multi-gigabyte clone never lands in this process's memory.
A PUBLIC repository is fetched anonymously; a private one requires its own org, and a wrong or absent org is 404 rather than a hint that the repository exists. A Content-Type other than `application/x-git-upload-pack-request` is 400. Addressed under the API prefix, so `git clone https://<host>/v1/git/<org>/<repo>.git` works on any host the binary serves. This is git's own wire protocol, not an API call to make by hand: point a git client at the clone URL and it makes this request itself.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param org
@param repo
@return GitAPIPostGitByOrgByRepoGitUploadPackRequest
*/
func (a *GitAPIService) PostGitByOrgByRepoGitUploadPack(ctx context.Context, org string, repo string) GitAPIPostGitByOrgByRepoGitUploadPackRequest {
return GitAPIPostGitByOrgByRepoGitUploadPackRequest{
ApiService: a,
ctx: ctx,
org: org,
repo: repo,
}
}
// Execute executes the request
func (a *GitAPIService) PostGitByOrgByRepoGitUploadPackExecute(r GitAPIPostGitByOrgByRepoGitUploadPackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitByOrgByRepoGitUploadPack")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/{org}/{repo}/git-upload-pack"
localVarPath = strings.Replace(localVarPath, "{"+"org"+"}", url.PathEscape(parameterValueToString(r.org, "org")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/octet-stream"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.body
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type GitAPIPostGitLinkRequest struct {
ctx context.Context
ApiService *GitAPIService
gitLinkAll *GitLinkAll
}
func (r GitAPIPostGitLinkRequest) GitLinkAll(gitLinkAll GitLinkAll) GitAPIPostGitLinkRequest {
r.gitLinkAll = &gitLinkAll
return r
}
func (r GitAPIPostGitLinkRequest) Execute() (*GitLinked, *http.Response, error) {
return r.ApiService.PostGitLinkExecute(r)
}
/*
PostGitLink Links every repository of the caller's org that holds no history here and names no link to github.com/<owner>/<name>, where GitHub lets the caller read it.
Links every repository of the caller's org that holds no history
here and names no link to github.com/<owner>/<name>, where GitHub lets the
caller read it. A repository with no such namesake is listed and left alone,
and one holding history here is listed and never touched. Nothing is fetched:
a linked repository's cache fills on its first read. Org admins only.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIPostGitLinkRequest
*/
func (a *GitAPIService) PostGitLink(ctx context.Context) GitAPIPostGitLinkRequest {
return GitAPIPostGitLinkRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return GitLinked
func (a *GitAPIService) PostGitLinkExecute(r GitAPIPostGitLinkRequest) (*GitLinked, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitLinked
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitLink")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/link"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.gitLinkAll == nil {
return localVarReturnValue, nil, reportError("gitLinkAll is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.gitLinkAll
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostGitPoolsRequest struct {
ctx context.Context
ApiService *GitAPIService
gitPoolDeclare *GitPoolDeclare
}
func (r GitAPIPostGitPoolsRequest) GitPoolDeclare(gitPoolDeclare GitPoolDeclare) GitAPIPostGitPoolsRequest {
r.gitPoolDeclare = &gitPoolDeclare
return r
}
func (r GitAPIPostGitPoolsRequest) Execute() (*GitPoolDeclared, *http.Response, error) {
return r.ApiService.PostGitPoolsExecute(r)
}
/*
PostGitPools Records the capacity an org has, and answers with the secret a runner daemon presents to enter it.
Records the capacity an org has, and answers with the secret a
runner daemon presents to enter it.
Declaring is the ONLY way capacity comes to exist: a daemon cannot register
against a pool nobody declared, because the secret it would have to present
does not exist until this runs. Re-declaring an existing pool replaces its
labels and mints a fresh secret; runners already inside it keep working.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIPostGitPoolsRequest
*/
func (a *GitAPIService) PostGitPools(ctx context.Context) GitAPIPostGitPoolsRequest {
return GitAPIPostGitPoolsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return GitPoolDeclared
func (a *GitAPIService) PostGitPoolsExecute(r GitAPIPostGitPoolsRequest) (*GitPoolDeclared, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitPoolDeclared
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitPools")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/pools"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.gitPoolDeclare == nil {
return localVarReturnValue, nil, reportError("gitPoolDeclare is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.gitPoolDeclare
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostGitReposRequest struct {
ctx context.Context
ApiService *GitAPIService
gitCreateReq *GitCreateReq
}
func (r GitAPIPostGitReposRequest) GitCreateReq(gitCreateReq GitCreateReq) GitAPIPostGitReposRequest {
r.gitCreateReq = &gitCreateReq
return r
}
func (r GitAPIPostGitReposRequest) Execute() (*GitRepoView, *http.Response, error) {
return r.ApiService.PostGitReposExecute(r)
}
/*
PostGitRepos Provisions an empty bare repository in the caller's scope and returns it with its clone URLs.
Provisions an empty bare repository in the caller's scope and
returns it with its clone URLs. Answers 201. The name must be unique within
the scope — a repeat is a 409, never a silent overwrite of an existing repo.
The org comes from the validated principal, so a repo is always born owned by
the caller's own tenant.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIPostGitReposRequest
*/
func (a *GitAPIService) PostGitRepos(ctx context.Context) GitAPIPostGitReposRequest {
return GitAPIPostGitReposRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return GitRepoView
func (a *GitAPIService) PostGitReposExecute(r GitAPIPostGitReposRequest) (*GitRepoView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitRepoView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitRepos")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.gitCreateReq == nil {
return localVarReturnValue, nil, reportError("gitCreateReq is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.gitCreateReq
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostGitReposByNameGcRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
}
func (r GitAPIPostGitReposByNameGcRequest) Execute() (*GitGcOut, *http.Response, error) {
return r.ApiService.PostGitReposByNameGcExecute(r)
}
/*
PostGitReposByNameGc Repacks a repo into one bitmapped pack and rewrites its commit-graph, so the next clone reuses the bitmap instead of walking the whole object graph.
Repacks a repo into one bitmapped pack and rewrites its commit-graph, so
the next clone reuses the bitmap instead of walking the whole object graph.
Idempotent, and safe to interrupt — git swaps both artifacts atomically. It
runs under one pack slot with the same memory bounds as a clone, so it can
block behind heavy pack traffic rather than compete with it. Storage usage is
re-measured afterwards, since a repack reclaims space.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo's org-unique handle, from the :name path segment. A trailing \".git\" is stripped.
@return GitAPIPostGitReposByNameGcRequest
*/
func (a *GitAPIService) PostGitReposByNameGc(ctx context.Context, name string) GitAPIPostGitReposByNameGcRequest {
return GitAPIPostGitReposByNameGcRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitGcOut
func (a *GitAPIService) PostGitReposByNameGcExecute(r GitAPIPostGitReposByNameGcRequest) (*GitGcOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitGcOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitReposByNameGc")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/gc"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostGitReposByNameHomeRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
}
func (r GitAPIPostGitReposByNameHomeRequest) Execute() (*GitRepoView, *http.Response, error) {
return r.ApiService.PostGitReposByNameHomeExecute(r)
}
/*
PostGitReposByNameHome Moves a repository whose history is HERE to the forge (git.hanzo.ai), the one home of a repository no other host holds, and links it there: the repository is made in the org's own namespace on the forge, every branch and tag is pushed to it, the forge's refs are read back and must equal these, and only then does the row name the forge as its link, so this copy becomes the cache it can be fetched back into.
Moves a repository whose history is HERE to the forge (git.hanzo.ai),
the one home of a repository no other host holds, and links it there: the
repository is made in the org's own namespace on the forge, every branch and
tag is pushed to it, the forge's refs are read back and must equal these, and
only then does the row name the forge as its link, so this copy becomes the
cache it can be fetched back into. A forge repository of that name that
already exists is refused, never overwritten. Org admins only.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repository, from the :name path segment.
@return GitAPIPostGitReposByNameHomeRequest
*/
func (a *GitAPIService) PostGitReposByNameHome(ctx context.Context, name string) GitAPIPostGitReposByNameHomeRequest {
return GitAPIPostGitReposByNameHomeRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitRepoView
func (a *GitAPIService) PostGitReposByNameHomeExecute(r GitAPIPostGitReposByNameHomeRequest) (*GitRepoView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitRepoView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitReposByNameHome")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/home"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostGitReposByNameLinkRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
gitLinkReq *GitLinkReq
}
func (r GitAPIPostGitReposByNameLinkRequest) GitLinkReq(gitLinkReq GitLinkReq) GitAPIPostGitReposByNameLinkRequest {
r.gitLinkReq = &gitLinkReq
return r
}
func (r GitAPIPostGitReposByNameLinkRequest) Execute() (*GitRepoView, *http.Response, error) {
return r.ApiService.PostGitReposByNameLinkExecute(r)
}
/*
PostGitReposByNameLink Records that a repository's history lives on another host, making the repository first when the org has none of that name.
Records that a repository's history lives on another host, making
the repository first when the org has none of that name. Nothing is copied:
a read is served from a cache filled from the host, as the host lets the
caller read, and a push goes to the host. A repository whose history is HERE
is refused (409): a link would hide what only this store holds.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repository, from the :name path segment. It is made when the org has none of that name.
@return GitAPIPostGitReposByNameLinkRequest
*/
func (a *GitAPIService) PostGitReposByNameLink(ctx context.Context, name string) GitAPIPostGitReposByNameLinkRequest {
return GitAPIPostGitReposByNameLinkRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitRepoView
func (a *GitAPIService) PostGitReposByNameLinkExecute(r GitAPIPostGitReposByNameLinkRequest) (*GitRepoView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitRepoView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitReposByNameLink")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/link"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.gitLinkReq == nil {
return localVarReturnValue, nil, reportError("gitLinkReq is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.gitLinkReq
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostGitReposByNamePullsRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
gitOpenReq *GitOpenReq
}
func (r GitAPIPostGitReposByNamePullsRequest) GitOpenReq(gitOpenReq GitOpenReq) GitAPIPostGitReposByNamePullsRequest {
r.gitOpenReq = &gitOpenReq
return r
}
func (r GitAPIPostGitReposByNamePullsRequest) Execute() (*GitPullView, *http.Response, error) {
return r.ApiService.PostGitReposByNamePullsExecute(r)
}
/*
PostGitReposByNamePulls Proposes a branch for merging and returns it with its number.
Proposes a branch for merging and returns it with its number. Answers
201. Both branches must already exist — a proposal naming a branch nobody
pushed is a typo, not a plan — and base defaults to the repo's default branch.
Proposing the same head into the same base twice is a 409 while the first
proposal is still open, so a retried agent run leaves ONE thing to review
rather than a pile of identical ones. A repo outside the caller's scope is a
404, exactly as reading it is.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo the proposal belongs to, from the :name path segment.
@return GitAPIPostGitReposByNamePullsRequest
*/
func (a *GitAPIService) PostGitReposByNamePulls(ctx context.Context, name string) GitAPIPostGitReposByNamePullsRequest {
return GitAPIPostGitReposByNamePullsRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitPullView
func (a *GitAPIService) PostGitReposByNamePullsExecute(r GitAPIPostGitReposByNamePullsRequest) (*GitPullView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitPullView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitReposByNamePulls")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/pulls"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.gitOpenReq == nil {
return localVarReturnValue, nil, reportError("gitOpenReq is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.gitOpenReq
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostGitReposByNamePullsByNumberMergeRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
number int64
}
func (r GitAPIPostGitReposByNamePullsByNumberMergeRequest) Execute() (*GitPullView, *http.Response, error) {
return r.ApiService.PostGitReposByNamePullsByNumberMergeExecute(r)
}
/*
PostGitReposByNamePullsByNumberMerge Merges an open pull request by FAST-FORWARDING base to head, and answers the proposal in its merged state with the revision base now points at.
Merges an open pull request by FAST-FORWARDING base to head, and
answers the proposal in its merged state with the revision base now points at.
It merges only when base is already an ancestor of head — the case where head
contains every commit base has, so moving the branch loses nothing and invents
nothing. When base has moved on independently, this REFUSES with 409 and says
so: a real three-way merge is not implemented here, and reporting one would
claim a result these bytes do not produce. Rebase head onto base and merge
again.
The move is judged by the same ref policy a `git push` of it would face, and
fires the same build and notify reactions, so merging is not a way around
either. Merging an already-merged proposal is a 409.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo, from the :name path segment.
@param number Number is the proposal's per-repo number, from the :number path segment.
@return GitAPIPostGitReposByNamePullsByNumberMergeRequest
*/
func (a *GitAPIService) PostGitReposByNamePullsByNumberMerge(ctx context.Context, name string, number int64) GitAPIPostGitReposByNamePullsByNumberMergeRequest {
return GitAPIPostGitReposByNamePullsByNumberMergeRequest{
ApiService: a,
ctx: ctx,
name: name,
number: number,
}
}
// Execute executes the request
//
// @return GitPullView
func (a *GitAPIService) PostGitReposByNamePullsByNumberMergeExecute(r GitAPIPostGitReposByNamePullsByNumberMergeRequest) (*GitPullView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitPullView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitReposByNamePullsByNumberMerge")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/pulls/{number}/merge"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"number"+"}", url.PathEscape(parameterValueToString(r.number, "number")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostGitReposByNamePushRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
gitPushReq *GitPushReq
}
func (r GitAPIPostGitReposByNamePushRequest) GitPushReq(gitPushReq GitPushReq) GitAPIPostGitReposByNamePushRequest {
r.gitPushReq = &gitPushReq
return r
}
func (r GitAPIPostGitReposByNamePushRequest) Execute() (*GitPushResp, *http.Response, error) {
return r.ApiService.PostGitReposByNamePushExecute(r)
}
/*
PostGitReposByNamePush Lands a set of files as one commit without a git client — the hanzo.app builder's push.
Lands a set of files as one commit without a git client — the
hanzo.app builder's push. The repo is CREATED on first push, the files are
merged onto the branch tip (unlisted files survive), and the same
push-to-deploy hook a real receive-pack fires is fired, so downstream this is
indistinguishable from a `git push`.
It is for generated content. Changing CI through it needs an org admin (403
otherwise), and a workflow whose newest change came in through it is not run
automatically; CI written through git runs as usual.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo to push into, from the :name path segment. It is CREATED on first push if it does not exist.
@return GitAPIPostGitReposByNamePushRequest
*/
func (a *GitAPIService) PostGitReposByNamePush(ctx context.Context, name string) GitAPIPostGitReposByNamePushRequest {
return GitAPIPostGitReposByNamePushRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitPushResp
func (a *GitAPIService) PostGitReposByNamePushExecute(r GitAPIPostGitReposByNamePushRequest) (*GitPushResp, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitPushResp
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitReposByNamePush")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/push"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.gitPushReq == nil {
return localVarReturnValue, nil, reportError("gitPushReq is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.gitPushReq
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostGitReposByNameSubscriptionsRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
gitSubscribeReq *GitSubscribeReq
}
func (r GitAPIPostGitReposByNameSubscriptionsRequest) GitSubscribeReq(gitSubscribeReq GitSubscribeReq) GitAPIPostGitReposByNameSubscriptionsRequest {
r.gitSubscribeReq = &gitSubscribeReq
return r
}
func (r GitAPIPostGitReposByNameSubscriptionsRequest) Execute() (*GitSubscriptionView, *http.Response, error) {
return r.ApiService.PostGitReposByNameSubscriptionsExecute(r)
}
/*
PostGitReposByNameSubscriptions Binds a Slack channel to a repo, so the lifecycle notifier posts that repo's push and deploy events there.
Binds a Slack channel to a repo, so the lifecycle notifier posts
that repo's push and deploy events there. Answers 201. The same channel twice
on one repo is a 409; a repo outside the caller's scope is a 404, exactly as
reading it is.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo to subscribe, from the :name path segment.
@return GitAPIPostGitReposByNameSubscriptionsRequest
*/
func (a *GitAPIService) PostGitReposByNameSubscriptions(ctx context.Context, name string) GitAPIPostGitReposByNameSubscriptionsRequest {
return GitAPIPostGitReposByNameSubscriptionsRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitSubscriptionView
func (a *GitAPIService) PostGitReposByNameSubscriptionsExecute(r GitAPIPostGitReposByNameSubscriptionsRequest) (*GitSubscriptionView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitSubscriptionView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitReposByNameSubscriptions")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/subscriptions"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.gitSubscribeReq == nil {
return localVarReturnValue, nil, reportError("gitSubscribeReq is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.gitSubscribeReq
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostGitReposByNameTargetsRequest struct {
ctx context.Context
ApiService *GitAPIService
name string
gitMirrorTargetReq *GitMirrorTargetReq
}
func (r GitAPIPostGitReposByNameTargetsRequest) GitMirrorTargetReq(gitMirrorTargetReq GitMirrorTargetReq) GitAPIPostGitReposByNameTargetsRequest {
r.gitMirrorTargetReq = &gitMirrorTargetReq
return r
}
func (r GitAPIPostGitReposByNameTargetsRequest) Execute() (*GitMirrorTargetView, *http.Response, error) {
return r.ApiService.PostGitReposByNameTargetsExecute(r)
}
/*
PostGitReposByNameTargets Registers a downstream remote the repo's advanced refs are pushed to whenever a push lands here.
Registers a downstream remote the repo's advanced refs are pushed to
whenever a push lands here. Answers 201. The URL must be https to a host on the
mirror allowlist (github.com / gitlab.com): the same set the mirror credential
may be sent to, so a target can never capture the shared token or point the push
at an internal service. Any embedded userinfo is stripped — credentials ride
env-only at push time and never enter the stored URL. One mirror per host per
repo; a second is a 409.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name is the repo whose advanced refs are pushed downstream, from the :name path segment.
@return GitAPIPostGitReposByNameTargetsRequest
*/
func (a *GitAPIService) PostGitReposByNameTargets(ctx context.Context, name string) GitAPIPostGitReposByNameTargetsRequest {
return GitAPIPostGitReposByNameTargetsRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return GitMirrorTargetView
func (a *GitAPIService) PostGitReposByNameTargetsExecute(r GitAPIPostGitReposByNameTargetsRequest) (*GitMirrorTargetView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitMirrorTargetView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitReposByNameTargets")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/repos/{name}/targets"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.gitMirrorTargetReq == nil {
return localVarReturnValue, nil, reportError("gitMirrorTargetReq is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.gitMirrorTargetReq
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostGitRunsRequest struct {
ctx context.Context
ApiService *GitAPIService
gitRunStart *GitRunStart
}
func (r GitAPIPostGitRunsRequest) GitRunStart(gitRunStart GitRunStart) GitAPIPostGitRunsRequest {
r.gitRunStart = &gitRunStart
return r
}
func (r GitAPIPostGitRunsRequest) Execute() (*GitWorkflowRuns, *http.Response, error) {
return r.ApiService.PostGitRunsExecute(r)
}
/*
PostGitRuns Runs a repository's workflows at a ref, on demand.
Runs a repository's workflows at a ref, on demand.
It takes the SAME path a push takes: the request is recorded in the journal
and delivered from there, so an explicit run and a pushed one are one
mechanism with one idempotency rule and not two that can disagree. Asking
twice for the same commit yields the same run.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIPostGitRunsRequest
*/
func (a *GitAPIService) PostGitRuns(ctx context.Context) GitAPIPostGitRunsRequest {
return GitAPIPostGitRunsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return GitWorkflowRuns
func (a *GitAPIService) PostGitRunsExecute(r GitAPIPostGitRunsRequest) (*GitWorkflowRuns, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitWorkflowRuns
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitRuns")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/runs"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.gitRunStart == nil {
return localVarReturnValue, nil, reportError("gitRunStart is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.gitRunStart
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostGitWebhookRequest struct {
ctx context.Context
ApiService *GitAPIService
}
func (r GitAPIPostGitWebhookRequest) Execute() (*http.Response, error) {
return r.ApiService.PostGitWebhookExecute(r)
}
/*
PostGitWebhook Retired — push-to-deploy has no inbound webhook
GONE (410). Push-to-deploy is not triggered by an inbound webhook. A push into this host's own git server fires the builder in-process, and a repository whose canonical home is GitHub is delivered by the Hanzo Platform GitHub App to POST /v1/provider/github/webhook. The forge does not report a push over HTTP.
Every delivery answers 410 whatever it carries — this endpoint reads no body and authenticates nothing.
410 rather than 404, because the address was real and its meaning moved, which is the distinction 410 carries. A 404 from this estate is ambiguous: Hanzo Git serves /v1, so /api/v1 404s too and reads as "the API is switched off". A retired endpoint says it is retired and names its replacement, so the answer carries its own fix.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIPostGitWebhookRequest
*/
func (a *GitAPIService) PostGitWebhook(ctx context.Context) GitAPIPostGitWebhookRequest {
return GitAPIPostGitWebhookRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *GitAPIService) PostGitWebhookExecute(r GitAPIPostGitWebhookRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitWebhook")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/webhook"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type GitAPIPostGitWorkspaceRequest struct {
ctx context.Context
ApiService *GitAPIService
}
func (r GitAPIPostGitWorkspaceRequest) Execute() (*GitWorkspaceView, *http.Response, error) {
return r.ApiService.PostGitWorkspaceExecute(r)
}
/*
PostGitWorkspace Sets the org's code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller's forge account and seat there.
Sets the org's code workspace up for the caller and answers it:
the namespace, made when the org has none, and the caller's forge account and
seat there. Idempotent. The estate's namespace is answered from the closed
table and nobody is enrolled in it. A seat is a person's: an API key or an
application is refused, and a SuperAdmin acting in another org reads the
workspace as it is and makes nothing.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIPostGitWorkspaceRequest
*/
func (a *GitAPIService) PostGitWorkspace(ctx context.Context) GitAPIPostGitWorkspaceRequest {
return GitAPIPostGitWorkspaceRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return GitWorkspaceView
func (a *GitAPIService) PostGitWorkspaceExecute(r GitAPIPostGitWorkspaceRequest) (*GitWorkspaceView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *GitWorkspaceView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostGitWorkspace")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/git/workspace"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostRunnerDeclareRequest struct {
ctx context.Context
ApiService *GitAPIService
runnerDeclareIn *RunnerDeclareIn
xRunnerUuid *string
xRunnerToken *string
}
func (r GitAPIPostRunnerDeclareRequest) RunnerDeclareIn(runnerDeclareIn RunnerDeclareIn) GitAPIPostRunnerDeclareRequest {
r.runnerDeclareIn = &runnerDeclareIn
return r
}
func (r GitAPIPostRunnerDeclareRequest) XRunnerUuid(xRunnerUuid string) GitAPIPostRunnerDeclareRequest {
r.xRunnerUuid = &xRunnerUuid
return r
}
func (r GitAPIPostRunnerDeclareRequest) XRunnerToken(xRunnerToken string) GitAPIPostRunnerDeclareRequest {
r.xRunnerToken = &xRunnerToken
return r
}
func (r GitAPIPostRunnerDeclareRequest) Execute() (*RunnerDeclareOut, *http.Response, error) {
return r.ApiService.PostRunnerDeclareExecute(r)
}
/*
PostRunnerDeclare Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
Republishes what a registered runner can do, and answers with what
this side understands, so the two learn about each other from one exchange.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIPostRunnerDeclareRequest
*/
func (a *GitAPIService) PostRunnerDeclare(ctx context.Context) GitAPIPostRunnerDeclareRequest {
return GitAPIPostRunnerDeclareRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return RunnerDeclareOut
func (a *GitAPIService) PostRunnerDeclareExecute(r GitAPIPostRunnerDeclareRequest) (*RunnerDeclareOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *RunnerDeclareOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostRunnerDeclare")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/runner/declare"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.runnerDeclareIn == nil {
return localVarReturnValue, nil, reportError("runnerDeclareIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
if r.xRunnerUuid != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "x-runner-uuid", r.xRunnerUuid, "simple", "")
}
if r.xRunnerToken != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "x-runner-token", r.xRunnerToken, "simple", "")
}
// body params
localVarPostBody = r.runnerDeclareIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostRunnerLogRequest struct {
ctx context.Context
ApiService *GitAPIService
runnerLogIn *RunnerLogIn
xRunnerUuid *string
xRunnerToken *string
}
func (r GitAPIPostRunnerLogRequest) RunnerLogIn(runnerLogIn RunnerLogIn) GitAPIPostRunnerLogRequest {
r.runnerLogIn = &runnerLogIn
return r
}
func (r GitAPIPostRunnerLogRequest) XRunnerUuid(xRunnerUuid string) GitAPIPostRunnerLogRequest {
r.xRunnerUuid = &xRunnerUuid
return r
}
func (r GitAPIPostRunnerLogRequest) XRunnerToken(xRunnerToken string) GitAPIPostRunnerLogRequest {
r.xRunnerToken = &xRunnerToken
return r
}
func (r GitAPIPostRunnerLogRequest) Execute() (*RunnerLogOut, *http.Response, error) {
return r.ApiService.PostRunnerLogExecute(r)
}
/*
PostRunnerLog Adds console output to a task's log and answers with how far that log is durable, so the runner knows where to resend from.
Adds console output to a task's log and answers with how far that log is
durable, so the runner knows where to resend from.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIPostRunnerLogRequest
*/
func (a *GitAPIService) PostRunnerLog(ctx context.Context) GitAPIPostRunnerLogRequest {
return GitAPIPostRunnerLogRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return RunnerLogOut
func (a *GitAPIService) PostRunnerLogExecute(r GitAPIPostRunnerLogRequest) (*RunnerLogOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *RunnerLogOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostRunnerLog")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/runner/log"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.runnerLogIn == nil {
return localVarReturnValue, nil, reportError("runnerLogIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
if r.xRunnerUuid != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "x-runner-uuid", r.xRunnerUuid, "simple", "")
}
if r.xRunnerToken != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "x-runner-token", r.xRunnerToken, "simple", "")
}
// body params
localVarPostBody = r.runnerLogIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostRunnerRegisterRequest struct {
ctx context.Context
ApiService *GitAPIService
runnerRegisterIn *RunnerRegisterIn
}
func (r GitAPIPostRunnerRegisterRequest) RunnerRegisterIn(runnerRegisterIn RunnerRegisterIn) GitAPIPostRunnerRegisterRequest {
r.runnerRegisterIn = &runnerRegisterIn
return r
}
func (r GitAPIPostRunnerRegisterRequest) Execute() (*RunnerRegisterOut, *http.Response, error) {
return r.ApiService.PostRunnerRegisterExecute(r)
}
/*
PostRunnerRegister Trades a pool's join secret for a runner identity and the token that authenticates every later call.
Trades a pool's join secret for a runner identity and the token that
authenticates every later call. It is the one operation with no credential to
check, because a runner has none until this answers.
The secret names the pool it opens, and a pool exists only because somebody
declared it. A daemon that starts against capacity nobody declared is refused
here, which is where the rule that pools are declared state actually holds.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIPostRunnerRegisterRequest
*/
func (a *GitAPIService) PostRunnerRegister(ctx context.Context) GitAPIPostRunnerRegisterRequest {
return GitAPIPostRunnerRegisterRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return RunnerRegisterOut
func (a *GitAPIService) PostRunnerRegisterExecute(r GitAPIPostRunnerRegisterRequest) (*RunnerRegisterOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *RunnerRegisterOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostRunnerRegister")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/runner/register"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.runnerRegisterIn == nil {
return localVarReturnValue, nil, reportError("runnerRegisterIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.runnerRegisterIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostRunnerStateRequest struct {
ctx context.Context
ApiService *GitAPIService
runnerStateIn *RunnerStateIn
xRunnerUuid *string
xRunnerToken *string
}
func (r GitAPIPostRunnerStateRequest) RunnerStateIn(runnerStateIn RunnerStateIn) GitAPIPostRunnerStateRequest {
r.runnerStateIn = &runnerStateIn
return r
}
func (r GitAPIPostRunnerStateRequest) XRunnerUuid(xRunnerUuid string) GitAPIPostRunnerStateRequest {
r.xRunnerUuid = &xRunnerUuid
return r
}
func (r GitAPIPostRunnerStateRequest) XRunnerToken(xRunnerToken string) GitAPIPostRunnerStateRequest {
r.xRunnerToken = &xRunnerToken
return r
}
func (r GitAPIPostRunnerStateRequest) Execute() (*RunnerStateOut, *http.Response, error) {
return r.ApiService.PostRunnerStateExecute(r)
}
/*
PostRunnerState Records a task's progress and that of its steps, and answers with the result this side now holds — which is how a runner learns its task was stopped from somewhere else.
Records a task's progress and that of its steps, and answers with the
result this side now holds — which is how a runner learns its task was stopped
from somewhere else.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIPostRunnerStateRequest
*/
func (a *GitAPIService) PostRunnerState(ctx context.Context) GitAPIPostRunnerStateRequest {
return GitAPIPostRunnerStateRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return RunnerStateOut
func (a *GitAPIService) PostRunnerStateExecute(r GitAPIPostRunnerStateRequest) (*RunnerStateOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *RunnerStateOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostRunnerState")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/runner/state"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.runnerStateIn == nil {
return localVarReturnValue, nil, reportError("runnerStateIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
if r.xRunnerUuid != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "x-runner-uuid", r.xRunnerUuid, "simple", "")
}
if r.xRunnerToken != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "x-runner-token", r.xRunnerToken, "simple", "")
}
// body params
localVarPostBody = r.runnerStateIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type GitAPIPostRunnerTaskRequest struct {
ctx context.Context
ApiService *GitAPIService
runnerTaskIn *RunnerTaskIn
xRunnerUuid *string
xRunnerToken *string
}
func (r GitAPIPostRunnerTaskRequest) RunnerTaskIn(runnerTaskIn RunnerTaskIn) GitAPIPostRunnerTaskRequest {
r.runnerTaskIn = &runnerTaskIn
return r
}
func (r GitAPIPostRunnerTaskRequest) XRunnerUuid(xRunnerUuid string) GitAPIPostRunnerTaskRequest {
r.xRunnerUuid = &xRunnerUuid
return r
}
func (r GitAPIPostRunnerTaskRequest) XRunnerToken(xRunnerToken string) GitAPIPostRunnerTaskRequest {
r.xRunnerToken = &xRunnerToken
return r
}
func (r GitAPIPostRunnerTaskRequest) Execute() (*RunnerTaskOut, *http.Response, error) {
return r.ApiService.PostRunnerTaskExecute(r)
}
/*
PostRunnerTask Hands the runner a job to execute, if its pool has one, and answers immediately either way.
Hands the runner a job to execute, if its pool has one, and answers
immediately either way. A runner sends the queue version it last saw; when it
matches, nothing has been queued since and no lease transaction is opened.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return GitAPIPostRunnerTaskRequest
*/
func (a *GitAPIService) PostRunnerTask(ctx context.Context) GitAPIPostRunnerTaskRequest {
return GitAPIPostRunnerTaskRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return RunnerTaskOut
func (a *GitAPIService) PostRunnerTaskExecute(r GitAPIPostRunnerTaskRequest) (*RunnerTaskOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *RunnerTaskOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "GitAPIService.PostRunnerTask")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/runner/task"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.runnerTaskIn == nil {
return localVarReturnValue, nil, reportError("runnerTaskIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
if r.xRunnerUuid != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "x-runner-uuid", r.xRunnerUuid, "simple", "")
}
if r.xRunnerToken != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "x-runner-token", r.xRunnerToken, "simple", "")
}
// body params
localVarPostBody = r.runnerTaskIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}