mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
1051 lines
26 KiB
Go
1051 lines
26 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"
|
|
"encoding/json"
|
|
"encoding/xml"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"mime/multipart"
|
|
"net/http"
|
|
"net/http/httputil"
|
|
"net/url"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
var (
|
|
JsonCheck = regexp.MustCompile(`(?i:(?:application|text)/(?:[^;]+\+)?json)`)
|
|
XmlCheck = regexp.MustCompile(`(?i:(?:application|text)/(?:[^;]+\+)?xml)`)
|
|
queryParamSplit = regexp.MustCompile(`(^|&)([^&]+)`)
|
|
queryDescape = strings.NewReplacer("%5B", "[", "%5D", "]")
|
|
)
|
|
|
|
// APIClient manages communication with the Hanzo Cloud API API vv1
|
|
// In most cases there should be only one, shared, APIClient.
|
|
type APIClient struct {
|
|
cfg *Configuration
|
|
common service // Reuse a single struct instead of allocating one for each service on the heap.
|
|
|
|
// API Services
|
|
|
|
AccountAPI *AccountAPIService
|
|
|
|
AdAPI *AdAPIService
|
|
|
|
AffiliateAPI *AffiliateAPIService
|
|
|
|
AgentAPI *AgentAPIService
|
|
|
|
AiAPI *AiAPIService
|
|
|
|
AllowanceAPI *AllowanceAPIService
|
|
|
|
AskAPI *AskAPIService
|
|
|
|
AuditAPI *AuditAPIService
|
|
|
|
AuthorAPI *AuthorAPIService
|
|
|
|
AuthzAPI *AuthzAPIService
|
|
|
|
AutoAPI *AutoAPIService
|
|
|
|
BaseAPI *BaseAPIService
|
|
|
|
BenchmarkAPI *BenchmarkAPIService
|
|
|
|
BillingAPI *BillingAPIService
|
|
|
|
BlueprintAPI *BlueprintAPIService
|
|
|
|
BooksAPI *BooksAPIService
|
|
|
|
BotAPI *BotAPIService
|
|
|
|
CampaignAPI *CampaignAPIService
|
|
|
|
CaptableAPI *CaptableAPIService
|
|
|
|
CatalogAPI *CatalogAPIService
|
|
|
|
CiAPI *CiAPIService
|
|
|
|
CloudflareAPI *CloudflareAPIService
|
|
|
|
CodeAPI *CodeAPIService
|
|
|
|
CommerceAPI *CommerceAPIService
|
|
|
|
CompanyAPI *CompanyAPIService
|
|
|
|
ComplianceAPI *ComplianceAPIService
|
|
|
|
ComputeAPI *ComputeAPIService
|
|
|
|
ContentAPI *ContentAPIService
|
|
|
|
CrawlAPI *CrawlAPIService
|
|
|
|
DataroomAPI *DataroomAPIService
|
|
|
|
DatasetAPI *DatasetAPIService
|
|
|
|
DeployAPI *DeployAPIService
|
|
|
|
DestinationAPI *DestinationAPIService
|
|
|
|
DnsAPI *DnsAPIService
|
|
|
|
DomainAPI *DomainAPIService
|
|
|
|
EmailAPI *EmailAPIService
|
|
|
|
EngineAPI *EngineAPIService
|
|
|
|
EntitlementAPI *EntitlementAPIService
|
|
|
|
EnvironmentAPI *EnvironmentAPIService
|
|
|
|
EsignAPI *EsignAPIService
|
|
|
|
EvalAPI *EvalAPIService
|
|
|
|
EventAPI *EventAPIService
|
|
|
|
ExecAPI *ExecAPIService
|
|
|
|
ExperimentAPI *ExperimentAPIService
|
|
|
|
ExplorerAPI *ExplorerAPIService
|
|
|
|
FlagAPI *FlagAPIService
|
|
|
|
FlowAPI *FlowAPIService
|
|
|
|
FormAPI *FormAPIService
|
|
|
|
FrameworkAPI *FrameworkAPIService
|
|
|
|
FunctionAPI *FunctionAPIService
|
|
|
|
GatewayAPI *GatewayAPIService
|
|
|
|
GitAPI *GitAPIService
|
|
|
|
GraphAPI *GraphAPIService
|
|
|
|
GuideAPI *GuideAPIService
|
|
|
|
HelpAPI *HelpAPIService
|
|
|
|
IamAPI *IamAPIService
|
|
|
|
IndexAPI *IndexAPIService
|
|
|
|
IngressAPI *IngressAPIService
|
|
|
|
KmsAPI *KmsAPIService
|
|
|
|
KnowledgeAPI *KnowledgeAPIService
|
|
|
|
KvAPI *KvAPIService
|
|
|
|
LabelAPI *LabelAPIService
|
|
|
|
LeaderboardAPI *LeaderboardAPIService
|
|
|
|
LegalAPI *LegalAPIService
|
|
|
|
LibraryAPI *LibraryAPIService
|
|
|
|
LicensingAPI *LicensingAPIService
|
|
|
|
LinkAPI *LinkAPIService
|
|
|
|
LspAPI *LspAPIService
|
|
|
|
MarketAPI *MarketAPIService
|
|
|
|
MarketingAPI *MarketingAPIService
|
|
|
|
MarketplaceAPI *MarketplaceAPIService
|
|
|
|
MeetAPI *MeetAPIService
|
|
|
|
MetricsAPI *MetricsAPIService
|
|
|
|
MlAPI *MlAPIService
|
|
|
|
MqAPI *MqAPIService
|
|
|
|
NetworkAPI *NetworkAPIService
|
|
|
|
NodeAPI *NodeAPIService
|
|
|
|
NotifyAPI *NotifyAPIService
|
|
|
|
O11yAPI *O11yAPIService
|
|
|
|
OpenapiAPI *OpenapiAPIService
|
|
|
|
PatentAPI *PatentAPIService
|
|
|
|
PatrolAPI *PatrolAPIService
|
|
|
|
PlanAPI *PlanAPIService
|
|
|
|
PlatformAPI *PlatformAPIService
|
|
|
|
PrefAPI *PrefAPIService
|
|
|
|
PricingAPI *PricingAPIService
|
|
|
|
PrincipalAPI *PrincipalAPIService
|
|
|
|
ProjectAPI *ProjectAPIService
|
|
|
|
PromptAPI *PromptAPIService
|
|
|
|
ProviderAPI *ProviderAPIService
|
|
|
|
ProvisioningAPI *ProvisioningAPIService
|
|
|
|
PubsubAPI *PubsubAPIService
|
|
|
|
ReferenceAPI *ReferenceAPIService
|
|
|
|
ReferralAPI *ReferralAPIService
|
|
|
|
RegistryAPI *RegistryAPIService
|
|
|
|
RewardAPI *RewardAPIService
|
|
|
|
RiskAPI *RiskAPIService
|
|
|
|
S3API *S3APIService
|
|
|
|
SandboxAPI *SandboxAPIService
|
|
|
|
SbomAPI *SbomAPIService
|
|
|
|
SearchAPI *SearchAPIService
|
|
|
|
SecurityAPI *SecurityAPIService
|
|
|
|
SeoAPI *SeoAPIService
|
|
|
|
SettingsAPI *SettingsAPIService
|
|
|
|
ShareAPI *ShareAPIService
|
|
|
|
SocialAPI *SocialAPIService
|
|
|
|
SpaceAPI *SpaceAPIService
|
|
|
|
StandingAPI *StandingAPIService
|
|
|
|
StudioAPI *StudioAPIService
|
|
|
|
SyncAPI *SyncAPIService
|
|
|
|
TaskAPI *TaskAPIService
|
|
|
|
TaxAPI *TaxAPIService
|
|
|
|
TaxonomyAPI *TaxonomyAPIService
|
|
|
|
TeamAPI *TeamAPIService
|
|
|
|
TelAPI *TelAPIService
|
|
|
|
TemplateAPI *TemplateAPIService
|
|
|
|
ToolAPI *ToolAPIService
|
|
|
|
TrainAPI *TrainAPIService
|
|
|
|
TranslateAPI *TranslateAPIService
|
|
|
|
TransportAPI *TransportAPIService
|
|
|
|
TreasuryAPI *TreasuryAPIService
|
|
|
|
TrustAPI *TrustAPIService
|
|
|
|
UsageAPI *UsageAPIService
|
|
|
|
ValidatorAPI *ValidatorAPIService
|
|
|
|
WalletAPI *WalletAPIService
|
|
|
|
Web3API *Web3APIService
|
|
|
|
WebhookAPI *WebhookAPIService
|
|
|
|
WebsearchAPI *WebsearchAPIService
|
|
|
|
WorkflowAPI *WorkflowAPIService
|
|
|
|
WorldAPI *WorldAPIService
|
|
|
|
X402API *X402APIService
|
|
}
|
|
|
|
type service struct {
|
|
client *APIClient
|
|
}
|
|
|
|
// NewAPIClient creates a new API client. Requires a userAgent string describing your application.
|
|
// optionally a custom http.Client to allow for advanced features such as caching.
|
|
func NewAPIClient(cfg *Configuration) *APIClient {
|
|
if cfg.HTTPClient == nil {
|
|
cfg.HTTPClient = http.DefaultClient
|
|
}
|
|
|
|
c := &APIClient{}
|
|
c.cfg = cfg
|
|
c.common.client = c
|
|
|
|
// API Services
|
|
c.AccountAPI = (*AccountAPIService)(&c.common)
|
|
c.AdAPI = (*AdAPIService)(&c.common)
|
|
c.AffiliateAPI = (*AffiliateAPIService)(&c.common)
|
|
c.AgentAPI = (*AgentAPIService)(&c.common)
|
|
c.AiAPI = (*AiAPIService)(&c.common)
|
|
c.AllowanceAPI = (*AllowanceAPIService)(&c.common)
|
|
c.AskAPI = (*AskAPIService)(&c.common)
|
|
c.AuditAPI = (*AuditAPIService)(&c.common)
|
|
c.AuthorAPI = (*AuthorAPIService)(&c.common)
|
|
c.AuthzAPI = (*AuthzAPIService)(&c.common)
|
|
c.AutoAPI = (*AutoAPIService)(&c.common)
|
|
c.BaseAPI = (*BaseAPIService)(&c.common)
|
|
c.BenchmarkAPI = (*BenchmarkAPIService)(&c.common)
|
|
c.BillingAPI = (*BillingAPIService)(&c.common)
|
|
c.BlueprintAPI = (*BlueprintAPIService)(&c.common)
|
|
c.BooksAPI = (*BooksAPIService)(&c.common)
|
|
c.BotAPI = (*BotAPIService)(&c.common)
|
|
c.CampaignAPI = (*CampaignAPIService)(&c.common)
|
|
c.CaptableAPI = (*CaptableAPIService)(&c.common)
|
|
c.CatalogAPI = (*CatalogAPIService)(&c.common)
|
|
c.CiAPI = (*CiAPIService)(&c.common)
|
|
c.CloudflareAPI = (*CloudflareAPIService)(&c.common)
|
|
c.CodeAPI = (*CodeAPIService)(&c.common)
|
|
c.CommerceAPI = (*CommerceAPIService)(&c.common)
|
|
c.CompanyAPI = (*CompanyAPIService)(&c.common)
|
|
c.ComplianceAPI = (*ComplianceAPIService)(&c.common)
|
|
c.ComputeAPI = (*ComputeAPIService)(&c.common)
|
|
c.ContentAPI = (*ContentAPIService)(&c.common)
|
|
c.CrawlAPI = (*CrawlAPIService)(&c.common)
|
|
c.DataroomAPI = (*DataroomAPIService)(&c.common)
|
|
c.DatasetAPI = (*DatasetAPIService)(&c.common)
|
|
c.DeployAPI = (*DeployAPIService)(&c.common)
|
|
c.DestinationAPI = (*DestinationAPIService)(&c.common)
|
|
c.DnsAPI = (*DnsAPIService)(&c.common)
|
|
c.DomainAPI = (*DomainAPIService)(&c.common)
|
|
c.EmailAPI = (*EmailAPIService)(&c.common)
|
|
c.EngineAPI = (*EngineAPIService)(&c.common)
|
|
c.EntitlementAPI = (*EntitlementAPIService)(&c.common)
|
|
c.EnvironmentAPI = (*EnvironmentAPIService)(&c.common)
|
|
c.EsignAPI = (*EsignAPIService)(&c.common)
|
|
c.EvalAPI = (*EvalAPIService)(&c.common)
|
|
c.EventAPI = (*EventAPIService)(&c.common)
|
|
c.ExecAPI = (*ExecAPIService)(&c.common)
|
|
c.ExperimentAPI = (*ExperimentAPIService)(&c.common)
|
|
c.ExplorerAPI = (*ExplorerAPIService)(&c.common)
|
|
c.FlagAPI = (*FlagAPIService)(&c.common)
|
|
c.FlowAPI = (*FlowAPIService)(&c.common)
|
|
c.FormAPI = (*FormAPIService)(&c.common)
|
|
c.FrameworkAPI = (*FrameworkAPIService)(&c.common)
|
|
c.FunctionAPI = (*FunctionAPIService)(&c.common)
|
|
c.GatewayAPI = (*GatewayAPIService)(&c.common)
|
|
c.GitAPI = (*GitAPIService)(&c.common)
|
|
c.GraphAPI = (*GraphAPIService)(&c.common)
|
|
c.GuideAPI = (*GuideAPIService)(&c.common)
|
|
c.HelpAPI = (*HelpAPIService)(&c.common)
|
|
c.IamAPI = (*IamAPIService)(&c.common)
|
|
c.IndexAPI = (*IndexAPIService)(&c.common)
|
|
c.IngressAPI = (*IngressAPIService)(&c.common)
|
|
c.KmsAPI = (*KmsAPIService)(&c.common)
|
|
c.KnowledgeAPI = (*KnowledgeAPIService)(&c.common)
|
|
c.KvAPI = (*KvAPIService)(&c.common)
|
|
c.LabelAPI = (*LabelAPIService)(&c.common)
|
|
c.LeaderboardAPI = (*LeaderboardAPIService)(&c.common)
|
|
c.LegalAPI = (*LegalAPIService)(&c.common)
|
|
c.LibraryAPI = (*LibraryAPIService)(&c.common)
|
|
c.LicensingAPI = (*LicensingAPIService)(&c.common)
|
|
c.LinkAPI = (*LinkAPIService)(&c.common)
|
|
c.LspAPI = (*LspAPIService)(&c.common)
|
|
c.MarketAPI = (*MarketAPIService)(&c.common)
|
|
c.MarketingAPI = (*MarketingAPIService)(&c.common)
|
|
c.MarketplaceAPI = (*MarketplaceAPIService)(&c.common)
|
|
c.MeetAPI = (*MeetAPIService)(&c.common)
|
|
c.MetricsAPI = (*MetricsAPIService)(&c.common)
|
|
c.MlAPI = (*MlAPIService)(&c.common)
|
|
c.MqAPI = (*MqAPIService)(&c.common)
|
|
c.NetworkAPI = (*NetworkAPIService)(&c.common)
|
|
c.NodeAPI = (*NodeAPIService)(&c.common)
|
|
c.NotifyAPI = (*NotifyAPIService)(&c.common)
|
|
c.O11yAPI = (*O11yAPIService)(&c.common)
|
|
c.OpenapiAPI = (*OpenapiAPIService)(&c.common)
|
|
c.PatentAPI = (*PatentAPIService)(&c.common)
|
|
c.PatrolAPI = (*PatrolAPIService)(&c.common)
|
|
c.PlanAPI = (*PlanAPIService)(&c.common)
|
|
c.PlatformAPI = (*PlatformAPIService)(&c.common)
|
|
c.PrefAPI = (*PrefAPIService)(&c.common)
|
|
c.PricingAPI = (*PricingAPIService)(&c.common)
|
|
c.PrincipalAPI = (*PrincipalAPIService)(&c.common)
|
|
c.ProjectAPI = (*ProjectAPIService)(&c.common)
|
|
c.PromptAPI = (*PromptAPIService)(&c.common)
|
|
c.ProviderAPI = (*ProviderAPIService)(&c.common)
|
|
c.ProvisioningAPI = (*ProvisioningAPIService)(&c.common)
|
|
c.PubsubAPI = (*PubsubAPIService)(&c.common)
|
|
c.ReferenceAPI = (*ReferenceAPIService)(&c.common)
|
|
c.ReferralAPI = (*ReferralAPIService)(&c.common)
|
|
c.RegistryAPI = (*RegistryAPIService)(&c.common)
|
|
c.RewardAPI = (*RewardAPIService)(&c.common)
|
|
c.RiskAPI = (*RiskAPIService)(&c.common)
|
|
c.S3API = (*S3APIService)(&c.common)
|
|
c.SandboxAPI = (*SandboxAPIService)(&c.common)
|
|
c.SbomAPI = (*SbomAPIService)(&c.common)
|
|
c.SearchAPI = (*SearchAPIService)(&c.common)
|
|
c.SecurityAPI = (*SecurityAPIService)(&c.common)
|
|
c.SeoAPI = (*SeoAPIService)(&c.common)
|
|
c.SettingsAPI = (*SettingsAPIService)(&c.common)
|
|
c.ShareAPI = (*ShareAPIService)(&c.common)
|
|
c.SocialAPI = (*SocialAPIService)(&c.common)
|
|
c.SpaceAPI = (*SpaceAPIService)(&c.common)
|
|
c.StandingAPI = (*StandingAPIService)(&c.common)
|
|
c.StudioAPI = (*StudioAPIService)(&c.common)
|
|
c.SyncAPI = (*SyncAPIService)(&c.common)
|
|
c.TaskAPI = (*TaskAPIService)(&c.common)
|
|
c.TaxAPI = (*TaxAPIService)(&c.common)
|
|
c.TaxonomyAPI = (*TaxonomyAPIService)(&c.common)
|
|
c.TeamAPI = (*TeamAPIService)(&c.common)
|
|
c.TelAPI = (*TelAPIService)(&c.common)
|
|
c.TemplateAPI = (*TemplateAPIService)(&c.common)
|
|
c.ToolAPI = (*ToolAPIService)(&c.common)
|
|
c.TrainAPI = (*TrainAPIService)(&c.common)
|
|
c.TranslateAPI = (*TranslateAPIService)(&c.common)
|
|
c.TransportAPI = (*TransportAPIService)(&c.common)
|
|
c.TreasuryAPI = (*TreasuryAPIService)(&c.common)
|
|
c.TrustAPI = (*TrustAPIService)(&c.common)
|
|
c.UsageAPI = (*UsageAPIService)(&c.common)
|
|
c.ValidatorAPI = (*ValidatorAPIService)(&c.common)
|
|
c.WalletAPI = (*WalletAPIService)(&c.common)
|
|
c.Web3API = (*Web3APIService)(&c.common)
|
|
c.WebhookAPI = (*WebhookAPIService)(&c.common)
|
|
c.WebsearchAPI = (*WebsearchAPIService)(&c.common)
|
|
c.WorkflowAPI = (*WorkflowAPIService)(&c.common)
|
|
c.WorldAPI = (*WorldAPIService)(&c.common)
|
|
c.X402API = (*X402APIService)(&c.common)
|
|
|
|
return c
|
|
}
|
|
|
|
func atoi(in string) (int, error) {
|
|
return strconv.Atoi(in)
|
|
}
|
|
|
|
// selectHeaderContentType select a content type from the available list.
|
|
func selectHeaderContentType(contentTypes []string) string {
|
|
if len(contentTypes) == 0 {
|
|
return ""
|
|
}
|
|
if contains(contentTypes, "application/json") {
|
|
return "application/json"
|
|
}
|
|
return contentTypes[0] // use the first content type specified in 'consumes'
|
|
}
|
|
|
|
// selectHeaderAccept join all accept types and return
|
|
func selectHeaderAccept(accepts []string) string {
|
|
if len(accepts) == 0 {
|
|
return ""
|
|
}
|
|
|
|
if contains(accepts, "application/json") {
|
|
return "application/json"
|
|
}
|
|
|
|
return strings.Join(accepts, ",")
|
|
}
|
|
|
|
// contains is a case insensitive match, finding needle in a haystack
|
|
func contains(haystack []string, needle string) bool {
|
|
for _, a := range haystack {
|
|
if strings.EqualFold(a, needle) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Verify optional parameters are of the correct type.
|
|
func typeCheckParameter(obj interface{}, expected string, name string) error {
|
|
// Make sure there is an object.
|
|
if obj == nil {
|
|
return nil
|
|
}
|
|
|
|
// Check the type is as expected.
|
|
if reflect.TypeOf(obj).String() != expected {
|
|
return fmt.Errorf("expected %s to be of type %s but received %s", name, expected, reflect.TypeOf(obj).String())
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func parameterValueToString(obj interface{}, key string) string {
|
|
if reflect.TypeOf(obj).Kind() != reflect.Ptr {
|
|
if actualObj, ok := obj.(interface{ GetActualInstanceValue() interface{} }); ok {
|
|
return fmt.Sprintf("%v", actualObj.GetActualInstanceValue())
|
|
}
|
|
|
|
return fmt.Sprintf("%v", obj)
|
|
}
|
|
var param, ok = obj.(MappedNullable)
|
|
if !ok {
|
|
return ""
|
|
}
|
|
dataMap, err := param.ToMap()
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
return fmt.Sprintf("%v", dataMap[key])
|
|
}
|
|
|
|
// parameterAddToHeaderOrQuery adds the provided object to the request header or url query
|
|
// supporting deep object syntax
|
|
func parameterAddToHeaderOrQuery(headerOrQueryParams interface{}, keyPrefix string, obj interface{}, style string, collectionType string) {
|
|
var v = reflect.ValueOf(obj)
|
|
var value = ""
|
|
if v == reflect.ValueOf(nil) {
|
|
value = "null"
|
|
} else {
|
|
switch v.Kind() {
|
|
case reflect.Invalid:
|
|
value = "invalid"
|
|
|
|
case reflect.Struct:
|
|
if t, ok := obj.(MappedNullable); ok {
|
|
dataMap, err := t.ToMap()
|
|
if err != nil {
|
|
return
|
|
}
|
|
parameterAddToHeaderOrQuery(headerOrQueryParams, keyPrefix, dataMap, style, collectionType)
|
|
return
|
|
}
|
|
if t, ok := obj.(time.Time); ok {
|
|
parameterAddToHeaderOrQuery(headerOrQueryParams, keyPrefix, t.Format(time.RFC3339Nano), style, collectionType)
|
|
return
|
|
}
|
|
value = v.Type().String() + " value"
|
|
case reflect.Slice:
|
|
var indValue = reflect.ValueOf(obj)
|
|
if indValue == reflect.ValueOf(nil) {
|
|
return
|
|
}
|
|
var lenIndValue = indValue.Len()
|
|
for i := 0; i < lenIndValue; i++ {
|
|
var arrayValue = indValue.Index(i)
|
|
var keyPrefixForCollectionType = keyPrefix
|
|
if style == "deepObject" {
|
|
keyPrefixForCollectionType = keyPrefix + "[" + strconv.Itoa(i) + "]"
|
|
}
|
|
parameterAddToHeaderOrQuery(headerOrQueryParams, keyPrefixForCollectionType, arrayValue.Interface(), style, collectionType)
|
|
}
|
|
return
|
|
|
|
case reflect.Map:
|
|
var indValue = reflect.ValueOf(obj)
|
|
if indValue == reflect.ValueOf(nil) {
|
|
return
|
|
}
|
|
iter := indValue.MapRange()
|
|
for iter.Next() {
|
|
k, v := iter.Key(), iter.Value()
|
|
parameterAddToHeaderOrQuery(headerOrQueryParams, fmt.Sprintf("%s[%s]", keyPrefix, k.String()), v.Interface(), style, collectionType)
|
|
}
|
|
return
|
|
|
|
case reflect.Interface:
|
|
fallthrough
|
|
case reflect.Ptr:
|
|
parameterAddToHeaderOrQuery(headerOrQueryParams, keyPrefix, v.Elem().Interface(), style, collectionType)
|
|
return
|
|
|
|
case reflect.Int, reflect.Int8, reflect.Int16,
|
|
reflect.Int32, reflect.Int64:
|
|
value = strconv.FormatInt(v.Int(), 10)
|
|
case reflect.Uint, reflect.Uint8, reflect.Uint16,
|
|
reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
value = strconv.FormatUint(v.Uint(), 10)
|
|
case reflect.Float32, reflect.Float64:
|
|
value = strconv.FormatFloat(v.Float(), 'g', -1, 32)
|
|
case reflect.Bool:
|
|
value = strconv.FormatBool(v.Bool())
|
|
case reflect.String:
|
|
value = v.String()
|
|
default:
|
|
value = v.Type().String() + " value"
|
|
}
|
|
}
|
|
|
|
switch valuesMap := headerOrQueryParams.(type) {
|
|
case url.Values:
|
|
if collectionType == "csv" && valuesMap.Get(keyPrefix) != "" {
|
|
valuesMap.Set(keyPrefix, valuesMap.Get(keyPrefix)+","+value)
|
|
} else {
|
|
valuesMap.Add(keyPrefix, value)
|
|
}
|
|
break
|
|
case map[string]string:
|
|
valuesMap[keyPrefix] = value
|
|
break
|
|
}
|
|
}
|
|
|
|
// helper for converting interface{} parameters to json strings
|
|
func parameterToJson(obj interface{}) (string, error) {
|
|
jsonBuf, err := json.Marshal(obj)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return string(jsonBuf), err
|
|
}
|
|
|
|
// callAPI do the request.
|
|
func (c *APIClient) callAPI(request *http.Request) (*http.Response, error) {
|
|
if c.cfg.Debug {
|
|
dump, err := httputil.DumpRequestOut(request, true)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
log.Printf("\n%s\n", string(dump))
|
|
}
|
|
|
|
resp, err := c.cfg.HTTPClient.Do(request)
|
|
if err != nil {
|
|
return resp, err
|
|
}
|
|
|
|
if c.cfg.Debug {
|
|
dump, err := httputil.DumpResponse(resp, true)
|
|
if err != nil {
|
|
return resp, err
|
|
}
|
|
log.Printf("\n%s\n", string(dump))
|
|
}
|
|
return resp, err
|
|
}
|
|
|
|
// Allow modification of underlying config for alternate implementations and testing
|
|
// Caution: modifying the configuration while live can cause data races and potentially unwanted behavior
|
|
func (c *APIClient) GetConfig() *Configuration {
|
|
return c.cfg
|
|
}
|
|
|
|
type formFile struct {
|
|
fileBytes []byte
|
|
fileName string
|
|
formFileName string
|
|
}
|
|
|
|
// prepareRequest build the request
|
|
func (c *APIClient) prepareRequest(
|
|
ctx context.Context,
|
|
path string, method string,
|
|
postBody interface{},
|
|
headerParams map[string]string,
|
|
queryParams url.Values,
|
|
formParams url.Values,
|
|
formFiles []formFile) (localVarRequest *http.Request, err error) {
|
|
|
|
var body *bytes.Buffer
|
|
|
|
// Detect postBody type and post.
|
|
if postBody != nil {
|
|
contentType := headerParams["Content-Type"]
|
|
if contentType == "" {
|
|
contentType = detectContentType(postBody)
|
|
headerParams["Content-Type"] = contentType
|
|
}
|
|
|
|
body, err = setBody(postBody, contentType)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// add form parameters and file if available.
|
|
if strings.HasPrefix(headerParams["Content-Type"], "multipart/form-data") && len(formParams) > 0 || (len(formFiles) > 0) {
|
|
if body != nil {
|
|
return nil, errors.New("Cannot specify postBody and multipart form at the same time.")
|
|
}
|
|
body = &bytes.Buffer{}
|
|
w := multipart.NewWriter(body)
|
|
|
|
for k, v := range formParams {
|
|
for _, iv := range v {
|
|
if strings.HasPrefix(k, "@") { // file
|
|
err = addFile(w, k[1:], iv)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
} else { // form value
|
|
w.WriteField(k, iv)
|
|
}
|
|
}
|
|
}
|
|
for _, formFile := range formFiles {
|
|
if len(formFile.fileBytes) > 0 && formFile.fileName != "" {
|
|
w.Boundary()
|
|
part, err := w.CreateFormFile(formFile.formFileName, filepath.Base(formFile.fileName))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
_, err = part.Write(formFile.fileBytes)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set the Boundary in the Content-Type
|
|
headerParams["Content-Type"] = w.FormDataContentType()
|
|
|
|
// Set Content-Length
|
|
headerParams["Content-Length"] = fmt.Sprintf("%d", body.Len())
|
|
w.Close()
|
|
}
|
|
|
|
if strings.HasPrefix(headerParams["Content-Type"], "application/x-www-form-urlencoded") && len(formParams) > 0 {
|
|
if body != nil {
|
|
return nil, errors.New("Cannot specify postBody and x-www-form-urlencoded form at the same time.")
|
|
}
|
|
body = &bytes.Buffer{}
|
|
body.WriteString(formParams.Encode())
|
|
// Set Content-Length
|
|
headerParams["Content-Length"] = fmt.Sprintf("%d", body.Len())
|
|
}
|
|
|
|
// Setup path and query parameters
|
|
url, err := url.Parse(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Override request host, if applicable
|
|
if c.cfg.Host != "" {
|
|
url.Host = c.cfg.Host
|
|
}
|
|
|
|
// Override request scheme, if applicable
|
|
if c.cfg.Scheme != "" {
|
|
url.Scheme = c.cfg.Scheme
|
|
}
|
|
|
|
// Adding Query Param
|
|
query := url.Query()
|
|
for k, v := range queryParams {
|
|
for _, iv := range v {
|
|
query.Add(k, iv)
|
|
}
|
|
}
|
|
|
|
// Encode the parameters.
|
|
url.RawQuery = queryParamSplit.ReplaceAllStringFunc(query.Encode(), func(s string) string {
|
|
pieces := strings.Split(s, "=")
|
|
pieces[0] = queryDescape.Replace(pieces[0])
|
|
return strings.Join(pieces, "=")
|
|
})
|
|
|
|
// Generate a new request
|
|
if body != nil {
|
|
localVarRequest, err = http.NewRequest(method, url.String(), body)
|
|
} else {
|
|
localVarRequest, err = http.NewRequest(method, url.String(), nil)
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// add header parameters, if any
|
|
if len(headerParams) > 0 {
|
|
headers := http.Header{}
|
|
for h, v := range headerParams {
|
|
headers[h] = []string{v}
|
|
}
|
|
localVarRequest.Header = headers
|
|
}
|
|
|
|
// Add the user agent to the request.
|
|
localVarRequest.Header.Add("User-Agent", c.cfg.UserAgent)
|
|
|
|
if ctx != nil {
|
|
// add context to the request
|
|
localVarRequest = localVarRequest.WithContext(ctx)
|
|
|
|
// Walk through any authentication.
|
|
|
|
// AccessToken Authentication
|
|
if auth, ok := ctx.Value(ContextAccessToken).(string); ok {
|
|
localVarRequest.Header.Add("Authorization", "Bearer "+auth)
|
|
}
|
|
|
|
}
|
|
|
|
for header, value := range c.cfg.DefaultHeader {
|
|
localVarRequest.Header.Add(header, value)
|
|
}
|
|
return localVarRequest, nil
|
|
}
|
|
|
|
func (c *APIClient) decode(v interface{}, b []byte, contentType string) (err error) {
|
|
if len(b) == 0 {
|
|
return nil
|
|
}
|
|
if s, ok := v.(*string); ok {
|
|
*s = string(b)
|
|
return nil
|
|
}
|
|
if f, ok := v.(*os.File); ok {
|
|
f, err = os.CreateTemp("", "HttpClientFile")
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = f.Write(b)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = f.Seek(0, io.SeekStart)
|
|
return
|
|
}
|
|
if f, ok := v.(**os.File); ok {
|
|
*f, err = os.CreateTemp("", "HttpClientFile")
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = (*f).Write(b)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = (*f).Seek(0, io.SeekStart)
|
|
return
|
|
}
|
|
if XmlCheck.MatchString(contentType) {
|
|
if err = xml.Unmarshal(b, v); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
if JsonCheck.MatchString(contentType) {
|
|
if actualObj, ok := v.(interface{ GetActualInstance() interface{} }); ok { // oneOf, anyOf schemas
|
|
if unmarshalObj, ok := actualObj.(interface{ UnmarshalJSON([]byte) error }); ok { // make sure it has UnmarshalJSON defined
|
|
if err = unmarshalObj.UnmarshalJSON(b); err != nil {
|
|
return err
|
|
}
|
|
} else {
|
|
return errors.New("Unknown type with GetActualInstance but no unmarshalObj.UnmarshalJSON defined")
|
|
}
|
|
} else if err = json.Unmarshal(b, v); err != nil { // simple model
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
return errors.New("undefined response type")
|
|
}
|
|
|
|
// Add a file to the multipart request
|
|
func addFile(w *multipart.Writer, fieldName, path string) error {
|
|
file, err := os.Open(filepath.Clean(path))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = file.Close()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
part, err := w.CreateFormFile(fieldName, filepath.Base(path))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = io.Copy(part, file)
|
|
|
|
return err
|
|
}
|
|
|
|
// Set request body from an interface{}
|
|
func setBody(body interface{}, contentType string) (bodyBuf *bytes.Buffer, err error) {
|
|
if bodyBuf == nil {
|
|
bodyBuf = &bytes.Buffer{}
|
|
}
|
|
|
|
if reader, ok := body.(io.Reader); ok {
|
|
_, err = bodyBuf.ReadFrom(reader)
|
|
} else if fp, ok := body.(*os.File); ok {
|
|
_, err = bodyBuf.ReadFrom(fp)
|
|
} else if b, ok := body.([]byte); ok {
|
|
_, err = bodyBuf.Write(b)
|
|
} else if s, ok := body.(string); ok {
|
|
_, err = bodyBuf.WriteString(s)
|
|
} else if s, ok := body.(*string); ok {
|
|
_, err = bodyBuf.WriteString(*s)
|
|
} else if JsonCheck.MatchString(contentType) {
|
|
err = json.NewEncoder(bodyBuf).Encode(body)
|
|
} else if XmlCheck.MatchString(contentType) {
|
|
var bs []byte
|
|
bs, err = xml.Marshal(body)
|
|
if err == nil {
|
|
bodyBuf.Write(bs)
|
|
}
|
|
}
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if bodyBuf.Len() == 0 {
|
|
err = fmt.Errorf("invalid body type %s\n", contentType)
|
|
return nil, err
|
|
}
|
|
return bodyBuf, nil
|
|
}
|
|
|
|
// detectContentType method is used to figure out `Request.Body` content type for request header
|
|
func detectContentType(body interface{}) string {
|
|
contentType := "text/plain; charset=utf-8"
|
|
kind := reflect.TypeOf(body).Kind()
|
|
|
|
switch kind {
|
|
case reflect.Struct, reflect.Map, reflect.Ptr:
|
|
contentType = "application/json; charset=utf-8"
|
|
case reflect.String:
|
|
contentType = "text/plain; charset=utf-8"
|
|
default:
|
|
if b, ok := body.([]byte); ok {
|
|
contentType = http.DetectContentType(b)
|
|
} else if kind == reflect.Slice {
|
|
contentType = "application/json; charset=utf-8"
|
|
}
|
|
}
|
|
|
|
return contentType
|
|
}
|
|
|
|
// Ripped from https://github.com/gregjones/httpcache/blob/master/httpcache.go
|
|
type cacheControl map[string]string
|
|
|
|
func parseCacheControl(headers http.Header) cacheControl {
|
|
cc := cacheControl{}
|
|
ccHeader := headers.Get("Cache-Control")
|
|
for _, part := range strings.Split(ccHeader, ",") {
|
|
part = strings.Trim(part, " ")
|
|
if part == "" {
|
|
continue
|
|
}
|
|
if strings.ContainsRune(part, '=') {
|
|
keyval := strings.Split(part, "=")
|
|
cc[strings.Trim(keyval[0], " ")] = strings.Trim(keyval[1], ",")
|
|
} else {
|
|
cc[part] = ""
|
|
}
|
|
}
|
|
return cc
|
|
}
|
|
|
|
// CacheExpires helper function to determine remaining time before repeating a request.
|
|
func CacheExpires(r *http.Response) time.Time {
|
|
// Figure out when the cache expires.
|
|
var expires time.Time
|
|
now, err := time.Parse(time.RFC1123, r.Header.Get("date"))
|
|
if err != nil {
|
|
return time.Now()
|
|
}
|
|
respCacheControl := parseCacheControl(r.Header)
|
|
|
|
if maxAge, ok := respCacheControl["max-age"]; ok {
|
|
lifetime, err := time.ParseDuration(maxAge + "s")
|
|
if err != nil {
|
|
expires = now
|
|
} else {
|
|
expires = now.Add(lifetime)
|
|
}
|
|
} else {
|
|
expiresHeader := r.Header.Get("Expires")
|
|
if expiresHeader != "" {
|
|
expires, err = time.Parse(time.RFC1123, expiresHeader)
|
|
if err != nil {
|
|
expires = now
|
|
}
|
|
}
|
|
}
|
|
return expires
|
|
}
|
|
|
|
func strlen(s string) int {
|
|
return utf8.RuneCountInString(s)
|
|
}
|
|
|
|
// GenericOpenAPIError Provides access to the body, error and model on returned errors.
|
|
type GenericOpenAPIError struct {
|
|
body []byte
|
|
error string
|
|
model interface{}
|
|
}
|
|
|
|
// Error returns non-empty string if there was an error.
|
|
func (e GenericOpenAPIError) Error() string {
|
|
return e.error
|
|
}
|
|
|
|
// Body returns the raw bytes of the response
|
|
func (e GenericOpenAPIError) Body() []byte {
|
|
return e.body
|
|
}
|
|
|
|
// Model returns the unpacked model of the error
|
|
func (e GenericOpenAPIError) Model() interface{} {
|
|
return e.model
|
|
}
|
|
|
|
// format error message using title and detail when model implements rfc7807
|
|
func formatErrorMessage(status string, v interface{}) string {
|
|
str := ""
|
|
metaValue := reflect.ValueOf(v).Elem()
|
|
|
|
if metaValue.Kind() == reflect.Struct {
|
|
field := metaValue.FieldByName("Title")
|
|
if field != (reflect.Value{}) {
|
|
str = fmt.Sprintf("%s", field.Interface())
|
|
}
|
|
|
|
field = metaValue.FieldByName("Detail")
|
|
if field != (reflect.Value{}) {
|
|
str = fmt.Sprintf("%s (%s)", str, field.Interface())
|
|
}
|
|
}
|
|
|
|
return strings.TrimSpace(fmt.Sprintf("%s %s", status, str))
|
|
}
|