mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
8906 lines
335 KiB
Go
8906 lines
335 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"
|
||
"strings"
|
||
)
|
||
|
||
// ProviderAPIService ProviderAPI service
|
||
type ProviderAPIService service
|
||
|
||
type ProviderAPIDeleteConnectionByIdRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
id string
|
||
}
|
||
|
||
func (r ProviderAPIDeleteConnectionByIdRequest) Execute() (*ProviderDisconnectOut, *http.Response, error) {
|
||
return r.ApiService.DeleteConnectionByIdExecute(r)
|
||
}
|
||
|
||
/*
|
||
DeleteConnectionById Forgets a connector: every custodied secret, then the row.
|
||
|
||
Forgets a connector: every custodied secret, then the row.
|
||
Idempotent — dropping a never-connected id still answers {disconnected:true}
|
||
(disconnect() parity). No provider Revoke: none of the user-plane providers
|
||
exposes a revoke endpoint.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param id ID is the connector id, provider + \":\" + label (\"openai:default\") — the auth-profile-id shape. Another user's id is simply no row, so 404.
|
||
@return ProviderAPIDeleteConnectionByIdRequest
|
||
*/
|
||
func (a *ProviderAPIService) DeleteConnectionById(ctx context.Context, id string) ProviderAPIDeleteConnectionByIdRequest {
|
||
return ProviderAPIDeleteConnectionByIdRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
id: id,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderDisconnectOut
|
||
func (a *ProviderAPIService) DeleteConnectionByIdExecute(r ProviderAPIDeleteConnectionByIdRequest) (*ProviderDisconnectOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodDelete
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderDisconnectOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.DeleteConnectionById")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/connection/{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 ProviderAPIDeleteProviderGithubReposByRepoPagesRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
repo string
|
||
}
|
||
|
||
func (r ProviderAPIDeleteProviderGithubReposByRepoPagesRequest) Execute() (*ProviderGithubPagesDisabledOut, *http.Response, error) {
|
||
return r.ApiService.DeleteProviderGithubReposByRepoPagesExecute(r)
|
||
}
|
||
|
||
/*
|
||
DeleteProviderGithubReposByRepoPages Deletes the repo's Pages site.
|
||
|
||
Deletes the repo's Pages site. 404 when there is none, so a
|
||
caller can tell "turned it off" from "there was nothing on".
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param repo Repo is the repository's short name within the org's installation, with no owner prefix (the owner is server-derived from the grant). A trailing \".git\" is stripped.
|
||
@return ProviderAPIDeleteProviderGithubReposByRepoPagesRequest
|
||
*/
|
||
func (a *ProviderAPIService) DeleteProviderGithubReposByRepoPages(ctx context.Context, repo string) ProviderAPIDeleteProviderGithubReposByRepoPagesRequest {
|
||
return ProviderAPIDeleteProviderGithubReposByRepoPagesRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
repo: repo,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubPagesDisabledOut
|
||
func (a *ProviderAPIService) DeleteProviderGithubReposByRepoPagesExecute(r ProviderAPIDeleteProviderGithubReposByRepoPagesRequest) (*ProviderGithubPagesDisabledOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodDelete
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubPagesDisabledOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.DeleteProviderGithubReposByRepoPages")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/repos/{repo}/pages"
|
||
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{"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 ProviderAPIDeleteProviderSlackMessagesRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
channel *string
|
||
ts *string
|
||
}
|
||
|
||
func (r ProviderAPIDeleteProviderSlackMessagesRequest) Channel(channel string) ProviderAPIDeleteProviderSlackMessagesRequest {
|
||
r.channel = &channel
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIDeleteProviderSlackMessagesRequest) Ts(ts string) ProviderAPIDeleteProviderSlackMessagesRequest {
|
||
r.ts = &ts
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIDeleteProviderSlackMessagesRequest) Execute() (*ProviderSlackDeleteMessageOut, *http.Response, error) {
|
||
return r.ApiService.DeleteProviderSlackMessagesExecute(r)
|
||
}
|
||
|
||
/*
|
||
DeleteProviderSlackMessages Takes back one of this app's messages: DELETE /v1/provider/slack/messages.
|
||
|
||
Takes back one of this app's messages:
|
||
DELETE /v1/provider/slack/messages.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIDeleteProviderSlackMessagesRequest
|
||
*/
|
||
func (a *ProviderAPIService) DeleteProviderSlackMessages(ctx context.Context) ProviderAPIDeleteProviderSlackMessagesRequest {
|
||
return ProviderAPIDeleteProviderSlackMessagesRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderSlackDeleteMessageOut
|
||
func (a *ProviderAPIService) DeleteProviderSlackMessagesExecute(r ProviderAPIDeleteProviderSlackMessagesRequest) (*ProviderSlackDeleteMessageOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodDelete
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderSlackDeleteMessageOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.DeleteProviderSlackMessages")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/slack/messages"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
if r.channel != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "channel", r.channel, "form", "")
|
||
}
|
||
if r.ts != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "ts", r.ts, "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 ProviderAPIGetConnectionRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetConnectionRequest) Execute() (*ProviderConnectionsOut, *http.Response, error) {
|
||
return r.ApiService.GetConnectionExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetConnection Lists the caller's OWN connectors across every provider — the set `hanzo connector ls` prints.
|
||
|
||
Lists the caller's OWN connectors across every provider — the set
|
||
`hanzo connector ls` prints. Rows are keyed (org,user), so this can never
|
||
surface another user's connector, and no secret is in the view.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetConnectionRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetConnection(ctx context.Context) ProviderAPIGetConnectionRequest {
|
||
return ProviderAPIGetConnectionRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderConnectionsOut
|
||
func (a *ProviderAPIService) GetConnectionExecute(r ProviderAPIGetConnectionRequest) (*ProviderConnectionsOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderConnectionsOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetConnection")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/connection"
|
||
|
||
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 ProviderAPIGetConnectionByIdTokenRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
id string
|
||
}
|
||
|
||
func (r ProviderAPIGetConnectionByIdTokenRequest) Execute() (*ProviderTokenOut, *http.Response, error) {
|
||
return r.ApiService.GetConnectionByIdTokenExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetConnectionByIdToken Hands the custodied access token to its owner — the ONE place custody exits.
|
||
|
||
Hands the custodied access token to its owner — the ONE place
|
||
custody exits. The (org,user)-keyed row IS the same-user gate: another user's
|
||
id is simply "no row" → 404. fresh() auto-rotates within the refreshSkew
|
||
window; static providers degenerate to a plain kmsGet of Secrets[0]. Refresh
|
||
tokens are NEVER returned — custody keeps the sink. The token is never logged.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param id ID is the connector id, provider + \":\" + label (\"openai:default\") — the auth-profile-id shape. Another user's id is simply no row, so 404.
|
||
@return ProviderAPIGetConnectionByIdTokenRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetConnectionByIdToken(ctx context.Context, id string) ProviderAPIGetConnectionByIdTokenRequest {
|
||
return ProviderAPIGetConnectionByIdTokenRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
id: id,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderTokenOut
|
||
func (a *ProviderAPIService) GetConnectionByIdTokenExecute(r ProviderAPIGetConnectionByIdTokenRequest) (*ProviderTokenOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderTokenOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetConnectionByIdToken")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/connection/{id}/token"
|
||
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 ProviderAPIGetConnectionProvidersRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetConnectionProvidersRequest) Execute() (*ProviderUserCatalogOut, *http.Response, error) {
|
||
return r.ApiService.GetConnectionProvidersExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetConnectionProviders Lists the USER-plane provider cards.
|
||
|
||
Lists the USER-plane provider cards. It is not the org
|
||
catalog at /v1/provider and the two are not a duplicate of one another: a
|
||
provider declares its custody plane, and the planes are disjoint, so a
|
||
user-scoped provider 404s on the org surface and vice versa. Hence the
|
||
catalog of what a
|
||
user can connect, and how. Modes derive from capabilities (Device/Adopt/Verify
|
||
— Mount asserts at least one), never from a parallel kind enum.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetConnectionProvidersRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetConnectionProviders(ctx context.Context) ProviderAPIGetConnectionProvidersRequest {
|
||
return ProviderAPIGetConnectionProvidersRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderUserCatalogOut
|
||
func (a *ProviderAPIService) GetConnectionProvidersExecute(r ProviderAPIGetConnectionProvidersRequest) (*ProviderUserCatalogOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderUserCatalogOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetConnectionProviders")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/connection/providers"
|
||
|
||
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 ProviderAPIGetProviderRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderRequest) Execute() (*ProviderListOut, *http.Response, error) {
|
||
return r.ApiService.GetProviderExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProvider Returns every registered integration provider together with THIS org's connection status for it — the catalog the console's Integrations page renders.
|
||
|
||
Returns every registered integration provider together with THIS org's
|
||
connection status for it — the catalog the console's Integrations page renders.
|
||
Org-authed: a caller with no validated principal is 403, because the status is
|
||
per-org and there is no org-less answer. User-plane providers (the /v1/connection
|
||
surface) are omitted; the two planes are disjoint.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProvider(ctx context.Context) ProviderAPIGetProviderRequest {
|
||
return ProviderAPIGetProviderRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderListOut
|
||
func (a *ProviderAPIService) GetProviderExecute(r ProviderAPIGetProviderRequest) (*ProviderListOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderListOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProvider")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider"
|
||
|
||
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 ProviderAPIGetProviderByProviderRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
provider string
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderByProviderRequest) Execute() (*ProviderProviderView, *http.Response, error) {
|
||
return r.ApiService.GetProviderByProviderExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderByProvider Returns ONE provider with this org's connection status — the same view list carries, for a single id.
|
||
|
||
Returns ONE provider with this org's connection status — the same view list
|
||
carries, for a single id. An unknown id is 404, and so is a user-plane provider:
|
||
the org surface never resolves one.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param provider Provider is the registry id of the connector — \"slack\", \"github\", \"cloudflare\". Unknown ids are 404, as are the user-plane (/v1/connection) providers, which this surface never resolves.
|
||
@return ProviderAPIGetProviderByProviderRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderByProvider(ctx context.Context, provider string) ProviderAPIGetProviderByProviderRequest {
|
||
return ProviderAPIGetProviderByProviderRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
provider: provider,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderProviderView
|
||
func (a *ProviderAPIService) GetProviderByProviderExecute(r ProviderAPIGetProviderByProviderRequest) (*ProviderProviderView, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderProviderView
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderByProvider")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/{provider}"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -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 ProviderAPIGetProviderByProviderCallbackRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
provider string
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderByProviderCallbackRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderByProviderCallbackExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderByProviderCallback OAuth return for any connector
|
||
|
||
The single address every connector's OAuth flow returns to. It exchanges the authorization the provider granted, records the connection, and ALWAYS redirects the browser back to the console — on success and on every labeled failure alike, so a user never lands on a raw JSON dead end.
|
||
|
||
It is public and carries no principal, so the org is taken ONLY from the signed state minted when the flow began; no header is trusted here. That state is single-use and is burned BEFORE the exchange, so one authorization is one attempt and a replayed return fails instead of exchanging twice.
|
||
|
||
Tokens are sealed into the org's KMS namespace BEFORE the connection row is written, so a failure of the secret store leaves no half-connected integration advertising a credential that was never stored. Token values never appear in the redirect, in a log line or in an error.
|
||
|
||
One generalization is worth knowing: a GitHub App installation returns an installation identifier instead of an OAuth code, and it is accepted in the code's place so the App model needs no second address.
|
||
|
||
A GitHub connect that returns from GitHub's authorization page, rather than its install page, answers a short page instead of a redirect when the person already controls installations no organization holds: they choose which one to connect, or go on to install the app on another account. Nothing is bound until they choose.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param provider
|
||
@return ProviderAPIGetProviderByProviderCallbackRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderByProviderCallback(ctx context.Context, provider string) ProviderAPIGetProviderByProviderCallbackRequest {
|
||
return ProviderAPIGetProviderByProviderCallbackRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
provider: provider,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderByProviderCallbackExecute(r ProviderAPIGetProviderByProviderCallbackRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderByProviderCallback")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/{provider}/callback"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -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 ProviderAPIGetProviderByProviderLogoRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
provider string
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderByProviderLogoRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderByProviderLogoExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderByProviderLogo Serves a connector's logo from the catalog.
|
||
|
||
Serves a connector's logo from the catalog. PUBLIC: an <img> carries no
|
||
bearer, and a logo is not the org's. It is served from the embedded catalog
|
||
only, never fetched, with a policy that runs nothing — an SVG opened directly
|
||
is a picture, not a page.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param provider
|
||
@return ProviderAPIGetProviderByProviderLogoRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderByProviderLogo(ctx context.Context, provider string) ProviderAPIGetProviderByProviderLogoRequest {
|
||
return ProviderAPIGetProviderByProviderLogoRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
provider: provider,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderByProviderLogoExecute(r ProviderAPIGetProviderByProviderLogoRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderByProviderLogo")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/{provider}/logo"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -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 ProviderAPIGetProviderDiscordLinkRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderDiscordLinkRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderDiscordLinkExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderDiscordLink Begin linking a Hanzo account from Discord
|
||
|
||
The entry point behind the connect prompt Hanzo shows in a Discord server. It starts a link session and redirects to Discord's OAuth `identify` consent — the narrowest scope that establishes which Discord user is asking, and nothing more.
|
||
|
||
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderDiscordLinkRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderDiscordLink(ctx context.Context) ProviderAPIGetProviderDiscordLinkRequest {
|
||
return ProviderAPIGetProviderDiscordLinkRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderDiscordLinkExecute(r ProviderAPIGetProviderDiscordLinkRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderDiscordLink")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/discord/link"
|
||
|
||
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 ProviderAPIGetProviderDiscordLinkCallbackRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderDiscordLinkCallbackRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderDiscordLinkCallbackExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderDiscordLinkCallback Complete the Discord account link
|
||
|
||
The final leg: it binds the verified Discord user to the Hanzo account that just signed in, and answers a short confirmation page telling them to return to Discord. The Hanzo credential is sealed into the connected org's KMS namespace rather than stored beside the link.
|
||
|
||
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderDiscordLinkCallbackRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderDiscordLinkCallback(ctx context.Context) ProviderAPIGetProviderDiscordLinkCallbackRequest {
|
||
return ProviderAPIGetProviderDiscordLinkCallbackRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderDiscordLinkCallbackExecute(r ProviderAPIGetProviderDiscordLinkCallbackRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderDiscordLinkCallback")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/discord/link/callback"
|
||
|
||
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 ProviderAPIGetProviderDiscordLinkDiscordRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderDiscordLinkDiscordRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderDiscordLinkDiscordExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderDiscordLinkDiscord Discord sign-in return leg
|
||
|
||
Where Discord returns the user after the identify consent. It resolves the verified Discord user, confirms the server is connected to an org, and hands the browser to the Hanzo sign-in that completes the link.
|
||
|
||
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderDiscordLinkDiscordRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderDiscordLinkDiscord(ctx context.Context) ProviderAPIGetProviderDiscordLinkDiscordRequest {
|
||
return ProviderAPIGetProviderDiscordLinkDiscordRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderDiscordLinkDiscordExecute(r ProviderAPIGetProviderDiscordLinkDiscordRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderDiscordLinkDiscord")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/discord/link/discord"
|
||
|
||
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 ProviderAPIGetProviderGithubInstallationsRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderGithubInstallationsRequest) Execute() (*ProviderGithubInstallationsOut, *http.Response, error) {
|
||
return r.ApiService.GetProviderGithubInstallationsExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderGithubInstallations Lists the GitHub accounts the caller may see the App installed on, each confirmed against the App's own list, plus where to add another.
|
||
|
||
Lists the GitHub accounts the caller may see the App
|
||
installed on, each confirmed against the App's own list, plus where to add
|
||
another.
|
||
|
||
The confirmation is the point. A connection row holds an installation id, and
|
||
an id whose installation was since removed on GitHub is a row that mints
|
||
nothing — every list and import against it fails with a token error, which
|
||
reads as "our git integration is broken" rather than "that install is gone".
|
||
Checking the App's view turns that into a fact the caller can act on.
|
||
|
||
ORG-SCOPED for a tenant, deliberately. The App is installed across every
|
||
customer, so the raw list is the customer list; a tenant sees only accounts its
|
||
own org has bound. It discovers a NEW account by installing it (InstallURL),
|
||
which is GitHub's own consent screen — not by reading ours.
|
||
|
||
A SUPER ADMIN sees the App's whole install list, because that list is the
|
||
platform's own inventory rather than any one tenant's data, and platform sudo
|
||
is the single cross-tenant scope this house has. Without it an App installed
|
||
out-of-band — granted straight from GitHub, so no connect flow ever ran and no
|
||
connection row exists — is invisible to everyone: the console card reads "not
|
||
connected" and an operator asked "which GitHub orgs do you see" can only
|
||
answer for accounts already bound, which is precisely the accounts that were
|
||
never the question.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderGithubInstallationsRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderGithubInstallations(ctx context.Context) ProviderAPIGetProviderGithubInstallationsRequest {
|
||
return ProviderAPIGetProviderGithubInstallationsRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubInstallationsOut
|
||
func (a *ProviderAPIService) GetProviderGithubInstallationsExecute(r ProviderAPIGetProviderGithubInstallationsRequest) (*ProviderGithubInstallationsOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubInstallationsOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGithubInstallations")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/installations"
|
||
|
||
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 ProviderAPIGetProviderGithubReposRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
q *string
|
||
owner *string
|
||
limit *int64
|
||
after *string
|
||
}
|
||
|
||
// Q keeps repositories whose owner/name contains it, case-insensitively.
|
||
func (r ProviderAPIGetProviderGithubReposRequest) Q(q string) ProviderAPIGetProviderGithubReposRequest {
|
||
r.q = &q
|
||
return r
|
||
}
|
||
|
||
// Owner keeps one GitHub account's repositories — an org or a user login.
|
||
func (r ProviderAPIGetProviderGithubReposRequest) Owner(owner string) ProviderAPIGetProviderGithubReposRequest {
|
||
r.owner = &owner
|
||
return r
|
||
}
|
||
|
||
// Limit is the page size: 1 to 100, and 50 when absent or unreadable.
|
||
func (r ProviderAPIGetProviderGithubReposRequest) Limit(limit int64) ProviderAPIGetProviderGithubReposRequest {
|
||
r.limit = &limit
|
||
return r
|
||
}
|
||
|
||
// After is the `next` of the previous page. Absent starts at the most recently pushed.
|
||
func (r ProviderAPIGetProviderGithubReposRequest) After(after string) ProviderAPIGetProviderGithubReposRequest {
|
||
r.after = &after
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderGithubReposRequest) Execute() (*ProviderGithubReposOut, *http.Response, error) {
|
||
return r.ApiService.GetProviderGithubReposExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderGithubRepos Lists the GitHub repositories the caller may work on, most recently pushed first, searched and paged on the server.
|
||
|
||
Lists the GitHub repositories the caller may work on, most
|
||
recently pushed first, searched and paged on the server.
|
||
|
||
A person who connected their own GitHub sees what their token reaches in this
|
||
App's installations. An org admin who has not sees every repository in the
|
||
installations their org holds. Anyone else gets an empty page with
|
||
connected:false, which is the console's cue to ask them to connect.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderGithubReposRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderGithubRepos(ctx context.Context) ProviderAPIGetProviderGithubReposRequest {
|
||
return ProviderAPIGetProviderGithubReposRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubReposOut
|
||
func (a *ProviderAPIService) GetProviderGithubReposExecute(r ProviderAPIGetProviderGithubReposRequest) (*ProviderGithubReposOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubReposOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGithubRepos")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/repos"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
if r.q != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "q", r.q, "form", "")
|
||
}
|
||
if r.owner != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "owner", r.owner, "form", "")
|
||
}
|
||
if r.limit != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
||
}
|
||
if r.after != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "after", r.after, "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 ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
owner string
|
||
repo string
|
||
q *string
|
||
limit *int64
|
||
after *string
|
||
}
|
||
|
||
// Q keeps branches whose name starts with it, matched by GitHub.
|
||
func (r ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest) Q(q string) ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest {
|
||
r.q = &q
|
||
return r
|
||
}
|
||
|
||
// Limit is the page size: 1 to 100, and 50 when absent or unreadable.
|
||
func (r ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest) Limit(limit int64) ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest {
|
||
r.limit = &limit
|
||
return r
|
||
}
|
||
|
||
// After is the `next` of the previous page.
|
||
func (r ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest) After(after string) ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest {
|
||
r.after = &after
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest) Execute() (*ProviderGithubBranchesOut, *http.Response, error) {
|
||
return r.ApiService.GetProviderGithubReposByOwnerByRepoBranchesExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderGithubReposByOwnerByRepoBranches Lists a repository's branches, the default first, with prefix search.
|
||
|
||
Lists a repository's branches, the default first, with prefix
|
||
search. The repository must be one the caller may see — the same set
|
||
GET /v1/provider/github/repos lists — or it is 404.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param owner Owner is the GitHub account that holds the repository.
|
||
@param repo Repo is the repository's name within that account.
|
||
@return ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderGithubReposByOwnerByRepoBranches(ctx context.Context, owner string, repo string) ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest {
|
||
return ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
owner: owner,
|
||
repo: repo,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubBranchesOut
|
||
func (a *ProviderAPIService) GetProviderGithubReposByOwnerByRepoBranchesExecute(r ProviderAPIGetProviderGithubReposByOwnerByRepoBranchesRequest) (*ProviderGithubBranchesOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubBranchesOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGithubReposByOwnerByRepoBranches")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/repos/{owner}/{repo}/branches"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
|
||
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
if r.q != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "q", r.q, "form", "")
|
||
}
|
||
if r.limit != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
||
}
|
||
if r.after != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "after", r.after, "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 ProviderAPIGetProviderGithubReposByRepoPagesRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
repo string
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderGithubReposByRepoPagesRequest) Execute() (*ProviderGithubPagesView, *http.Response, error) {
|
||
return r.ApiService.GetProviderGithubReposByRepoPagesExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderGithubReposByRepoPages Returns the repo's Pages status, live URL, custom domain and build source.
|
||
|
||
Returns the repo's Pages status, live URL, custom domain and build
|
||
source. The repo is resolved against the org installation's GRANTED set, so a
|
||
caller can never address a repo the App was not granted; 404 when the repo has no
|
||
Pages site.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param repo Repo is the repository's short name within the org's installation, with no owner prefix (the owner is server-derived from the grant). A trailing \".git\" is stripped.
|
||
@return ProviderAPIGetProviderGithubReposByRepoPagesRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderGithubReposByRepoPages(ctx context.Context, repo string) ProviderAPIGetProviderGithubReposByRepoPagesRequest {
|
||
return ProviderAPIGetProviderGithubReposByRepoPagesRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
repo: repo,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubPagesView
|
||
func (a *ProviderAPIService) GetProviderGithubReposByRepoPagesExecute(r ProviderAPIGetProviderGithubReposByRepoPagesRequest) (*ProviderGithubPagesView, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubPagesView
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGithubReposByRepoPages")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/repos/{repo}/pages"
|
||
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{"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 ProviderAPIGetProviderGithubUserRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderGithubUserRequest) Execute() (*ProviderGithubUserOut, *http.Response, error) {
|
||
return r.ApiService.GetProviderGithubUserExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderGithubUser Reports whether the caller has connected their own GitHub account in the org they act in, and as whom.
|
||
|
||
Reports whether the caller has connected their own GitHub
|
||
account in the org they act in, and as whom.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderGithubUserRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderGithubUser(ctx context.Context) ProviderAPIGetProviderGithubUserRequest {
|
||
return ProviderAPIGetProviderGithubUserRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubUserOut
|
||
func (a *ProviderAPIService) GetProviderGithubUserExecute(r ProviderAPIGetProviderGithubUserRequest) (*ProviderGithubUserOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubUserOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGithubUser")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/user"
|
||
|
||
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 ProviderAPIGetProviderGithubUserCallbackRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderGithubUserCallbackRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderGithubUserCallbackExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderGithubUserCallback Is where GitHub returns the person.
|
||
|
||
Is where GitHub returns the person. It verifies the state,
|
||
burns its nonce, and parks the code for the return page to complete; it
|
||
exchanges nothing. PUBLIC and state-authed, like every OAuth return, and raw because it
|
||
answers a browser with a redirect.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderGithubUserCallbackRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderGithubUserCallback(ctx context.Context) ProviderAPIGetProviderGithubUserCallbackRequest {
|
||
return ProviderAPIGetProviderGithubUserCallbackRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderGithubUserCallbackExecute(r ProviderAPIGetProviderGithubUserCallbackRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGithubUserCallback")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/user/callback"
|
||
|
||
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 ProviderAPIGetProviderGitlabProjectsRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderGitlabProjectsRequest) Execute() (*ProviderGitlabProjectsOut, *http.Response, error) {
|
||
return r.ApiService.GetProviderGitlabProjectsExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderGitlabProjects Lists the projects the org's GitLab connection can reach — membership projects, most recently active first.
|
||
|
||
Lists the projects the org's GitLab connection can reach —
|
||
membership projects, most recently active first.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderGitlabProjectsRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderGitlabProjects(ctx context.Context) ProviderAPIGetProviderGitlabProjectsRequest {
|
||
return ProviderAPIGetProviderGitlabProjectsRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGitlabProjectsOut
|
||
func (a *ProviderAPIService) GetProviderGitlabProjectsExecute(r ProviderAPIGetProviderGitlabProjectsRequest) (*ProviderGitlabProjectsOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGitlabProjectsOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGitlabProjects")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/gitlab/projects"
|
||
|
||
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 ProviderAPIGetProviderGoogleUserRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderGoogleUserRequest) Execute() (*ProviderGoogleUserOut, *http.Response, error) {
|
||
return r.ApiService.GetProviderGoogleUserExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderGoogleUser Reports whether the caller has connected their own Google account in the org they act in, and as whom.
|
||
|
||
Reports whether the caller has connected their own Google
|
||
account in the org they act in, and as whom.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderGoogleUserRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderGoogleUser(ctx context.Context) ProviderAPIGetProviderGoogleUserRequest {
|
||
return ProviderAPIGetProviderGoogleUserRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGoogleUserOut
|
||
func (a *ProviderAPIService) GetProviderGoogleUserExecute(r ProviderAPIGetProviderGoogleUserRequest) (*ProviderGoogleUserOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGoogleUserOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGoogleUser")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/google/user"
|
||
|
||
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 ProviderAPIGetProviderGoogleUserCallbackRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderGoogleUserCallbackRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderGoogleUserCallbackExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderGoogleUserCallback Is where Google returns the person.
|
||
|
||
Is where Google returns the person. It verifies the state,
|
||
burns its nonce, and parks the code for the return page to complete; it
|
||
exchanges nothing. PUBLIC and state-authed, like every OAuth return, and raw
|
||
because it answers a browser with a redirect.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderGoogleUserCallbackRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderGoogleUserCallback(ctx context.Context) ProviderAPIGetProviderGoogleUserCallbackRequest {
|
||
return ProviderAPIGetProviderGoogleUserCallbackRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderGoogleUserCallbackExecute(r ProviderAPIGetProviderGoogleUserCallbackRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderGoogleUserCallback")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/google/user/callback"
|
||
|
||
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 ProviderAPIGetProviderSlackChannelsRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
types *string
|
||
cursor *string
|
||
}
|
||
|
||
// Types selects public_channel, private_channel, im or mpim, comma-separated. Defaults to public_channel; each selected type requires its own read scope.
|
||
func (r ProviderAPIGetProviderSlackChannelsRequest) Types(types string) ProviderAPIGetProviderSlackChannelsRequest {
|
||
r.types = &types
|
||
return r
|
||
}
|
||
|
||
// Cursor continues the previous page's next_cursor.
|
||
func (r ProviderAPIGetProviderSlackChannelsRequest) Cursor(cursor string) ProviderAPIGetProviderSlackChannelsRequest {
|
||
r.cursor = &cursor
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderSlackChannelsRequest) Execute() (*ProviderSlackChannelsOut, *http.Response, error) {
|
||
return r.ApiService.GetProviderSlackChannelsExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderSlackChannels Lists Slack conversations for the caller's connected workspace.
|
||
|
||
Lists Slack conversations for the caller's connected workspace.
|
||
Read next_cursor until empty to discover channels, including private channels
|
||
or group DMs when types requests them and the bot has their read scopes.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderSlackChannelsRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderSlackChannels(ctx context.Context) ProviderAPIGetProviderSlackChannelsRequest {
|
||
return ProviderAPIGetProviderSlackChannelsRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderSlackChannelsOut
|
||
func (a *ProviderAPIService) GetProviderSlackChannelsExecute(r ProviderAPIGetProviderSlackChannelsRequest) (*ProviderSlackChannelsOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderSlackChannelsOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderSlackChannels")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/slack/channels"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
if r.types != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "types", r.types, "form", "")
|
||
}
|
||
if r.cursor != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "cursor", r.cursor, "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 ProviderAPIGetProviderSlackFileRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderSlackFileRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderSlackFileExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderSlackFile Read one Slack file's bytes.
|
||
|
||
Streams the bytes of a file attached to a message in the workspace this organization connected. `id` is the Slack file id a message's `files` carries; the response is the file itself, under the Content-Type Slack recorded for it, never JSON.
|
||
|
||
THE WORKSPACE IS THE CALLER'S. The org comes from the validated identity and never from the request, and it selects the token the read spends, so a caller cannot name a workspace they have not connected. A file that workspace cannot see answers 404 from Slack's own answer rather than from a guess made here, and a file past the size bound is refused by name instead of arriving truncated.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderSlackFileRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderSlackFile(ctx context.Context) ProviderAPIGetProviderSlackFileRequest {
|
||
return ProviderAPIGetProviderSlackFileRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderSlackFileExecute(r ProviderAPIGetProviderSlackFileRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderSlackFile")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/slack/file"
|
||
|
||
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 ProviderAPIGetProviderSlackInstallRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderSlackInstallRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderSlackInstallExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderSlackInstall Install the Hanzo app into a Slack workspace
|
||
|
||
The address behind Slack's "Add to Slack" and Marketplace Install buttons. It answers a 302 to Slack's own consent screen and does nothing else — it is a redirector by design.
|
||
|
||
It exists because Slack refuses a slack.com URL in that field and requires one of ours that redirects there, which makes the field an ATTRIBUTION hook: routing the click through our own address is what lets an install be counted, and always answering the redirect is what keeps the counter from becoming a detour that never reaches consent. The destination is the same consent URL every time, built from the same scopes the console's Connect button asks for, so a workspace is asked to grant one thing however the install began.
|
||
|
||
It is PUBLIC and carries no principal, because whoever clicks Install in Slack's directory has no Hanzo session yet. It binds no org either, and that is deliberate rather than missing: the org is resolved at the shared provider callback, from the signed state a console connect minted or from the workspace's existing connection. Minting an org for an anonymous click is the one thing that would break tenant isolation, so an install begun here finishes under exactly the rules every other install obeys.
|
||
|
||
Where the app is not configured it answers 503, rather than a consent URL carrying an empty client_id that Slack would render as its own dead-end error page.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderSlackInstallRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderSlackInstall(ctx context.Context) ProviderAPIGetProviderSlackInstallRequest {
|
||
return ProviderAPIGetProviderSlackInstallRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderSlackInstallExecute(r ProviderAPIGetProviderSlackInstallRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderSlackInstall")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/slack/install"
|
||
|
||
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 ProviderAPIGetProviderSlackLinkRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderSlackLinkRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderSlackLinkExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderSlackLink Begin linking a Hanzo account from Slack
|
||
|
||
The entry point behind the connect prompt Hanzo posts in Slack. It starts a link session in the browser and redirects to Slack's own sign-in, which is what proves which Slack user is asking.
|
||
|
||
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderSlackLinkRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderSlackLink(ctx context.Context) ProviderAPIGetProviderSlackLinkRequest {
|
||
return ProviderAPIGetProviderSlackLinkRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderSlackLinkExecute(r ProviderAPIGetProviderSlackLinkRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderSlackLink")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/slack/link"
|
||
|
||
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 ProviderAPIGetProviderSlackLinkCallbackRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderSlackLinkCallbackRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderSlackLinkCallbackExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderSlackLinkCallback Complete the Slack account link
|
||
|
||
The final leg: the user has proved both who they are in Slack and who they are in Hanzo, and this binds the two. It answers a short confirmation page telling them to return to Slack.
|
||
|
||
The Hanzo credential obtained here is sealed into the connected workspace's own KMS namespace; it is never written to a database column and never logged. A deployment whose secret store is unavailable refuses the link rather than completing it without custody of the credential.
|
||
|
||
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderSlackLinkCallbackRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderSlackLinkCallback(ctx context.Context) ProviderAPIGetProviderSlackLinkCallbackRequest {
|
||
return ProviderAPIGetProviderSlackLinkCallbackRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderSlackLinkCallbackExecute(r ProviderAPIGetProviderSlackLinkCallbackRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderSlackLinkCallback")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/slack/link/callback"
|
||
|
||
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 ProviderAPIGetProviderSlackLinkSlackRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderSlackLinkSlackRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderSlackLinkSlackExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderSlackLinkSlack Slack sign-in return leg
|
||
|
||
Where Slack returns the user after they sign in. It establishes the verified Slack workspace and user, confirms that workspace is connected to an org, and hands the browser on to the Hanzo sign-in that completes the link.
|
||
|
||
The verified pair is carried onward in a host-bound cookie rather than in the URL, so the identity being linked cannot be edited in transit.
|
||
|
||
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderSlackLinkSlackRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderSlackLinkSlack(ctx context.Context) ProviderAPIGetProviderSlackLinkSlackRequest {
|
||
return ProviderAPIGetProviderSlackLinkSlackRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderSlackLinkSlackExecute(r ProviderAPIGetProviderSlackLinkSlackRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderSlackLinkSlack")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/slack/link/slack"
|
||
|
||
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 ProviderAPIGetProviderSlackMessagesRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
channel *string
|
||
limit *int64
|
||
cursor *string
|
||
threadTs *string
|
||
oldest *string
|
||
latest *string
|
||
}
|
||
|
||
// Channel is a Slack channel ID, name (#hanzo-gtm), or Slack channel mention.
|
||
func (r ProviderAPIGetProviderSlackMessagesRequest) Channel(channel string) ProviderAPIGetProviderSlackMessagesRequest {
|
||
r.channel = &channel
|
||
return r
|
||
}
|
||
|
||
// Limit bounds the page to 1-100 messages; zero defaults to 15.
|
||
func (r ProviderAPIGetProviderSlackMessagesRequest) Limit(limit int64) ProviderAPIGetProviderSlackMessagesRequest {
|
||
r.limit = &limit
|
||
return r
|
||
}
|
||
|
||
// Cursor continues the previous page's next_cursor.
|
||
func (r ProviderAPIGetProviderSlackMessagesRequest) Cursor(cursor string) ProviderAPIGetProviderSlackMessagesRequest {
|
||
r.cursor = &cursor
|
||
return r
|
||
}
|
||
|
||
// ThreadTS reads a thread via conversations.replies. Empty reads recent channel messages via conversations.history, which excludes thread replies.
|
||
func (r ProviderAPIGetProviderSlackMessagesRequest) ThreadTs(threadTs string) ProviderAPIGetProviderSlackMessagesRequest {
|
||
r.threadTs = &threadTs
|
||
return r
|
||
}
|
||
|
||
// Oldest filters to messages after this Slack timestamp (exclusive).
|
||
func (r ProviderAPIGetProviderSlackMessagesRequest) Oldest(oldest string) ProviderAPIGetProviderSlackMessagesRequest {
|
||
r.oldest = &oldest
|
||
return r
|
||
}
|
||
|
||
// Latest filters to messages before this Slack timestamp (exclusive).
|
||
func (r ProviderAPIGetProviderSlackMessagesRequest) Latest(latest string) ProviderAPIGetProviderSlackMessagesRequest {
|
||
r.latest = &latest
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderSlackMessagesRequest) Execute() (*ProviderSlackMessagesOut, *http.Response, error) {
|
||
return r.ApiService.GetProviderSlackMessagesExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderSlackMessages Reads recent messages from a named Slack channel such as #hanzo-gtm.
|
||
|
||
Reads recent messages from a named Slack channel such as
|
||
#hanzo-gtm. The bot must be a member and have the relevant history scope.
|
||
Set thread_ts to fetch a parent's replies, and cursor to continue a page.
|
||
Channel history is newest first; thread replies are oldest first.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderSlackMessagesRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderSlackMessages(ctx context.Context) ProviderAPIGetProviderSlackMessagesRequest {
|
||
return ProviderAPIGetProviderSlackMessagesRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderSlackMessagesOut
|
||
func (a *ProviderAPIService) GetProviderSlackMessagesExecute(r ProviderAPIGetProviderSlackMessagesRequest) (*ProviderSlackMessagesOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderSlackMessagesOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderSlackMessages")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/slack/messages"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
if r.channel != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "channel", r.channel, "form", "")
|
||
}
|
||
if r.limit != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
||
}
|
||
if r.cursor != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "cursor", r.cursor, "form", "")
|
||
}
|
||
if r.threadTs != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "thread_ts", r.threadTs, "form", "")
|
||
}
|
||
if r.oldest != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "oldest", r.oldest, "form", "")
|
||
}
|
||
if r.latest != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "latest", r.latest, "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 ProviderAPIGetProviderTeamsLinkRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderTeamsLinkRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderTeamsLinkExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderTeamsLink Begin linking a Hanzo account from Teams
|
||
|
||
The entry point behind the connect prompt Hanzo shows in Teams. It starts a link session and redirects to Microsoft sign-in addressed to the CHAT'S OWN tenant, not the common endpoint, so only a member of that tenant can complete it.
|
||
|
||
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderTeamsLinkRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderTeamsLink(ctx context.Context) ProviderAPIGetProviderTeamsLinkRequest {
|
||
return ProviderAPIGetProviderTeamsLinkRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderTeamsLinkExecute(r ProviderAPIGetProviderTeamsLinkRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderTeamsLink")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/teams/link"
|
||
|
||
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 ProviderAPIGetProviderTeamsLinkAadRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderTeamsLinkAadRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderTeamsLinkAadExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderTeamsLinkAad Microsoft sign-in return leg
|
||
|
||
Where Microsoft returns the user after sign-in. It resolves the verified directory identity and then re-checks the tenant: the signed-in user's tenant must equal the tenant of the chat the link started from, so a valid Microsoft sign-in from a different organization is refused here rather than accepted.
|
||
|
||
This is the leg Teams has and the other platforms do not, which is why the Teams flow has an extra address.
|
||
|
||
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderTeamsLinkAadRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderTeamsLinkAad(ctx context.Context) ProviderAPIGetProviderTeamsLinkAadRequest {
|
||
return ProviderAPIGetProviderTeamsLinkAadRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderTeamsLinkAadExecute(r ProviderAPIGetProviderTeamsLinkAadRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderTeamsLinkAad")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/teams/link/aad"
|
||
|
||
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 ProviderAPIGetProviderTeamsLinkCallbackRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderTeamsLinkCallbackRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderTeamsLinkCallbackExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderTeamsLinkCallback Complete the Teams account link
|
||
|
||
The final leg: it binds the verified directory identity to the Hanzo account that just signed in, and answers a short confirmation page telling them to return to Teams. The Hanzo credential is sealed into the connected org's KMS namespace.
|
||
|
||
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderTeamsLinkCallbackRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderTeamsLinkCallback(ctx context.Context) ProviderAPIGetProviderTeamsLinkCallbackRequest {
|
||
return ProviderAPIGetProviderTeamsLinkCallbackRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderTeamsLinkCallbackExecute(r ProviderAPIGetProviderTeamsLinkCallbackRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderTeamsLinkCallback")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/teams/link/callback"
|
||
|
||
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 ProviderAPIGetProviderTelegramLinkRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderTelegramLinkRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderTelegramLinkExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderTelegramLink Begin linking a Hanzo account from Telegram
|
||
|
||
The entry point behind the connect prompt Hanzo sends in Telegram. Unlike the other platforms it answers an HTML PAGE rather than a redirect: Telegram has no OAuth flow, so the page hosts Telegram's Login Widget, and the browser is sent onward only after the user signs in through it.
|
||
|
||
The widget only appears on the domain registered for the bot, so a deployment whose bot domain is unset renders a page with nothing on it.
|
||
|
||
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderTelegramLinkRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderTelegramLink(ctx context.Context) ProviderAPIGetProviderTelegramLinkRequest {
|
||
return ProviderAPIGetProviderTelegramLinkRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderTelegramLinkExecute(r ProviderAPIGetProviderTelegramLinkRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderTelegramLink")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/telegram/link"
|
||
|
||
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 ProviderAPIGetProviderTelegramLinkAuthRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderTelegramLinkAuthRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderTelegramLinkAuthExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderTelegramLinkAuth Telegram Login Widget return leg
|
||
|
||
Where Telegram's Login Widget sends the user with its signed authentication data. That data is verified against the bot token — this is the identity source, and it is the widget's signature rather than a code exchange — and the chat is confirmed to be bound to an org before the browser is handed to the Hanzo sign-in.
|
||
|
||
Widget data is only accepted while it is fresh, so a captured sign-in blob cannot be replayed later even though its signature stays valid.
|
||
|
||
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderTelegramLinkAuthRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderTelegramLinkAuth(ctx context.Context) ProviderAPIGetProviderTelegramLinkAuthRequest {
|
||
return ProviderAPIGetProviderTelegramLinkAuthRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderTelegramLinkAuthExecute(r ProviderAPIGetProviderTelegramLinkAuthRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderTelegramLinkAuth")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/telegram/link/auth"
|
||
|
||
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 ProviderAPIGetProviderTelegramLinkCallbackRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderTelegramLinkCallbackRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderTelegramLinkCallbackExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderTelegramLinkCallback Complete the Telegram account link
|
||
|
||
The final leg: it binds the verified Telegram user to the Hanzo account that just signed in, and answers a short confirmation page telling them to return to Telegram. The Hanzo credential is sealed into the connected org's KMS namespace.
|
||
|
||
This is one leg of a three-leg flow, and the legs are not interchangeable: a browser is expected to arrive here only from the leg before it. The link URL's state proves the prompt was server-minted and carries the CHAT it started from — it is provenance only, and it never decides which account gets linked. The account identity always comes from the platform's own verified sign-in and a host-bound cookie, so forwarding a link to someone else cannot bind their account, and a session lifted into another browser is refused rather than completed. Each link is single-use, and a deployment without linking configured answers 503.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderTelegramLinkCallbackRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderTelegramLinkCallback(ctx context.Context) ProviderAPIGetProviderTelegramLinkCallbackRequest {
|
||
return ProviderAPIGetProviderTelegramLinkCallbackRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderTelegramLinkCallbackExecute(r ProviderAPIGetProviderTelegramLinkCallbackRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderTelegramLinkCallback")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/telegram/link/callback"
|
||
|
||
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 ProviderAPIGetProviderTwitterCallbackRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderTwitterCallbackRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderTwitterCallbackExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderTwitterCallback Completes an X consent that arrived on the twitter spelling of the callback.
|
||
|
||
Completes an X consent that arrived on the twitter spelling of the callback.
|
||
The consent URL this process sends is /v1/provider/x/callback. The X app is
|
||
also registered at this address, so a browser sent there still finishes the
|
||
same flow. State is signed for provider x, and the answer is a redirect.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderTwitterCallbackRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderTwitterCallback(ctx context.Context) ProviderAPIGetProviderTwitterCallbackRequest {
|
||
return ProviderAPIGetProviderTwitterCallbackRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderTwitterCallbackExecute(r ProviderAPIGetProviderTwitterCallbackRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderTwitterCallback")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/twitter/callback"
|
||
|
||
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 ProviderAPIGetProviderWhatsappGroupsRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
group *string
|
||
}
|
||
|
||
// Group is the group id returned when the group was created.
|
||
func (r ProviderAPIGetProviderWhatsappGroupsRequest) Group(group string) ProviderAPIGetProviderWhatsappGroupsRequest {
|
||
r.group = &group
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderWhatsappGroupsRequest) Execute() (*ProviderWhatsappGroupOut, *http.Response, error) {
|
||
return r.ApiService.GetProviderWhatsappGroupsExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderWhatsappGroups Reads the invite link of a group this org's number owns.
|
||
|
||
Reads the invite link of a group this org's number owns.
|
||
|
||
Org admin, for the same reason creating one is: the link admits anyone who
|
||
holds it.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderWhatsappGroupsRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderWhatsappGroups(ctx context.Context) ProviderAPIGetProviderWhatsappGroupsRequest {
|
||
return ProviderAPIGetProviderWhatsappGroupsRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderWhatsappGroupOut
|
||
func (a *ProviderAPIService) GetProviderWhatsappGroupsExecute(r ProviderAPIGetProviderWhatsappGroupsRequest) (*ProviderWhatsappGroupOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderWhatsappGroupOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderWhatsappGroups")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/whatsapp/groups"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
if r.group != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "group", r.group, "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 ProviderAPIGetProviderWhatsappWebhookRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIGetProviderWhatsappWebhookRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.GetProviderWhatsappWebhookExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetProviderWhatsappWebhook WhatsApp Cloud API subscription challenge
|
||
|
||
Meta calls this once when the webhook is subscribed, carrying the verify token this deployment was configured with and a challenge to echo. The token is compared in constant time before the echo — answering the challenge without checking it would let anyone point their own app at this address and have it confirm the subscription.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIGetProviderWhatsappWebhookRequest
|
||
*/
|
||
func (a *ProviderAPIService) GetProviderWhatsappWebhook(ctx context.Context) ProviderAPIGetProviderWhatsappWebhookRequest {
|
||
return ProviderAPIGetProviderWhatsappWebhookRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) GetProviderWhatsappWebhookExecute(r ProviderAPIGetProviderWhatsappWebhookRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.GetProviderWhatsappWebhook")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/whatsapp/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 ProviderAPIPostConnectionByIdRefreshRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
id string
|
||
}
|
||
|
||
func (r ProviderAPIPostConnectionByIdRefreshRequest) Execute() (*ProviderRefreshOut, *http.Response, error) {
|
||
return r.ApiService.PostConnectionByIdRefreshExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostConnectionByIdRefresh Forces a token rotation for a connected connector, ahead of the automatic rotation a token read would do inside the expiry window.
|
||
|
||
Forces a token rotation for a connected connector, ahead of the
|
||
automatic rotation a token read would do inside the expiry window. Only
|
||
providers that declare a Refresh support it.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param id ID is the connector id, provider + \":\" + label (\"openai:default\") — the auth-profile-id shape. Another user's id is simply no row, so 404.
|
||
@return ProviderAPIPostConnectionByIdRefreshRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostConnectionByIdRefresh(ctx context.Context, id string) ProviderAPIPostConnectionByIdRefreshRequest {
|
||
return ProviderAPIPostConnectionByIdRefreshRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
id: id,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderRefreshOut
|
||
func (a *ProviderAPIService) PostConnectionByIdRefreshExecute(r ProviderAPIPostConnectionByIdRefreshRequest) (*ProviderRefreshOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderRefreshOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostConnectionByIdRefresh")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/connection/{id}/refresh"
|
||
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 ProviderAPIPostConnectionByProviderCredentialRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
provider string
|
||
providerCredentialIn *ProviderCredentialIn
|
||
}
|
||
|
||
func (r ProviderAPIPostConnectionByProviderCredentialRequest) ProviderCredentialIn(providerCredentialIn ProviderCredentialIn) ProviderAPIPostConnectionByProviderCredentialRequest {
|
||
r.providerCredentialIn = &providerCredentialIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostConnectionByProviderCredentialRequest) Execute() (*ProviderCredentialOut, *http.Response, error) {
|
||
return r.ApiService.PostConnectionByProviderCredentialExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostConnectionByProviderCredential Is the direct intake path: a customer-held token/setup-token (Verify) or an externally obtained OAuth bundle from the CLI's local PKCE (Adopt).
|
||
|
||
Is the direct intake path: a customer-held token/setup-token
|
||
(Verify) or an externally obtained OAuth bundle from the CLI's local PKCE
|
||
(Adopt). ALWAYS verify-before-store: a bad credential is refused and NOTHING
|
||
is persisted (connectByCredential's fail-closed order).
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param provider Provider is the user-scoped provider's registry id, from the path.
|
||
@return ProviderAPIPostConnectionByProviderCredentialRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostConnectionByProviderCredential(ctx context.Context, provider string) ProviderAPIPostConnectionByProviderCredentialRequest {
|
||
return ProviderAPIPostConnectionByProviderCredentialRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
provider: provider,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderCredentialOut
|
||
func (a *ProviderAPIService) PostConnectionByProviderCredentialExecute(r ProviderAPIPostConnectionByProviderCredentialRequest) (*ProviderCredentialOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderCredentialOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostConnectionByProviderCredential")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/connection/{provider}/credential"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerCredentialIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerCredentialIn 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.providerCredentialIn
|
||
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 ProviderAPIPostConnectionByProviderDeviceRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
provider string
|
||
providerDeviceStartIn *ProviderDeviceStartIn
|
||
}
|
||
|
||
func (r ProviderAPIPostConnectionByProviderDeviceRequest) ProviderDeviceStartIn(providerDeviceStartIn ProviderDeviceStartIn) ProviderAPIPostConnectionByProviderDeviceRequest {
|
||
r.providerDeviceStartIn = &providerDeviceStartIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostConnectionByProviderDeviceRequest) Execute() (*ProviderDeviceStartOut, *http.Response, error) {
|
||
return r.ApiService.PostConnectionByProviderDeviceExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostConnectionByProviderDevice Begins a device sign-in and returns the code to show the user plus how to poll for completion.
|
||
|
||
Begins a device sign-in and returns the code to show the user plus
|
||
how to poll for completion. KMS readiness is checked NOW rather than dead-ending
|
||
the user at poll-done (connect() parity), and the per-provider connector cap is
|
||
checked before the provider is called. The provider's device code is persisted
|
||
only in the encrypted grants table and is NEVER returned.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param provider Provider is the user-scoped provider's registry id, from the path.
|
||
@return ProviderAPIPostConnectionByProviderDeviceRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostConnectionByProviderDevice(ctx context.Context, provider string) ProviderAPIPostConnectionByProviderDeviceRequest {
|
||
return ProviderAPIPostConnectionByProviderDeviceRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
provider: provider,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderDeviceStartOut
|
||
func (a *ProviderAPIService) PostConnectionByProviderDeviceExecute(r ProviderAPIPostConnectionByProviderDeviceRequest) (*ProviderDeviceStartOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderDeviceStartOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostConnectionByProviderDevice")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/connection/{provider}/device"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerDeviceStartIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerDeviceStartIn 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.providerDeviceStartIn
|
||
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 ProviderAPIPostConnectionByProviderDeviceByFlowPollRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
provider string
|
||
flow string
|
||
}
|
||
|
||
func (r ProviderAPIPostConnectionByProviderDeviceByFlowPollRequest) Execute() (*ProviderDevicePollOut, *http.Response, error) {
|
||
return r.ApiService.PostConnectionByProviderDeviceByFlowPollExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostConnectionByProviderDeviceByFlowPoll Advances a device sign-in.
|
||
|
||
Advances a device sign-in. Terminal outcomes are DATA, not errors
|
||
(verifyConn {active:false} discipline) — the status set is closed:
|
||
pending|connected|denied|expired. pollSlow collapses to "pending" on the
|
||
wire; the raised cadence rides interval.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param provider Provider is the user-scoped provider's registry id, from the path.
|
||
@param flow Flow is the id deviceStartOut returned. Expired or another user's flow is indistinguishable from an unknown one: 404.
|
||
@return ProviderAPIPostConnectionByProviderDeviceByFlowPollRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostConnectionByProviderDeviceByFlowPoll(ctx context.Context, provider string, flow string) ProviderAPIPostConnectionByProviderDeviceByFlowPollRequest {
|
||
return ProviderAPIPostConnectionByProviderDeviceByFlowPollRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
provider: provider,
|
||
flow: flow,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderDevicePollOut
|
||
func (a *ProviderAPIService) PostConnectionByProviderDeviceByFlowPollExecute(r ProviderAPIPostConnectionByProviderDeviceByFlowPollRequest) (*ProviderDevicePollOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderDevicePollOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostConnectionByProviderDeviceByFlowPoll")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/connection/{provider}/device/{flow}/poll"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
|
||
localVarPath = strings.Replace(localVarPath, "{"+"flow"+"}", url.PathEscape(parameterValueToString(r.flow, "flow")), -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 ProviderAPIPostProviderByProviderChooseRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
provider string
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderByProviderChooseRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.PostProviderByProviderChooseExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderByProviderChoose Answer the connect's account chooser
|
||
|
||
The form the chooser page posts: `state` (the token the page was given), and either `account` (one of the accounts it offered) or `install` (go on to the provider's install page). It binds the chosen account to the organization that started the connect and redirects back to the page that asked, as the callback does.
|
||
|
||
It is public and carries no principal. Its authority is the token alone: signed like the callback's state, carrying the offered accounts under its signature, and single-use, so a page answers once and only with an account it offered.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param provider
|
||
@return ProviderAPIPostProviderByProviderChooseRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderByProviderChoose(ctx context.Context, provider string) ProviderAPIPostProviderByProviderChooseRequest {
|
||
return ProviderAPIPostProviderByProviderChooseRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
provider: provider,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) PostProviderByProviderChooseExecute(r ProviderAPIPostProviderByProviderChooseRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderByProviderChoose")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/{provider}/choose"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -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 ProviderAPIPostProviderByProviderConnectRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
provider string
|
||
providerConnectIn *ProviderConnectIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderByProviderConnectRequest) ProviderConnectIn(providerConnectIn ProviderConnectIn) ProviderAPIPostProviderByProviderConnectRequest {
|
||
r.providerConnectIn = &providerConnectIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderByProviderConnectRequest) Execute() (*ProviderConnectOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderByProviderConnectExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderByProviderConnect Acquires the org's credential for one provider.
|
||
|
||
Acquires the org's credential for one provider. It has TWO paths and the
|
||
REQUEST picks which: a "token" key in the body seals that credential directly
|
||
(verify-before-store), and its absence begins the 3-legged OAuth flow — minting a
|
||
single-use nonce plus an HMAC-signed state that binds this org to this provider,
|
||
and answering with the provider's authorize URL for the caller to redirect to.
|
||
|
||
Fail-closed order, unchanged: no principal → 403; unknown provider → 404; an
|
||
AdminOnly connector without the caller's own-org admin bit → 403; not configured
|
||
→ 503; KMS not ready → 503 (the flow WILL need to seal a token, so refuse now
|
||
rather than dead-end at the callback).
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param provider Provider is the connector's registry id, from the :provider path segment.
|
||
@return ProviderAPIPostProviderByProviderConnectRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderByProviderConnect(ctx context.Context, provider string) ProviderAPIPostProviderByProviderConnectRequest {
|
||
return ProviderAPIPostProviderByProviderConnectRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
provider: provider,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderConnectOut
|
||
func (a *ProviderAPIService) PostProviderByProviderConnectExecute(r ProviderAPIPostProviderByProviderConnectRequest) (*ProviderConnectOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderConnectOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderByProviderConnect")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/{provider}/connect"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerConnectIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerConnectIn 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.providerConnectIn
|
||
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 ProviderAPIPostProviderByProviderDisconnectRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
provider string
|
||
providerDisconnectIn *ProviderDisconnectIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderByProviderDisconnectRequest) ProviderDisconnectIn(providerDisconnectIn ProviderDisconnectIn) ProviderAPIPostProviderByProviderDisconnectRequest {
|
||
r.providerDisconnectIn = &providerDisconnectIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderByProviderDisconnectRequest) Execute() (*ProviderDisconnectOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderByProviderDisconnectExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderByProviderDisconnect Revokes (best-effort) and forgets an org's connection: it deletes every custodied KMS secret and the connection row.
|
||
|
||
Revokes (best-effort) and forgets an org's connection: it deletes
|
||
every custodied KMS secret and the connection row. Idempotent — disconnecting a
|
||
provider that was never connected still returns {disconnected:true}. Symmetric
|
||
with connect: an AdminOnly connector needs the caller's own-org admin bit.
|
||
|
||
An `account` disconnects that one account and leaves the org's others; without
|
||
it every account goes. A provider with an App installation (GitHub) also removes
|
||
the installation at the provider for each account no other org still holds, so
|
||
connecting that account again is a fresh install rather than GitHub's Configure
|
||
page, which returns nothing the connect can bind.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param provider Provider is the connector's registry id, from the :provider path segment.
|
||
@return ProviderAPIPostProviderByProviderDisconnectRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderByProviderDisconnect(ctx context.Context, provider string) ProviderAPIPostProviderByProviderDisconnectRequest {
|
||
return ProviderAPIPostProviderByProviderDisconnectRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
provider: provider,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderDisconnectOut
|
||
func (a *ProviderAPIService) PostProviderByProviderDisconnectExecute(r ProviderAPIPostProviderByProviderDisconnectRequest) (*ProviderDisconnectOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderDisconnectOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderByProviderDisconnect")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/{provider}/disconnect"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerDisconnectIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerDisconnectIn 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.providerDisconnectIn
|
||
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 ProviderAPIPostProviderByProviderRunRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
provider string
|
||
providerRunIn *ProviderRunIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderByProviderRunRequest) ProviderRunIn(providerRunIn ProviderRunIn) ProviderAPIPostProviderByProviderRunRequest {
|
||
r.providerRunIn = &providerRunIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderByProviderRunRequest) Execute() (*ProviderRunOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderByProviderRunExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderByProviderRun Runs one action of a connector as the caller's org, with the credential the org connected, and answers what the action returned.
|
||
|
||
Runs one action of a connector as the caller's org, with the credential
|
||
the org connected, and answers what the action returned. The credential is
|
||
read from the org's KMS namespace here and never leaves this service. An
|
||
action that ran and failed is ok:false with the reason; an unknown connector
|
||
is 404, an action that does not run on this deployment 422, and a connector
|
||
the org has not connected 424.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param provider Provider is the connector, from the path.
|
||
@return ProviderAPIPostProviderByProviderRunRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderByProviderRun(ctx context.Context, provider string) ProviderAPIPostProviderByProviderRunRequest {
|
||
return ProviderAPIPostProviderByProviderRunRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
provider: provider,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderRunOut
|
||
func (a *ProviderAPIService) PostProviderByProviderRunExecute(r ProviderAPIPostProviderByProviderRunRequest) (*ProviderRunOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderRunOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderByProviderRun")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/{provider}/run"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerRunIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerRunIn 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.providerRunIn
|
||
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 ProviderAPIPostProviderByProviderVerifyRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
provider string
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderByProviderVerifyRequest) Execute() (*ProviderVerifyOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderByProviderVerifyExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderByProviderVerify Re-checks a CONNECTED apikey connector's stored credential against the provider, live (`hanzo connector verify`).
|
||
|
||
Re-checks a CONNECTED apikey connector's stored credential against the
|
||
provider, live (`hanzo connector verify`). Org-scoped (any member may check
|
||
status); the credential is read from KMS, verified, and NEVER returned or logged.
|
||
A verification failure is reported as {active:false}, not an error — the console/
|
||
CLI renders it. Only apikey providers support verify (OAuth tokens are checked at
|
||
use, not re-verified here).
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param provider Provider is the registry id of the connector — \"slack\", \"github\", \"cloudflare\". Unknown ids are 404, as are the user-plane (/v1/connection) providers, which this surface never resolves.
|
||
@return ProviderAPIPostProviderByProviderVerifyRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderByProviderVerify(ctx context.Context, provider string) ProviderAPIPostProviderByProviderVerifyRequest {
|
||
return ProviderAPIPostProviderByProviderVerifyRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
provider: provider,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderVerifyOut
|
||
func (a *ProviderAPIService) PostProviderByProviderVerifyExecute(r ProviderAPIPostProviderByProviderVerifyRequest) (*ProviderVerifyOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderVerifyOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderByProviderVerify")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/{provider}/verify"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -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 ProviderAPIPostProviderDiscordInteractionsRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderDiscordInteractionsRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.PostProviderDiscordInteractionsExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderDiscordInteractions Discord interactions endpoint
|
||
|
||
The Interactions Endpoint URL for the Discord app. It answers Discord's PING with a PONG, and handles the `/hanzo` slash command by acknowledging with a deferred ephemeral reply and editing that reply with the answer once the agent has run. Any other interaction is acknowledged and ignored.
|
||
|
||
Requests are verified by ED25519 SIGNATURE over the timestamp and body against the app's public key — not by HMAC, unlike the Slack webhooks. Interactions work over plain HTTP, so no gateway connection and no message-content intent is involved.
|
||
|
||
Discord does not retry, so this is the one channel where being at capacity is shown to the user as an ephemeral ask-to-run-it-again rather than answered as a retriable failure — nothing is recorded either way, so the next attempt is clean.
|
||
|
||
The caller here is the PLATFORM, not a Hanzo tenant, so there is no bearer and no principal. The signature check IS the authentication, and it fails closed. The tenant is never read from the payload either: it is resolved from the verified platform identifier through the connection map, so an event from a workspace nobody connected does nothing. Refusals are written with their own status rather than being flattened to a 500, so a rejected signature reads as 401 and a malformed body as 400.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderDiscordInteractionsRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderDiscordInteractions(ctx context.Context) ProviderAPIPostProviderDiscordInteractionsRequest {
|
||
return ProviderAPIPostProviderDiscordInteractionsRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) PostProviderDiscordInteractionsExecute(r ProviderAPIPostProviderDiscordInteractionsRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderDiscordInteractions")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/discord/interactions"
|
||
|
||
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 ProviderAPIPostProviderForgeWebhookRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
forgeJob *ForgeJob
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderForgeWebhookRequest) ForgeJob(forgeJob ForgeJob) ProviderAPIPostProviderForgeWebhookRequest {
|
||
r.forgeJob = &forgeJob
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderForgeWebhookRequest) Execute() (*ForgeLaunched, *http.Response, error) {
|
||
return r.ApiService.PostProviderForgeWebhookExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderForgeWebhook Forge workflow_job webhook
|
||
|
||
Receives the forge's workflow_job delivery. The signature over the raw body is checked against the secret at KMS forge.WebhookRef before anything is decoded; a queued job becomes one ephemeral runner Job on the cluster, minted a registration token for exactly that job. Every other action is answered 200 and ignored.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderForgeWebhookRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderForgeWebhook(ctx context.Context) ProviderAPIPostProviderForgeWebhookRequest {
|
||
return ProviderAPIPostProviderForgeWebhookRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ForgeLaunched
|
||
func (a *ProviderAPIService) PostProviderForgeWebhookExecute(r ProviderAPIPostProviderForgeWebhookRequest) (*ForgeLaunched, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ForgeLaunched
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderForgeWebhook")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/forge/webhook"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// 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"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
// body params
|
||
localVarPostBody = r.forgeJob
|
||
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,
|
||
}
|
||
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 ProviderAPIPostProviderGithubForkRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerGithubForkReq *ProviderGithubForkReq
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubForkRequest) ProviderGithubForkReq(providerGithubForkReq ProviderGithubForkReq) ProviderAPIPostProviderGithubForkRequest {
|
||
r.providerGithubForkReq = &providerGithubForkReq
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubForkRequest) Execute() (*ProviderGithubForkOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderGithubForkExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderGithubFork Forks a granted repository.
|
||
|
||
Forks a granted repository.
|
||
|
||
GitHub's fork is ASYNCHRONOUS: it answers 202 with the target repo and
|
||
populates it in the background, and it answers the same 202 when the fork
|
||
already exists. So this reports what GitHub said rather than waiting — a call
|
||
that blocked until the clone finished would time out on a large repository and
|
||
tell the caller nothing it does not already know.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderGithubForkRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderGithubFork(ctx context.Context) ProviderAPIPostProviderGithubForkRequest {
|
||
return ProviderAPIPostProviderGithubForkRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubForkOut
|
||
func (a *ProviderAPIService) PostProviderGithubForkExecute(r ProviderAPIPostProviderGithubForkRequest) (*ProviderGithubForkOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubForkOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubFork")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/fork"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerGithubForkReq == nil {
|
||
return localVarReturnValue, nil, reportError("providerGithubForkReq 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.providerGithubForkReq
|
||
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 ProviderAPIPostProviderGithubIssuesBackfillRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerGithubBackfillIn *ProviderGithubBackfillIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubIssuesBackfillRequest) ProviderGithubBackfillIn(providerGithubBackfillIn ProviderGithubBackfillIn) ProviderAPIPostProviderGithubIssuesBackfillRequest {
|
||
r.providerGithubBackfillIn = &providerGithubBackfillIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubIssuesBackfillRequest) Execute() (*ProviderGithubBackfillResult, *http.Response, error) {
|
||
return r.ApiService.PostProviderGithubIssuesBackfillExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderGithubIssuesBackfill Seeds the native todo with the EXISTING issues across the org's granted repos (default state=open); the webhook keeps them live thereafter.
|
||
|
||
Seeds the native todo with the EXISTING issues across the
|
||
org's granted repos (default state=open); the webhook keeps them live thereafter.
|
||
Org-scoped by the validated principal — a caller only ever backfills its OWN org.
|
||
Synchronous + bounded (a total time budget and an issue cap) so it returns the
|
||
counts directly; idempotent by ExtRef, so a re-run continues where a truncated
|
||
pass left off and never duplicates.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderGithubIssuesBackfillRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderGithubIssuesBackfill(ctx context.Context) ProviderAPIPostProviderGithubIssuesBackfillRequest {
|
||
return ProviderAPIPostProviderGithubIssuesBackfillRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubBackfillResult
|
||
func (a *ProviderAPIService) PostProviderGithubIssuesBackfillExecute(r ProviderAPIPostProviderGithubIssuesBackfillRequest) (*ProviderGithubBackfillResult, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubBackfillResult
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubIssuesBackfill")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/issues/backfill"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerGithubBackfillIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerGithubBackfillIn 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.providerGithubBackfillIn
|
||
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 ProviderAPIPostProviderGithubReposByRepoPagesRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
repo string
|
||
providerGithubPagesEnableReq *ProviderGithubPagesEnableReq
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubReposByRepoPagesRequest) ProviderGithubPagesEnableReq(providerGithubPagesEnableReq ProviderGithubPagesEnableReq) ProviderAPIPostProviderGithubReposByRepoPagesRequest {
|
||
r.providerGithubPagesEnableReq = &providerGithubPagesEnableReq
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubReposByRepoPagesRequest) Execute() (*ProviderGithubPagesView, *http.Response, error) {
|
||
return r.ApiService.PostProviderGithubReposByRepoPagesExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderGithubReposByRepoPages Creates the repo's Pages site and answers 201 Created with it.
|
||
|
||
Creates the repo's Pages site and answers 201 Created with it.
|
||
With buildType "workflow" the site builds via GitHub Actions; otherwise it builds
|
||
from a branch source, defaulting to the repo's own default branch when none is
|
||
given. Only "/" and "/docs" are legal source paths (GitHub's rule).
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param repo Repo is the repository, from the :repo path segment.
|
||
@return ProviderAPIPostProviderGithubReposByRepoPagesRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderGithubReposByRepoPages(ctx context.Context, repo string) ProviderAPIPostProviderGithubReposByRepoPagesRequest {
|
||
return ProviderAPIPostProviderGithubReposByRepoPagesRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
repo: repo,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubPagesView
|
||
func (a *ProviderAPIService) PostProviderGithubReposByRepoPagesExecute(r ProviderAPIPostProviderGithubReposByRepoPagesRequest) (*ProviderGithubPagesView, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubPagesView
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubReposByRepoPages")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/repos/{repo}/pages"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerGithubPagesEnableReq == nil {
|
||
return localVarReturnValue, nil, reportError("providerGithubPagesEnableReq 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.providerGithubPagesEnableReq
|
||
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 ProviderAPIPostProviderGithubReposByRepoPagesBuildsRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
repo string
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubReposByRepoPagesBuildsRequest) Execute() (*ProviderGithubPagesBuildOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderGithubReposByRepoPagesBuildsExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderGithubReposByRepoPagesBuilds Requests a Pages rebuild and returns the queued build's status.
|
||
|
||
Requests a Pages rebuild and returns the queued build's status.
|
||
The build is queued AT GITHUB, not completed here, so the answer is 202 Accepted
|
||
and its status is the one GitHub reported at queue time. 404 when the repository
|
||
has no Pages site, or when the org's installation was not granted it.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param repo Repo is the repository's short name within the org's installation, with no owner prefix (the owner is server-derived from the grant). A trailing \".git\" is stripped.
|
||
@return ProviderAPIPostProviderGithubReposByRepoPagesBuildsRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderGithubReposByRepoPagesBuilds(ctx context.Context, repo string) ProviderAPIPostProviderGithubReposByRepoPagesBuildsRequest {
|
||
return ProviderAPIPostProviderGithubReposByRepoPagesBuildsRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
repo: repo,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubPagesBuildOut
|
||
func (a *ProviderAPIService) PostProviderGithubReposByRepoPagesBuildsExecute(r ProviderAPIPostProviderGithubReposByRepoPagesBuildsRequest) (*ProviderGithubPagesBuildOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubPagesBuildOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubReposByRepoPagesBuilds")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/repos/{repo}/pages/builds"
|
||
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{"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 ProviderAPIPostProviderGithubReposImportRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerGithubImportIn *ProviderGithubImportIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubReposImportRequest) ProviderGithubImportIn(providerGithubImportIn ProviderGithubImportIn) ProviderAPIPostProviderGithubReposImportRequest {
|
||
r.providerGithubImportIn = &providerGithubImportIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubReposImportRequest) Execute() (*ProviderGithubImportOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderGithubReposImportExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderGithubReposImport Imports the selected (or all) granted repos into git.hanzo.ai.
|
||
|
||
Imports the selected (or all) granted repos into git.hanzo.ai. The
|
||
selection is intersected with the installation's GRANTED set, so a client can
|
||
never import a repo the App was not granted (org isolation + a grant check). The
|
||
import runs in a bounded background worker (don't block the request), so the
|
||
answer is 202 Accepted; poll GET /v1/git/repos for each repository to appear
|
||
on git.hanzo.ai.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderGithubReposImportRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderGithubReposImport(ctx context.Context) ProviderAPIPostProviderGithubReposImportRequest {
|
||
return ProviderAPIPostProviderGithubReposImportRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubImportOut
|
||
func (a *ProviderAPIService) PostProviderGithubReposImportExecute(r ProviderAPIPostProviderGithubReposImportRequest) (*ProviderGithubImportOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubImportOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubReposImport")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/repos/import"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerGithubImportIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerGithubImportIn 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.providerGithubImportIn
|
||
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 ProviderAPIPostProviderGithubSearchRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerGithubSearchReq *ProviderGithubSearchReq
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubSearchRequest) ProviderGithubSearchReq(providerGithubSearchReq ProviderGithubSearchReq) ProviderAPIPostProviderGithubSearchRequest {
|
||
r.providerGithubSearchReq = &providerGithubSearchReq
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubSearchRequest) Execute() (*ProviderGithubSearchOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderGithubSearchExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderGithubSearch Finds repositories on GitHub.
|
||
|
||
Finds repositories on GitHub.
|
||
|
||
This reads the PUBLIC index and returns nothing an installation unlocks: it is
|
||
how you find a repository to fork, not a way to see inside one. The org's own
|
||
token is used only so the query is rate-limited against the installation
|
||
rather than anonymously — the results are the same ones anyone would get.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderGithubSearchRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderGithubSearch(ctx context.Context) ProviderAPIPostProviderGithubSearchRequest {
|
||
return ProviderAPIPostProviderGithubSearchRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubSearchOut
|
||
func (a *ProviderAPIService) PostProviderGithubSearchExecute(r ProviderAPIPostProviderGithubSearchRequest) (*ProviderGithubSearchOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubSearchOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubSearch")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/search"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerGithubSearchReq == nil {
|
||
return localVarReturnValue, nil, reportError("providerGithubSearchReq 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.providerGithubSearchReq
|
||
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 ProviderAPIPostProviderGithubUserCompleteRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerGithubUserCompleteIn *ProviderGithubUserCompleteIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubUserCompleteRequest) ProviderGithubUserCompleteIn(providerGithubUserCompleteIn ProviderGithubUserCompleteIn) ProviderAPIPostProviderGithubUserCompleteRequest {
|
||
r.providerGithubUserCompleteIn = &providerGithubUserCompleteIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubUserCompleteRequest) Execute() (*ProviderGithubUserOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderGithubUserCompleteExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderGithubUserComplete Finishes connecting the caller's GitHub account: it takes the authorization the callback parked, trades it for the person's token, and seals it.
|
||
|
||
Finishes connecting the caller's GitHub account: it takes
|
||
the authorization the callback parked, trades it for the person's token, and
|
||
seals it. Only the person who started the flow can complete it — another
|
||
person's grant id is simply not found — and a grant completes once.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderGithubUserCompleteRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderGithubUserComplete(ctx context.Context) ProviderAPIPostProviderGithubUserCompleteRequest {
|
||
return ProviderAPIPostProviderGithubUserCompleteRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubUserOut
|
||
func (a *ProviderAPIService) PostProviderGithubUserCompleteExecute(r ProviderAPIPostProviderGithubUserCompleteRequest) (*ProviderGithubUserOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubUserOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubUserComplete")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/user/complete"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerGithubUserCompleteIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerGithubUserCompleteIn 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.providerGithubUserCompleteIn
|
||
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 ProviderAPIPostProviderGithubUserConnectRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerGithubUserConnectIn *ProviderGithubUserConnectIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubUserConnectRequest) ProviderGithubUserConnectIn(providerGithubUserConnectIn ProviderGithubUserConnectIn) ProviderAPIPostProviderGithubUserConnectRequest {
|
||
r.providerGithubUserConnectIn = &providerGithubUserConnectIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubUserConnectRequest) Execute() (*ProviderGithubUserConnectOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderGithubUserConnectExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderGithubUserConnect Begins connecting the caller's own GitHub account: it answers the App's authorization page, carrying a state signed for this org and this person.
|
||
|
||
Begins connecting the caller's own GitHub account: it answers
|
||
the App's authorization page, carrying a state signed for this org and this
|
||
person. Every member may connect their own; it grants nothing the person does
|
||
not already hold on GitHub. The page shows GitHub's account picker (githubPick),
|
||
so a connect after a Disconnect can choose another account: GitHub otherwise
|
||
skips the page for anyone who authorized the App before.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderGithubUserConnectRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderGithubUserConnect(ctx context.Context) ProviderAPIPostProviderGithubUserConnectRequest {
|
||
return ProviderAPIPostProviderGithubUserConnectRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubUserConnectOut
|
||
func (a *ProviderAPIService) PostProviderGithubUserConnectExecute(r ProviderAPIPostProviderGithubUserConnectRequest) (*ProviderGithubUserConnectOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubUserConnectOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubUserConnect")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/user/connect"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerGithubUserConnectIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerGithubUserConnectIn 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.providerGithubUserConnectIn
|
||
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 ProviderAPIPostProviderGithubUserDisconnectRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubUserDisconnectRequest) Execute() (*ProviderGithubUserDisconnectOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderGithubUserDisconnectExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderGithubUserDisconnect Forgets the caller's GitHub connection in this org: the token is revoked at GitHub, and the sealed secrets and the row go.
|
||
|
||
Forgets the caller's GitHub connection in this org: the
|
||
token is revoked at GitHub, and the sealed secrets and the row go. It says
|
||
whether GitHub confirmed the revocation rather than reporting a success it did
|
||
not see. Disconnecting what is not connected succeeds.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderGithubUserDisconnectRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderGithubUserDisconnect(ctx context.Context) ProviderAPIPostProviderGithubUserDisconnectRequest {
|
||
return ProviderAPIPostProviderGithubUserDisconnectRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubUserDisconnectOut
|
||
func (a *ProviderAPIService) PostProviderGithubUserDisconnectExecute(r ProviderAPIPostProviderGithubUserDisconnectRequest) (*ProviderGithubUserDisconnectOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubUserDisconnectOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubUserDisconnect")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/user/disconnect"
|
||
|
||
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 ProviderAPIPostProviderGithubWebhookRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGithubWebhookRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.PostProviderGithubWebhookExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderGithubWebhook GitHub App webhook
|
||
|
||
The address the GitHub App delivers events to. A push is handed to the repository sync engine, and an issue or issue-comment event is mirrored into the native todo — idempotently, so the same issue re-syncs to one row however many times it is edited, closed or reopened. A repository event that puts a repo INTO the granted set (created, transferred, unarchived) raises one todo offering to import it; accepting means POSTing that repo to /v1/provider/github/import. It never imports on its own.
|
||
|
||
It answers a benign 200 for everything it does not act on — the ping, other event types, an unknown installation — deliberately, so GitHub does not enter a retry storm over events that were never going to do anything. Only a bad signature and a genuine sync failure are non-200, and an oversized payload is refused outright.
|
||
|
||
Two sync rules are worth stating because neither is guessable. EVERY ref syncs, tags as well as branches, because releases are cut by tag and filtering them would stop publishing with nothing reporting a failure. And a delete is NEVER propagated: the native side is canonical, so an inbound delete never removes a native ref.
|
||
|
||
The payload is verified by HMAC against the webhook secret before it is parsed.
|
||
|
||
The caller here is the PLATFORM, not a Hanzo tenant, so there is no bearer and no principal. The signature check IS the authentication, and it fails closed. The tenant is never read from the payload either: it is resolved from the verified platform identifier through the connection map, so an event from a workspace nobody connected does nothing. Refusals are written with their own status rather than being flattened to a 500, so a rejected signature reads as 401 and a malformed body as 400.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderGithubWebhookRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderGithubWebhook(ctx context.Context) ProviderAPIPostProviderGithubWebhookRequest {
|
||
return ProviderAPIPostProviderGithubWebhookRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) PostProviderGithubWebhookExecute(r ProviderAPIPostProviderGithubWebhookRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGithubWebhook")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/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 ProviderAPIPostProviderGoogleUserCompleteRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerGoogleUserCompleteIn *ProviderGoogleUserCompleteIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGoogleUserCompleteRequest) ProviderGoogleUserCompleteIn(providerGoogleUserCompleteIn ProviderGoogleUserCompleteIn) ProviderAPIPostProviderGoogleUserCompleteRequest {
|
||
r.providerGoogleUserCompleteIn = &providerGoogleUserCompleteIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGoogleUserCompleteRequest) Execute() (*ProviderGoogleUserOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderGoogleUserCompleteExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderGoogleUserComplete Finishes connecting the caller's Google account: it takes the authorization the callback parked, trades it for the person's tokens, and seals them.
|
||
|
||
Finishes connecting the caller's Google account: it takes
|
||
the authorization the callback parked, trades it for the person's tokens, and
|
||
seals them. Only the person who started the flow can complete it — another
|
||
person's grant id is simply not found — and a grant completes once. A grant
|
||
that leaves out sending mail, or offline access, is refused and nothing is
|
||
kept: a connection that cannot send is not one this surface offers.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderGoogleUserCompleteRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderGoogleUserComplete(ctx context.Context) ProviderAPIPostProviderGoogleUserCompleteRequest {
|
||
return ProviderAPIPostProviderGoogleUserCompleteRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGoogleUserOut
|
||
func (a *ProviderAPIService) PostProviderGoogleUserCompleteExecute(r ProviderAPIPostProviderGoogleUserCompleteRequest) (*ProviderGoogleUserOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGoogleUserOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGoogleUserComplete")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/google/user/complete"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerGoogleUserCompleteIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerGoogleUserCompleteIn 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.providerGoogleUserCompleteIn
|
||
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 ProviderAPIPostProviderGoogleUserConnectRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerGoogleUserConnectIn *ProviderGoogleUserConnectIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGoogleUserConnectRequest) ProviderGoogleUserConnectIn(providerGoogleUserConnectIn ProviderGoogleUserConnectIn) ProviderAPIPostProviderGoogleUserConnectRequest {
|
||
r.providerGoogleUserConnectIn = &providerGoogleUserConnectIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGoogleUserConnectRequest) Execute() (*ProviderGoogleUserConnectOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderGoogleUserConnectExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderGoogleUserConnect Begins connecting the caller's own Google account: it answers Google's consent page, asking offline access to send mail as them, carrying a state signed for this org and this person.
|
||
|
||
Begins connecting the caller's own Google account: it answers
|
||
Google's consent page, asking offline access to send mail as them, carrying a
|
||
state signed for this org and this person. Every member may connect their own;
|
||
it grants nothing the person does not already hold at Google.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderGoogleUserConnectRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderGoogleUserConnect(ctx context.Context) ProviderAPIPostProviderGoogleUserConnectRequest {
|
||
return ProviderAPIPostProviderGoogleUserConnectRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGoogleUserConnectOut
|
||
func (a *ProviderAPIService) PostProviderGoogleUserConnectExecute(r ProviderAPIPostProviderGoogleUserConnectRequest) (*ProviderGoogleUserConnectOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGoogleUserConnectOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGoogleUserConnect")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/google/user/connect"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerGoogleUserConnectIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerGoogleUserConnectIn 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.providerGoogleUserConnectIn
|
||
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 ProviderAPIPostProviderGoogleUserDisconnectRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderGoogleUserDisconnectRequest) Execute() (*ProviderGoogleUserDisconnectOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderGoogleUserDisconnectExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderGoogleUserDisconnect Forgets the caller's Google connection in this org: the grant is revoked at Google, and the sealed secrets and the row go.
|
||
|
||
Forgets the caller's Google connection in this org: the
|
||
grant is revoked at Google, and the sealed secrets and the row go. It says
|
||
whether Google confirmed the revocation rather than reporting a success it did
|
||
not see. Disconnecting what is not connected succeeds.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderGoogleUserDisconnectRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderGoogleUserDisconnect(ctx context.Context) ProviderAPIPostProviderGoogleUserDisconnectRequest {
|
||
return ProviderAPIPostProviderGoogleUserDisconnectRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGoogleUserDisconnectOut
|
||
func (a *ProviderAPIService) PostProviderGoogleUserDisconnectExecute(r ProviderAPIPostProviderGoogleUserDisconnectRequest) (*ProviderGoogleUserDisconnectOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGoogleUserDisconnectOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderGoogleUserDisconnect")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/google/user/disconnect"
|
||
|
||
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 ProviderAPIPostProviderLinearClaimRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerLinearClaimIn *ProviderLinearClaimIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderLinearClaimRequest) ProviderLinearClaimIn(providerLinearClaimIn ProviderLinearClaimIn) ProviderAPIPostProviderLinearClaimRequest {
|
||
r.providerLinearClaimIn = &providerLinearClaimIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderLinearClaimRequest) Execute() (*ProviderLinearClaimOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderLinearClaimExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderLinearClaim Binds the caller's Linear organization to the org and seals the webhook secret.
|
||
|
||
Binds the caller's Linear organization to the org and seals the
|
||
webhook secret. The organization is READ from the caller's own key, never taken
|
||
from the body: a person can only bind an organization they are a member of. An
|
||
organization another org already holds is refused.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderLinearClaimRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderLinearClaim(ctx context.Context) ProviderAPIPostProviderLinearClaimRequest {
|
||
return ProviderAPIPostProviderLinearClaimRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderLinearClaimOut
|
||
func (a *ProviderAPIService) PostProviderLinearClaimExecute(r ProviderAPIPostProviderLinearClaimRequest) (*ProviderLinearClaimOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderLinearClaimOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderLinearClaim")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/linear/claim"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerLinearClaimIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerLinearClaimIn 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.providerLinearClaimIn
|
||
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 ProviderAPIPostProviderLinearCommentsRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerLinearCommentIn *ProviderLinearCommentIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderLinearCommentsRequest) ProviderLinearCommentIn(providerLinearCommentIn ProviderLinearCommentIn) ProviderAPIPostProviderLinearCommentsRequest {
|
||
r.providerLinearCommentIn = &providerLinearCommentIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderLinearCommentsRequest) Execute() (*ProviderLinearCommentOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderLinearCommentsExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderLinearComments Posts a comment on a Linear issue with the caller's own key, so it carries their name.
|
||
|
||
Posts a comment on a Linear issue with the caller's own key, so it
|
||
carries their name. This is the op an agent is offered when it should answer in
|
||
Linear rather than in chat.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderLinearCommentsRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderLinearComments(ctx context.Context) ProviderAPIPostProviderLinearCommentsRequest {
|
||
return ProviderAPIPostProviderLinearCommentsRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderLinearCommentOut
|
||
func (a *ProviderAPIService) PostProviderLinearCommentsExecute(r ProviderAPIPostProviderLinearCommentsRequest) (*ProviderLinearCommentOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderLinearCommentOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderLinearComments")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/linear/comments"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerLinearCommentIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerLinearCommentIn 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.providerLinearCommentIn
|
||
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 ProviderAPIPostProviderLinearIssuesBackfillRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerLinearBackfillIn *ProviderLinearBackfillIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderLinearIssuesBackfillRequest) ProviderLinearBackfillIn(providerLinearBackfillIn ProviderLinearBackfillIn) ProviderAPIPostProviderLinearIssuesBackfillRequest {
|
||
r.providerLinearBackfillIn = &providerLinearBackfillIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderLinearIssuesBackfillRequest) Execute() (*ProviderLinearBackfillResult, *http.Response, error) {
|
||
return r.ApiService.PostProviderLinearIssuesBackfillExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderLinearIssuesBackfill Seeds the native todo with the EXISTING Linear issues the caller's key can see (default state=open); the webhook keeps them live thereafter.
|
||
|
||
Seeds the native todo with the EXISTING Linear issues the
|
||
caller's key can see (default state=open); the webhook keeps them live
|
||
thereafter. Synchronous and bounded, idempotent by ExtRef.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderLinearIssuesBackfillRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderLinearIssuesBackfill(ctx context.Context) ProviderAPIPostProviderLinearIssuesBackfillRequest {
|
||
return ProviderAPIPostProviderLinearIssuesBackfillRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderLinearBackfillResult
|
||
func (a *ProviderAPIService) PostProviderLinearIssuesBackfillExecute(r ProviderAPIPostProviderLinearIssuesBackfillRequest) (*ProviderLinearBackfillResult, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderLinearBackfillResult
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderLinearIssuesBackfill")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/linear/issues/backfill"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerLinearBackfillIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerLinearBackfillIn 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.providerLinearBackfillIn
|
||
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 ProviderAPIPostProviderLinearWebhookRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderLinearWebhookRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.PostProviderLinearWebhookExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderLinearWebhook Linear webhook
|
||
|
||
The address Linear delivers Issue and Comment events to. An issue event is mirrored into the native todo — idempotently by identifier, so ENG-123 is one row however many times it is edited, moved or closed — and every issue and comment event is handed to the automations engine as a verified trigger, which is how an org runs an agent when an issue is assigned to it or a comment mentions it. A remove is never propagated: the native side is canonical.
|
||
|
||
It answers a benign 200 for what it does not act on — an unknown organization, other event types — so Linear does not retry-storm. A bad signature and a delivery older than a minute are 401; only a sink failure is 502.
|
||
|
||
The delivery names its Linear organization; that organization's own webhook secret — sealed at /v1/provider/linear/claim — verifies the HMAC over the raw body, so the tenant is the organization the signature proves, never a header.
|
||
|
||
The caller here is the PLATFORM, not a Hanzo tenant, so there is no bearer and no principal. The signature check IS the authentication, and it fails closed. The tenant is never read from the payload either: it is resolved from the verified platform identifier through the connection map, so an event from a workspace nobody connected does nothing. Refusals are written with their own status rather than being flattened to a 500, so a rejected signature reads as 401 and a malformed body as 400.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderLinearWebhookRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderLinearWebhook(ctx context.Context) ProviderAPIPostProviderLinearWebhookRequest {
|
||
return ProviderAPIPostProviderLinearWebhookRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) PostProviderLinearWebhookExecute(r ProviderAPIPostProviderLinearWebhookRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderLinearWebhook")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/linear/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 ProviderAPIPostProviderOpenrouterWebhookRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
requestBody *map[string]interface{}
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderOpenrouterWebhookRequest) RequestBody(requestBody map[string]interface{}) ProviderAPIPostProviderOpenrouterWebhookRequest {
|
||
r.requestBody = &requestBody
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderOpenrouterWebhookRequest) Execute() (map[string]interface{}, *http.Response, error) {
|
||
return r.ApiService.PostProviderOpenrouterWebhookExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderOpenrouterWebhook Receive OpenRouter Broadcast traces as usage rows
|
||
|
||
OpenRouter's spend is invisible to every Hanzo money lens because those lenses read hanzo.cloud_usage and OpenRouter meters keys of its own. Point a Broadcast destination (Settings ▸ Observability ▸ Webhook) at this endpoint and each generation span becomes ONE row in that same ledger with provider `openrouter`, so one query answers what we spend everywhere. Enable the Cost and Identity field categories: cost is the money and identity carries `openrouter.api_key_name`, which is what says WHICH key spent it — it lands in `account` as openrouter/<key name>.
|
||
|
||
AUTHENTICATION IS A HANZO KEY. Broadcast signs nothing; its only authentication is the destination's Headers map, so send a key as `Authorization: Bearer pk-…` and it is admitted exactly as /v1/event admits a beacon's: a project key resolves through the project that minted it, an IAM-issued key through IAM. That key names the org every row is filed under; it can write and cannot read. No key, or a key that names no org, is 401 and nothing is stored.
|
||
|
||
The body is OTLP/JSON — `{resourceSpans:[{scopeSpans:[{spans:[…]}]}]}` — exactly as OpenTelemetry defines it; the model, tokens and cost are read from each span's `gen_ai.*` attributes and the key name from `openrouter.api_key_name`. The answer is `{stored, dropped}`: how many generations became rows, and how many spans named no model. Those are OpenRouter's trace and span parents — they carry no cost to meter. An empty payload stores nothing and answers 200, which is what makes Test Connection pass. A warehouse that cannot take the rows answers 503 so the delivery shows red and can be replayed: a row is keyed by its span id, so a redelivery collapses rather than double-counting.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderOpenrouterWebhookRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderOpenrouterWebhook(ctx context.Context) ProviderAPIPostProviderOpenrouterWebhookRequest {
|
||
return ProviderAPIPostProviderOpenrouterWebhookRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return map[string]interface{}
|
||
func (a *ProviderAPIService) PostProviderOpenrouterWebhookExecute(r ProviderAPIPostProviderOpenrouterWebhookRequest) (map[string]interface{}, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue map[string]interface{}
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderOpenrouterWebhook")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/openrouter/webhook"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// 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"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
// body params
|
||
localVarPostBody = r.requestBody
|
||
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,
|
||
}
|
||
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 ProviderAPIPostProviderSlackCommandsRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderSlackCommandsRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.PostProviderSlackCommandsExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderSlackCommands Slack slash command webhook
|
||
|
||
The address Slack posts a slash command to, form-encoded. It acknowledges inside Slack's three-second budget and posts the answer afterwards to the command's own response URL, which is why the immediate reply is empty.
|
||
|
||
The body is verified against the same app signing secret as the events webhook, and a repeat of the same command invocation is absorbed rather than answered twice.
|
||
|
||
The caller here is the PLATFORM, not a Hanzo tenant, so there is no bearer and no principal. The signature check IS the authentication, and it fails closed. The tenant is never read from the payload either: it is resolved from the verified platform identifier through the connection map, so an event from a workspace nobody connected does nothing. Refusals are written with their own status rather than being flattened to a 500, so a rejected signature reads as 401 and a malformed body as 400.
|
||
|
||
The answer is acknowledged immediately and the work happens afterwards, because every one of these platforms times out a slow webhook. Duplicate deliveries are absorbed durably, so a platform retry of an event that already ran never runs it a second time or bills for it twice. When the agent pool is full nothing at all is recorded and the delivery is refused as retriable, so the message is re-delivered later rather than being lost or half-processed.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderSlackCommandsRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderSlackCommands(ctx context.Context) ProviderAPIPostProviderSlackCommandsRequest {
|
||
return ProviderAPIPostProviderSlackCommandsRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) PostProviderSlackCommandsExecute(r ProviderAPIPostProviderSlackCommandsRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderSlackCommands")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/slack/commands"
|
||
|
||
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 ProviderAPIPostProviderSlackEventsRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderSlackEventsRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.PostProviderSlackEventsExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderSlackEvents Slack Events API webhook
|
||
|
||
The address a Slack app posts workspace events to. It answers Slack's url_verification handshake with the challenge, and routes an @mention or a direct message to an agent turn that replies in the same thread. The turn holds the product's own tools, so a request to change code starts a sandbox run because the model chose to — there is no prefix and no second path.
|
||
|
||
The raw body and its timestamp are verified against the app's signing secret before anything is read from them. Hanzo's own bot messages are dropped, so a reply cannot trigger another reply.
|
||
|
||
The caller here is the PLATFORM, not a Hanzo tenant, so there is no bearer and no principal. The signature check IS the authentication, and it fails closed. The tenant is never read from the payload either: it is resolved from the verified platform identifier through the connection map, so an event from a workspace nobody connected does nothing. Refusals are written with their own status rather than being flattened to a 500, so a rejected signature reads as 401 and a malformed body as 400.
|
||
|
||
The answer is acknowledged immediately and the work happens afterwards, because every one of these platforms times out a slow webhook. Duplicate deliveries are absorbed durably, so a platform retry of an event that already ran never runs it a second time or bills for it twice. When the agent pool is full nothing at all is recorded and the delivery is refused as retriable, so the message is re-delivered later rather than being lost or half-processed.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderSlackEventsRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderSlackEvents(ctx context.Context) ProviderAPIPostProviderSlackEventsRequest {
|
||
return ProviderAPIPostProviderSlackEventsRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) PostProviderSlackEventsExecute(r ProviderAPIPostProviderSlackEventsRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderSlackEvents")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/slack/events"
|
||
|
||
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 ProviderAPIPostProviderSlackJoinRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderSlackJoinRequest) Execute() (*ProviderSlackJoinOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderSlackJoinExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderSlackJoin Joins every public channel in the caller org's workspace.
|
||
|
||
Joins every public channel in the caller org's workspace.
|
||
|
||
Org admin, because it changes what the whole workspace sees: after it the agent
|
||
is a member of every public room and answers in all of them.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderSlackJoinRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderSlackJoin(ctx context.Context) ProviderAPIPostProviderSlackJoinRequest {
|
||
return ProviderAPIPostProviderSlackJoinRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderSlackJoinOut
|
||
func (a *ProviderAPIService) PostProviderSlackJoinExecute(r ProviderAPIPostProviderSlackJoinRequest) (*ProviderSlackJoinOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderSlackJoinOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderSlackJoin")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/slack/join"
|
||
|
||
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 ProviderAPIPostProviderSlackMessagesRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerSlackSendMessageIn *ProviderSlackSendMessageIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderSlackMessagesRequest) ProviderSlackSendMessageIn(providerSlackSendMessageIn ProviderSlackSendMessageIn) ProviderAPIPostProviderSlackMessagesRequest {
|
||
r.providerSlackSendMessageIn = &providerSlackSendMessageIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderSlackMessagesRequest) Execute() (*ProviderSlackSendMessageOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderSlackMessagesExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderSlackMessages Posts as Hanzo to the caller's connected Slack workspace.
|
||
|
||
Posts as Hanzo to the caller's connected Slack workspace.
|
||
Use channel from a message read and thread_ts to reply to a specific message.
|
||
Requires chat:write; this operation does not join channels automatically.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderSlackMessagesRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderSlackMessages(ctx context.Context) ProviderAPIPostProviderSlackMessagesRequest {
|
||
return ProviderAPIPostProviderSlackMessagesRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderSlackSendMessageOut
|
||
func (a *ProviderAPIService) PostProviderSlackMessagesExecute(r ProviderAPIPostProviderSlackMessagesRequest) (*ProviderSlackSendMessageOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderSlackSendMessageOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderSlackMessages")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/slack/messages"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerSlackSendMessageIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerSlackSendMessageIn 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.providerSlackSendMessageIn
|
||
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 ProviderAPIPostProviderSlackReactionsRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerSlackReactIn *ProviderSlackReactIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderSlackReactionsRequest) ProviderSlackReactIn(providerSlackReactIn ProviderSlackReactIn) ProviderAPIPostProviderSlackReactionsRequest {
|
||
r.providerSlackReactIn = &providerSlackReactIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderSlackReactionsRequest) Execute() (*ProviderSlackReactOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderSlackReactionsExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderSlackReactions Adds an emoji reaction: POST /v1/provider/slack/reactions.
|
||
|
||
Adds an emoji reaction: POST /v1/provider/slack/reactions.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderSlackReactionsRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderSlackReactions(ctx context.Context) ProviderAPIPostProviderSlackReactionsRequest {
|
||
return ProviderAPIPostProviderSlackReactionsRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderSlackReactOut
|
||
func (a *ProviderAPIService) PostProviderSlackReactionsExecute(r ProviderAPIPostProviderSlackReactionsRequest) (*ProviderSlackReactOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderSlackReactOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderSlackReactions")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/slack/reactions"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerSlackReactIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerSlackReactIn 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.providerSlackReactIn
|
||
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 ProviderAPIPostProviderSlackSearchRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerSlackSearchIn *ProviderSlackSearchIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderSlackSearchRequest) ProviderSlackSearchIn(providerSlackSearchIn ProviderSlackSearchIn) ProviderAPIPostProviderSlackSearchRequest {
|
||
r.providerSlackSearchIn = &providerSlackSearchIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderSlackSearchRequest) Execute() (*ProviderSlackSearchOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderSlackSearchExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderSlackSearch Answers a workspace question: POST /v1/provider/slack/search.
|
||
|
||
Answers a workspace question: POST /v1/provider/slack/search.
|
||
|
||
Slack's search.messages wants a USER token for a person's own view of a
|
||
workspace; a bot token searches what the app can see. Whichever the install
|
||
granted, the token custodied for this org is the one sent.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderSlackSearchRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderSlackSearch(ctx context.Context) ProviderAPIPostProviderSlackSearchRequest {
|
||
return ProviderAPIPostProviderSlackSearchRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderSlackSearchOut
|
||
func (a *ProviderAPIService) PostProviderSlackSearchExecute(r ProviderAPIPostProviderSlackSearchRequest) (*ProviderSlackSearchOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderSlackSearchOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderSlackSearch")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/slack/search"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerSlackSearchIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerSlackSearchIn 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.providerSlackSearchIn
|
||
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 ProviderAPIPostProviderTeamsEventsRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderTeamsEventsRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.PostProviderTeamsEventsExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderTeamsEvents Microsoft Teams Bot Framework webhook
|
||
|
||
The messaging endpoint for the Teams bot. A message activity is routed to an agent turn and answered proactively through the Bot Connection; anything that is not a message with text is acknowledged and ignored.
|
||
|
||
Authentication is the Bot Framework's RS256 JWT, verified against its published keys and bound BOTH to this deployment's app id and to the activity's own service URL. The service-URL binding is the part that matters: without it a token valid for one activity could point the outbound reply somewhere else.
|
||
|
||
The caller here is the PLATFORM, not a Hanzo tenant, so there is no bearer and no principal. The signature check IS the authentication, and it fails closed. The tenant is never read from the payload either: it is resolved from the verified platform identifier through the connection map, so an event from a workspace nobody connected does nothing. Refusals are written with their own status rather than being flattened to a 500, so a rejected signature reads as 401 and a malformed body as 400.
|
||
|
||
The answer is acknowledged immediately and the work happens afterwards, because every one of these platforms times out a slow webhook. Duplicate deliveries are absorbed durably, so a platform retry of an event that already ran never runs it a second time or bills for it twice. When the agent pool is full nothing at all is recorded and the delivery is refused as retriable, so the message is re-delivered later rather than being lost or half-processed.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderTeamsEventsRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderTeamsEvents(ctx context.Context) ProviderAPIPostProviderTeamsEventsRequest {
|
||
return ProviderAPIPostProviderTeamsEventsRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) PostProviderTeamsEventsExecute(r ProviderAPIPostProviderTeamsEventsRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderTeamsEvents")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/teams/events"
|
||
|
||
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 ProviderAPIPostProviderTelegramConnectRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderTelegramConnectRequest) Execute() (*ProviderAuthorizeOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderTelegramConnectExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderTelegramConnect Mints a short, single-use deep-link code bound to the caller's org and returns the t.me link the console navigates to.
|
||
|
||
Mints a short, single-use deep-link code bound to the caller's
|
||
org and returns the t.me link the console navigates to. Org-authed: a caller with
|
||
no validated principal is 403 (same gate as the framework connect). The code is
|
||
stored as an oauth_nonce (org,telegram); the webhook's /start handler claims it to
|
||
bind chat→org. It is short (128-bit hex) so it fits Telegram's 64-char `start`
|
||
payload limit.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderTelegramConnectRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderTelegramConnect(ctx context.Context) ProviderAPIPostProviderTelegramConnectRequest {
|
||
return ProviderAPIPostProviderTelegramConnectRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderAuthorizeOut
|
||
func (a *ProviderAPIService) PostProviderTelegramConnectExecute(r ProviderAPIPostProviderTelegramConnectRequest) (*ProviderAuthorizeOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderAuthorizeOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderTelegramConnect")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/telegram/connect"
|
||
|
||
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 ProviderAPIPostProviderTelegramWebhookRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderTelegramWebhookRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.PostProviderTelegramWebhookExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderTelegramWebhook Telegram Bot API webhook
|
||
|
||
The update webhook for the Telegram bot. It does two jobs: `/start <code>` or `/connect <code>` binds the chat it was sent from to an org, idempotently; anything else is treated as a possible agent trigger.
|
||
|
||
What counts as a trigger differs by chat type, and it is easy to get wrong: in a private chat every message is a trigger, while in a group the message must mention the bot or use the `/hanzo` command. Non-triggers and non-message updates are acknowledged and dropped.
|
||
|
||
Authentication is the secret token Telegram echoes on every update, compared in constant time. A message in a chat that has never been bound is dropped, which is why the bind command exists.
|
||
|
||
The caller here is the PLATFORM, not a Hanzo tenant, so there is no bearer and no principal. The signature check IS the authentication, and it fails closed. The tenant is never read from the payload either: it is resolved from the verified platform identifier through the connection map, so an event from a workspace nobody connected does nothing. Refusals are written with their own status rather than being flattened to a 500, so a rejected signature reads as 401 and a malformed body as 400.
|
||
|
||
The answer is acknowledged immediately and the work happens afterwards, because every one of these platforms times out a slow webhook. Duplicate deliveries are absorbed durably, so a platform retry of an event that already ran never runs it a second time or bills for it twice. When the agent pool is full nothing at all is recorded and the delivery is refused as retriable, so the message is re-delivered later rather than being lost or half-processed.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderTelegramWebhookRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderTelegramWebhook(ctx context.Context) ProviderAPIPostProviderTelegramWebhookRequest {
|
||
return ProviderAPIPostProviderTelegramWebhookRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) PostProviderTelegramWebhookExecute(r ProviderAPIPostProviderTelegramWebhookRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderTelegramWebhook")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/telegram/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 ProviderAPIPostProviderWhatsappGroupsRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerWhatsappGroupIn *ProviderWhatsappGroupIn
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderWhatsappGroupsRequest) ProviderWhatsappGroupIn(providerWhatsappGroupIn ProviderWhatsappGroupIn) ProviderAPIPostProviderWhatsappGroupsRequest {
|
||
r.providerWhatsappGroupIn = &providerWhatsappGroupIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderWhatsappGroupsRequest) Execute() (*ProviderWhatsappGroupOut, *http.Response, error) {
|
||
return r.ApiService.PostProviderWhatsappGroupsExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderWhatsappGroups Creates a group on the org's WhatsApp number and returns its invite link.
|
||
|
||
Creates a group on the org's WhatsApp number and returns
|
||
its invite link.
|
||
|
||
Org admin, because the group speaks as the org's number and the invite link
|
||
admits anyone who holds it.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderWhatsappGroupsRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderWhatsappGroups(ctx context.Context) ProviderAPIPostProviderWhatsappGroupsRequest {
|
||
return ProviderAPIPostProviderWhatsappGroupsRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderWhatsappGroupOut
|
||
func (a *ProviderAPIService) PostProviderWhatsappGroupsExecute(r ProviderAPIPostProviderWhatsappGroupsRequest) (*ProviderWhatsappGroupOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderWhatsappGroupOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderWhatsappGroups")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/whatsapp/groups"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerWhatsappGroupIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerWhatsappGroupIn 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.providerWhatsappGroupIn
|
||
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 ProviderAPIPostProviderWhatsappWebhookRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
}
|
||
|
||
func (r ProviderAPIPostProviderWhatsappWebhookRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.PostProviderWhatsappWebhookExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostProviderWhatsappWebhook WhatsApp Cloud API webhook
|
||
|
||
One delivery from Meta. Authenticity is the X-Hub-Signature-256 HMAC over the raw body, and it is the whole of it: a message accepted here creates the reply route that authorises this org to answer, so an unsigned delivery would let anyone hand an org a conversation to answer under its own number.
|
||
|
||
Meta batches (entry × changes × messages) and sends status callbacks — sent/delivered/read — through this same address with no message at all. Those are acknowledged and dropped rather than refused, because a non-2xx is retried with backoff and eventually disables the subscription: the only refusals here are an unconfigured endpoint and a bad signature, which are ours to fix and not Meta's to retry.
|
||
|
||
The answer is acknowledged immediately and the work happens afterwards, because every one of these platforms times out a slow webhook. Duplicate deliveries are absorbed durably, so a platform retry of an event that already ran never runs it a second time or bills for it twice. When the agent pool is full nothing at all is recorded and the delivery is refused as retriable, so the message is re-delivered later rather than being lost or half-processed.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPostProviderWhatsappWebhookRequest
|
||
*/
|
||
func (a *ProviderAPIService) PostProviderWhatsappWebhook(ctx context.Context) ProviderAPIPostProviderWhatsappWebhookRequest {
|
||
return ProviderAPIPostProviderWhatsappWebhookRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *ProviderAPIService) PostProviderWhatsappWebhookExecute(r ProviderAPIPostProviderWhatsappWebhookRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PostProviderWhatsappWebhook")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/whatsapp/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 ProviderAPIPutProviderGithubReposByRepoPagesRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
repo string
|
||
providerGithubPagesUpdateReq *ProviderGithubPagesUpdateReq
|
||
}
|
||
|
||
func (r ProviderAPIPutProviderGithubReposByRepoPagesRequest) ProviderGithubPagesUpdateReq(providerGithubPagesUpdateReq ProviderGithubPagesUpdateReq) ProviderAPIPutProviderGithubReposByRepoPagesRequest {
|
||
r.providerGithubPagesUpdateReq = &providerGithubPagesUpdateReq
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPutProviderGithubReposByRepoPagesRequest) Execute() (*ProviderGithubPagesUpdatedOut, *http.Response, error) {
|
||
return r.ApiService.PutProviderGithubReposByRepoPagesExecute(r)
|
||
}
|
||
|
||
/*
|
||
PutProviderGithubReposByRepoPages Sets or clears the custom domain (cname) and updates HTTPS enforcement, build type, or source.
|
||
|
||
Sets or clears the custom domain (cname) and updates HTTPS
|
||
enforcement, build type, or source. ONLY the provided fields are sent to GitHub,
|
||
so an update never resets a setting the caller did not mention.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param repo Repo is the repository, from the :repo path segment.
|
||
@return ProviderAPIPutProviderGithubReposByRepoPagesRequest
|
||
*/
|
||
func (a *ProviderAPIService) PutProviderGithubReposByRepoPages(ctx context.Context, repo string) ProviderAPIPutProviderGithubReposByRepoPagesRequest {
|
||
return ProviderAPIPutProviderGithubReposByRepoPagesRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
repo: repo,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderGithubPagesUpdatedOut
|
||
func (a *ProviderAPIService) PutProviderGithubReposByRepoPagesExecute(r ProviderAPIPutProviderGithubReposByRepoPagesRequest) (*ProviderGithubPagesUpdatedOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPut
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderGithubPagesUpdatedOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PutProviderGithubReposByRepoPages")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/github/repos/{repo}/pages"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"repo"+"}", url.PathEscape(parameterValueToString(r.repo, "repo")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerGithubPagesUpdateReq == nil {
|
||
return localVarReturnValue, nil, reportError("providerGithubPagesUpdateReq 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.providerGithubPagesUpdateReq
|
||
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 ProviderAPIPutProviderSlackMessagesRequest struct {
|
||
ctx context.Context
|
||
ApiService *ProviderAPIService
|
||
providerSlackUpdateMessageIn *ProviderSlackUpdateMessageIn
|
||
}
|
||
|
||
func (r ProviderAPIPutProviderSlackMessagesRequest) ProviderSlackUpdateMessageIn(providerSlackUpdateMessageIn ProviderSlackUpdateMessageIn) ProviderAPIPutProviderSlackMessagesRequest {
|
||
r.providerSlackUpdateMessageIn = &providerSlackUpdateMessageIn
|
||
return r
|
||
}
|
||
|
||
func (r ProviderAPIPutProviderSlackMessagesRequest) Execute() (*ProviderSlackUpdateMessageOut, *http.Response, error) {
|
||
return r.ApiService.PutProviderSlackMessagesExecute(r)
|
||
}
|
||
|
||
/*
|
||
PutProviderSlackMessages Rewrites one of this app's messages: PUT /v1/provider/slack/messages.
|
||
|
||
Rewrites one of this app's messages:
|
||
PUT /v1/provider/slack/messages. Slack refuses a message the token did not
|
||
post, and that refusal is reported as it arrives.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return ProviderAPIPutProviderSlackMessagesRequest
|
||
*/
|
||
func (a *ProviderAPIService) PutProviderSlackMessages(ctx context.Context) ProviderAPIPutProviderSlackMessagesRequest {
|
||
return ProviderAPIPutProviderSlackMessagesRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return ProviderSlackUpdateMessageOut
|
||
func (a *ProviderAPIService) PutProviderSlackMessagesExecute(r ProviderAPIPutProviderSlackMessagesRequest) (*ProviderSlackUpdateMessageOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPut
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *ProviderSlackUpdateMessageOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ProviderAPIService.PutProviderSlackMessages")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/provider/slack/messages"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.providerSlackUpdateMessageIn == nil {
|
||
return localVarReturnValue, nil, reportError("providerSlackUpdateMessageIn 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.providerSlackUpdateMessageIn
|
||
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
|
||
}
|