loafle/openapi-generator
3
0
Fork 0
forked from loafle/openapi-generator-original
Code Pull Requests Activity

Revert "[GO][Client] return GenericOpenAPIError instead of error in Execute() (#8137)" (#8427)

Browse Source 
This reverts commit 1562afea3980484a7f1819c4f51b0d53a44a009f.
This commit is contained in:
William Cheng 2021-01-14 13:59:21 +08:00 committed by GitHub
parent 2b7ae4fa46
commit 22ac8faec7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
42 changed files with 898 additions and 1478 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
modules/openapi-generator/src/main/resources/go/api.mustache vendored
View File

@ -3,7 +3,6 @@ package {{packageName}}
{{#operations}} {{#operations}}
import ( import (
"bytes"
_context "context" _context "context"
_ioutil "io/ioutil" _ioutil "io/ioutil"
_nethttp "net/http" _nethttp "net/http"
@ -36,7 +35,7 @@ type {{classname}} interface {
* {{nickname}}Execute executes the request{{#returnType}} * {{nickname}}Execute executes the request{{#returnType}}
* @return {{{.}}}{{/returnType}} * @return {{{.}}}{{/returnType}}
*/ */
{{nickname}}Execute(r {{#structPrefix}}{{&classname}}{{/structPrefix}}Api{{operationId}}Request) ({{#returnType}}{{{.}}}, {{/returnType}}*_nethttp.Response, GenericOpenAPIError) {{nickname}}Execute(r {{#structPrefix}}{{&classname}}{{/structPrefix}}Api{{operationId}}Request) ({{#returnType}}{{{.}}}, {{/returnType}}*_nethttp.Response, error)
{{/operation}} {{/operation}}
} }
{{/generateInterfaces}} {{/generateInterfaces}}
@ -61,7 +60,7 @@ func (r {{#structPrefix}}{{&classname}}{{/structPrefix}}Api{{operationId}}Reques
return r return r
}{{/isPathParam}}{{/allParams}} }{{/isPathParam}}{{/allParams}}
func (r {{#structPrefix}}{{&classname}}{{/structPrefix}}Api{{operationId}}Request) Execute() ({{#returnType}}{{{.}}}, {{/returnType}}*_nethttp.Response, GenericOpenAPIError) { func (r {{#structPrefix}}{{&classname}}{{/structPrefix}}Api{{operationId}}Request) Execute() ({{#returnType}}{{{.}}}, {{/returnType}}*_nethttp.Response, error) {
return r.ApiService.{{nickname}}Execute(r) return r.ApiService.{{nickname}}Execute(r)
} }
@ -86,14 +85,13 @@ func (a *{{{classname}}}Service) {{{nickname}}}(ctx _context.Context{{#pathParam
* Execute executes the request{{#returnType}} * Execute executes the request{{#returnType}}
* @return {{{.}}}{{/returnType}} * @return {{{.}}}{{/returnType}}
*/ */
func (a *{{{classname}}}Service) {{nickname}}Execute(r {{#structPrefix}}{{&classname}}{{/structPrefix}}Api{{operationId}}Request) ({{#returnType}}{{{.}}}, {{/returnType}}*_nethttp.Response, GenericOpenAPIError) { func (a *{{{classname}}}Service) {{nickname}}Execute(r {{#structPrefix}}{{&classname}}{{/structPrefix}}Api{{operationId}}Request) ({{#returnType}}{{{.}}}, {{/returnType}}*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.Method{{httpMethod}} localVarHTTPMethod = _nethttp.Method{{httpMethod}}
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
{{#returnType}} {{#returnType}}
localVarReturnValue {{{.}}} localVarReturnValue {{{.}}}
{{/returnType}} {{/returnType}}
@ -101,8 +99,7 @@ func (a *{{{classname}}}Service) {{nickname}}Execute(r {{#structPrefix}}{{&class
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "{{{classname}}}Service.{{{nickname}}}") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "{{{classname}}}Service.{{{nickname}}}")
if err != nil { if err != nil {
executionError.error = err.Error() return {{#returnType}}localVarReturnValue, {{/returnType}}nil, GenericOpenAPIError{error: err.Error()}
return {{#returnType}}localVarReturnValue, {{/returnType}}nil, executionError
} }
localVarPath := localBasePath + "{{{path}}}"{{#pathParams}} localVarPath := localBasePath + "{{{path}}}"{{#pathParams}}
@ -115,32 +112,27 @@ func (a *{{{classname}}}Service) {{nickname}}Execute(r {{#structPrefix}}{{&class
{{#required}} {{#required}}
{{^isPathParam}} {{^isPathParam}}
if r.{{paramName}} == nil { if r.{{paramName}} == nil {
executionError.error = "{{paramName}} is required and must be specified" return {{#returnType}}localVarReturnValue, {{/returnType}}nil, reportError("{{paramName}} is required and must be specified")
return {{#returnType}}localVarReturnValue, {{/returnType}}nil, executionError
} }
{{/isPathParam}} {{/isPathParam}}
{{#minItems}} {{#minItems}}
if len({{^isPathParam}}*{{/isPathParam}}r.{{paramName}}) < {{minItems}} { if len({{^isPathParam}}*{{/isPathParam}}r.{{paramName}}) < {{minItems}} {
executionError.error = "{{paramName}} must have at least {{minItems}} elements" return {{#returnType}}localVarReturnValue, {{/returnType}}nil, reportError("{{paramName}} must have at least {{minItems}} elements")
return {{#returnType}}localVarReturnValue, {{/returnType}}nil, executionError
} }
{{/minItems}} {{/minItems}}
{{#maxItems}} {{#maxItems}}
if len({{^isPathParam}}*{{/isPathParam}}r.{{paramName}}) > {{maxItems}} { if len({{^isPathParam}}*{{/isPathParam}}r.{{paramName}}) > {{maxItems}} {
executionError.error = "{{paramName}} must have less than {{maxItems}} elements" return {{#returnType}}localVarReturnValue, {{/returnType}}nil, reportError("{{paramName}} must have less than {{maxItems}} elements")
return {{#returnType}}localVarReturnValue, {{/returnType}}nil, executionError
} }
{{/maxItems}} {{/maxItems}}
{{#minLength}} {{#minLength}}
if strlen({{^isPathParam}}*{{/isPathParam}}r.{{paramName}}) < {{minLength}} { if strlen({{^isPathParam}}*{{/isPathParam}}r.{{paramName}}) < {{minLength}} {
executionError.error = "{{paramName}} must have at least {{minLength}} elements" return {{#returnType}}localVarReturnValue, {{/returnType}}nil, reportError("{{paramName}} must have at least {{minLength}} elements")
return {{#returnType}}localVarReturnValue, {{/returnType}}nil, executionError
} }
{{/minLength}} {{/minLength}}
{{#maxLength}} {{#maxLength}}
if strlen({{^isPathParam}}*{{/isPathParam}}r.{{paramName}}) > {{maxLength}} { if strlen({{^isPathParam}}*{{/isPathParam}}r.{{paramName}}) > {{maxLength}} {
executionError.error = "{{paramName}} must have less than {{maxLength}} elements" return {{#returnType}}localVarReturnValue, {{/returnType}}nil, reportError("{{paramName}} must have less than {{maxLength}} elements")
return {{#returnType}}localVarReturnValue, {{/returnType}}nil, executionError
} }
{{/maxLength}} {{/maxLength}}
{{#minimum}} {{#minimum}}
@ -151,8 +143,7 @@ func (a *{{{classname}}}Service) {{nickname}}Execute(r {{#structPrefix}}{{&class
{{^isString}} {{^isString}}
if {{^isPathParam}}*{{/isPathParam}}r.{{paramName}} < {{minimum}} { if {{^isPathParam}}*{{/isPathParam}}r.{{paramName}} < {{minimum}} {
{{/isString}} {{/isString}}
executionError.error = "{{paramName}} must be greater than {{minimum}}" return {{#returnType}}localVarReturnValue, {{/returnType}}nil, reportError("{{paramName}} must be greater than {{minimum}}")
return {{#returnType}}localVarReturnValue, {{/returnType}}nil, executionError
} }
{{/minimum}} {{/minimum}}
{{#maximum}} {{#maximum}}
@ -163,8 +154,7 @@ func (a *{{{classname}}}Service) {{nickname}}Execute(r {{#structPrefix}}{{&class
{{^isString}} {{^isString}}
if {{^isPathParam}}*{{/isPathParam}}r.{{paramName}} > {{maximum}} { if {{^isPathParam}}*{{/isPathParam}}r.{{paramName}} > {{maximum}} {
{{/isString}} {{/isString}}
executionError.error = "{{paramName}} must be less than {{maximum}}" return {{#returnType}}localVarReturnValue, {{/returnType}}nil, reportError("{{paramName}} must be less than {{maximum}}")
return {{#returnType}}localVarReturnValue, {{/returnType}}nil, executionError
} }
{{/maximum}} {{/maximum}}
{{/required}} {{/required}}
@ -267,8 +257,7 @@ func (a *{{{classname}}}Service) {{nickname}}Execute(r {{#structPrefix}}{{&class
if r.{{paramName}} != nil { if r.{{paramName}} != nil {
paramJson, err := parameterToJson(*r.{{paramName}}) paramJson, err := parameterToJson(*r.{{paramName}})
if err != nil { if err != nil {
executionError.error = err.Error() return {{#returnType}}localVarReturnValue, {{/returnType}}nil, err
return {{#returnType}}localVarReturnValue, {{/returnType}}nil, executionError
} }
localVarFormParams.Add("{{baseName}}", paramJson) localVarFormParams.Add("{{baseName}}", paramJson)
} }
@ -323,22 +312,18 @@ func (a *{{{classname}}}Service) {{nickname}}Execute(r {{#structPrefix}}{{&class
{{/authMethods}} {{/authMethods}}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return {{#returnType}}localVarReturnValue, {{/returnType}}nil, err
return {{#returnType}}localVarReturnValue, {{/returnType}}nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return {{#returnType}}localVarReturnValue, {{/returnType}}localVarHTTPResponse, err
return {{#returnType}}localVarReturnValue, {{/returnType}}localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return {{#returnType}}localVarReturnValue, {{/returnType}}localVarHTTPResponse, err
return {{#returnType}}localVarReturnValue, {{/returnType}}localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -384,7 +369,7 @@ func (a *{{{classname}}}Service) {{nickname}}Execute(r {{#structPrefix}}{{&class
} }
{{/returnType}} {{/returnType}}
return {{#returnType}}localVarReturnValue, {{/returnType}}localVarHTTPResponse, executionError return {{#returnType}}localVarReturnValue, {{/returnType}}localVarHTTPResponse, nil
} }
{{/operation}} {{/operation}}
{{/operations}} {{/operations}}

2
modules/openapi-generator/src/main/resources/go/api_doc.mustache vendored
View File

@ -43,7 +43,7 @@ func main() {
configuration := {{goImportAlias}}.NewConfiguration() configuration := {{goImportAlias}}.NewConfiguration()
api_client := {{goImportAlias}}.NewAPIClient(configuration) api_client := {{goImportAlias}}.NewAPIClient(configuration)
resp, r, err := api_client.{{classname}}.{{operationId}}(context.Background(){{#pathParams}}, {{paramName}}{{/pathParams}}){{#allParams}}{{^isPathParam}}.{{vendorExtensions.x-export-param-name}}({{paramName}}){{/isPathParam}}{{/allParams}}.Execute() resp, r, err := api_client.{{classname}}.{{operationId}}(context.Background(){{#pathParams}}, {{paramName}}{{/pathParams}}){{#allParams}}{{^isPathParam}}.{{vendorExtensions.x-export-param-name}}({{paramName}}){{/isPathParam}}{{/allParams}}.Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `{{classname}}.{{operationId}}``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `{{classname}}.{{operationId}}``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }

32
samples/client/petstore/go/auth_test.go
View File

@ -43,7 +43,7 @@ func TestOAuth2(t *testing.T) {
r, err := client.PetApi.AddPet(context.Background()).Body(newPet).Execute() r, err := client.PetApi.AddPet(context.Background()).Body(newPet).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -52,7 +52,7 @@ func TestOAuth2(t *testing.T) {
r, err = client.PetApi.DeletePet(auth, 12992).Execute() r, err = client.PetApi.DeletePet(auth, 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -78,7 +78,7 @@ func TestBasicAuth(t *testing.T) {
r, err := client.PetApi.AddPet(auth).Body(newPet).Execute() r, err := client.PetApi.AddPet(auth).Body(newPet).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -87,7 +87,7 @@ func TestBasicAuth(t *testing.T) {
r, err = client.PetApi.DeletePet(auth, 12992).Execute() r, err = client.PetApi.DeletePet(auth, 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -108,7 +108,7 @@ func TestAccessToken(t *testing.T) {
r, err := client.PetApi.AddPet(nil).Body(newPet).Execute() r, err := client.PetApi.AddPet(nil).Body(newPet).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -117,7 +117,7 @@ func TestAccessToken(t *testing.T) {
r, err = client.PetApi.DeletePet(auth, 12992).Execute() r, err = client.PetApi.DeletePet(auth, 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -138,7 +138,7 @@ func TestAPIKeyNoPrefix(t *testing.T) {
r, err := client.PetApi.AddPet(context.Background()).Body(newPet).Execute() r, err := client.PetApi.AddPet(context.Background()).Body(newPet).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -146,7 +146,7 @@ func TestAPIKeyNoPrefix(t *testing.T) {
} }
_, r, err = client.PetApi.GetPetById(auth, 12992).Execute() _, r, err = client.PetApi.GetPetById(auth, 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
@ -156,7 +156,7 @@ func TestAPIKeyNoPrefix(t *testing.T) {
} }
r, err = client.PetApi.DeletePet(auth, 12992).Execute() r, err = client.PetApi.DeletePet(auth, 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -173,7 +173,7 @@ func TestAPIKeyWithPrefix(t *testing.T) {
r, err := client.PetApi.AddPet(nil).Body(newPet).Execute() r, err := client.PetApi.AddPet(nil).Body(newPet).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -181,7 +181,7 @@ func TestAPIKeyWithPrefix(t *testing.T) {
} }
_, r, err = client.PetApi.GetPetById(auth, 12992).Execute() _, r, err = client.PetApi.GetPetById(auth, 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
@ -191,7 +191,7 @@ func TestAPIKeyWithPrefix(t *testing.T) {
} }
r, err = client.PetApi.DeletePet(auth, 12992).Execute() r, err = client.PetApi.DeletePet(auth, 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -206,7 +206,7 @@ func TestDefaultHeader(t *testing.T) {
r, err := client.PetApi.AddPet(context.Background()).Body(newPet).Execute() r, err := client.PetApi.AddPet(context.Background()).Body(newPet).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -215,7 +215,7 @@ func TestDefaultHeader(t *testing.T) {
r, err = client.PetApi.DeletePet(context.Background(), 12992).Execute() r, err = client.PetApi.DeletePet(context.Background(), 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -230,7 +230,7 @@ func TestDefaultHeader(t *testing.T) {
func TestHostOverride(t *testing.T) { func TestHostOverride(t *testing.T) {
_, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status(nil).Execute() _, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status(nil).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while finding pets by status: %v", err) t.Fatalf("Error while finding pets by status: %v", err)
} }
@ -242,7 +242,7 @@ func TestHostOverride(t *testing.T) {
func TestSchemeOverride(t *testing.T) { func TestSchemeOverride(t *testing.T) {
_, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status(nil).Execute() _, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status(nil).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while finding pets by status: %v", err) t.Fatalf("Error while finding pets by status: %v", err)
} }

2
samples/client/petstore/go/fake_api_test.go
View File

@ -19,7 +19,7 @@ func TestPutBodyWithFileSchema(t *testing.T) {
r, err := client.FakeApi.TestBodyWithFileSchema(context.Background()).Body(schema).Execute() r, err := client.FakeApi.TestBodyWithFileSchema(context.Background()).Body(schema).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {

26
samples/client/petstore/go/go-petstore/api_another_fake.go
View File

@ -11,7 +11,6 @@
package petstore package petstore
import ( import (
"bytes"
_context "context" _context "context"
_ioutil "io/ioutil" _ioutil "io/ioutil"
_nethttp "net/http" _nethttp "net/http"
@ -37,7 +36,7 @@ type AnotherFakeApi interface {
* Call123TestSpecialTagsExecute executes the request * Call123TestSpecialTagsExecute executes the request
* @return Client * @return Client
*/ */
Call123TestSpecialTagsExecute(r ApiCall123TestSpecialTagsRequest) (Client, *_nethttp.Response, GenericOpenAPIError) Call123TestSpecialTagsExecute(r ApiCall123TestSpecialTagsRequest) (Client, *_nethttp.Response, error)
} }
// AnotherFakeApiService AnotherFakeApi service // AnotherFakeApiService AnotherFakeApi service
@ -54,7 +53,7 @@ func (r ApiCall123TestSpecialTagsRequest) Body(body Client) ApiCall123TestSpecia
return r return r
} }
func (r ApiCall123TestSpecialTagsRequest) Execute() (Client, *_nethttp.Response, GenericOpenAPIError) { func (r ApiCall123TestSpecialTagsRequest) Execute() (Client, *_nethttp.Response, error) {
return r.ApiService.Call123TestSpecialTagsExecute(r) return r.ApiService.Call123TestSpecialTagsExecute(r)
} }
@ -75,21 +74,19 @@ func (a *AnotherFakeApiService) Call123TestSpecialTags(ctx _context.Context) Api
* Execute executes the request * Execute executes the request
* @return Client * @return Client
*/ */
func (a *AnotherFakeApiService) Call123TestSpecialTagsExecute(r ApiCall123TestSpecialTagsRequest) (Client, *_nethttp.Response, GenericOpenAPIError) { func (a *AnotherFakeApiService) Call123TestSpecialTagsExecute(r ApiCall123TestSpecialTagsRequest) (Client, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPatch localVarHTTPMethod = _nethttp.MethodPatch
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue Client localVarReturnValue Client
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AnotherFakeApiService.Call123TestSpecialTags") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AnotherFakeApiService.Call123TestSpecialTags")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/another-fake/dummy" localVarPath := localBasePath + "/another-fake/dummy"
@ -98,8 +95,7 @@ func (a *AnotherFakeApiService) Call123TestSpecialTagsExecute(r ApiCall123TestSp
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.body == nil { if r.body == nil {
executionError.error = "body is required and must be specified" return localVarReturnValue, nil, reportError("body is required and must be specified")
return localVarReturnValue, nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -123,22 +119,18 @@ func (a *AnotherFakeApiService) Call123TestSpecialTagsExecute(r ApiCall123TestSp
localVarPostBody = r.body localVarPostBody = r.body
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -158,5 +150,5 @@ func (a *AnotherFakeApiService) Call123TestSpecialTagsExecute(r ApiCall123TestSp
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }

381
samples/client/petstore/go/go-petstore/api_fake.go
View File

File diff suppressed because it is too large Load Diff

26
samples/client/petstore/go/go-petstore/api_fake_classname_tags123.go
View File

@ -11,7 +11,6 @@
package petstore package petstore
import ( import (
"bytes"
_context "context" _context "context"
_ioutil "io/ioutil" _ioutil "io/ioutil"
_nethttp "net/http" _nethttp "net/http"
@ -37,7 +36,7 @@ type FakeClassnameTags123Api interface {
* TestClassnameExecute executes the request * TestClassnameExecute executes the request
* @return Client * @return Client
*/ */
TestClassnameExecute(r ApiTestClassnameRequest) (Client, *_nethttp.Response, GenericOpenAPIError) TestClassnameExecute(r ApiTestClassnameRequest) (Client, *_nethttp.Response, error)
} }
// FakeClassnameTags123ApiService FakeClassnameTags123Api service // FakeClassnameTags123ApiService FakeClassnameTags123Api service
@ -54,7 +53,7 @@ func (r ApiTestClassnameRequest) Body(body Client) ApiTestClassnameRequest {
return r return r
} }
func (r ApiTestClassnameRequest) Execute() (Client, *_nethttp.Response, GenericOpenAPIError) { func (r ApiTestClassnameRequest) Execute() (Client, *_nethttp.Response, error) {
return r.ApiService.TestClassnameExecute(r) return r.ApiService.TestClassnameExecute(r)
} }
@ -75,21 +74,19 @@ func (a *FakeClassnameTags123ApiService) TestClassname(ctx _context.Context) Api
* Execute executes the request * Execute executes the request
* @return Client * @return Client
*/ */
func (a *FakeClassnameTags123ApiService) TestClassnameExecute(r ApiTestClassnameRequest) (Client, *_nethttp.Response, GenericOpenAPIError) { func (a *FakeClassnameTags123ApiService) TestClassnameExecute(r ApiTestClassnameRequest) (Client, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPatch localVarHTTPMethod = _nethttp.MethodPatch
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue Client localVarReturnValue Client
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FakeClassnameTags123ApiService.TestClassname") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FakeClassnameTags123ApiService.TestClassname")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/fake_classname_test" localVarPath := localBasePath + "/fake_classname_test"
@ -98,8 +95,7 @@ func (a *FakeClassnameTags123ApiService) TestClassnameExecute(r ApiTestClassname
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.body == nil { if r.body == nil {
executionError.error = "body is required and must be specified" return localVarReturnValue, nil, reportError("body is required and must be specified")
return localVarReturnValue, nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -137,22 +133,18 @@ func (a *FakeClassnameTags123ApiService) TestClassnameExecute(r ApiTestClassname
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -172,5 +164,5 @@ func (a *FakeClassnameTags123ApiService) TestClassnameExecute(r ApiTestClassname
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }

214
samples/client/petstore/go/go-petstore/api_pet.go
View File

@ -11,7 +11,6 @@
package petstore package petstore
import ( import (
"bytes"
_context "context" _context "context"
_ioutil "io/ioutil" _ioutil "io/ioutil"
_nethttp "net/http" _nethttp "net/http"
@ -37,7 +36,7 @@ type PetApi interface {
/* /*
* AddPetExecute executes the request * AddPetExecute executes the request
*/ */
AddPetExecute(r ApiAddPetRequest) (*_nethttp.Response, GenericOpenAPIError) AddPetExecute(r ApiAddPetRequest) (*_nethttp.Response, error)
/* /*
* DeletePet Deletes a pet * DeletePet Deletes a pet
@ -50,7 +49,7 @@ type PetApi interface {
/* /*
* DeletePetExecute executes the request * DeletePetExecute executes the request
*/ */
DeletePetExecute(r ApiDeletePetRequest) (*_nethttp.Response, GenericOpenAPIError) DeletePetExecute(r ApiDeletePetRequest) (*_nethttp.Response, error)
/* /*
* FindPetsByStatus Finds Pets by status * FindPetsByStatus Finds Pets by status
@ -64,7 +63,7 @@ type PetApi interface {
* FindPetsByStatusExecute executes the request * FindPetsByStatusExecute executes the request
* @return []Pet * @return []Pet
*/ */
FindPetsByStatusExecute(r ApiFindPetsByStatusRequest) ([]Pet, *_nethttp.Response, GenericOpenAPIError) FindPetsByStatusExecute(r ApiFindPetsByStatusRequest) ([]Pet, *_nethttp.Response, error)
/* /*
* FindPetsByTags Finds Pets by tags * FindPetsByTags Finds Pets by tags
@ -78,7 +77,7 @@ type PetApi interface {
* FindPetsByTagsExecute executes the request * FindPetsByTagsExecute executes the request
* @return []Pet * @return []Pet
*/ */
FindPetsByTagsExecute(r ApiFindPetsByTagsRequest) ([]Pet, *_nethttp.Response, GenericOpenAPIError) FindPetsByTagsExecute(r ApiFindPetsByTagsRequest) ([]Pet, *_nethttp.Response, error)
/* /*
* GetPetById Find pet by ID * GetPetById Find pet by ID
@ -93,7 +92,7 @@ type PetApi interface {
* GetPetByIdExecute executes the request * GetPetByIdExecute executes the request
* @return Pet * @return Pet
*/ */
GetPetByIdExecute(r ApiGetPetByIdRequest) (Pet, *_nethttp.Response, GenericOpenAPIError) GetPetByIdExecute(r ApiGetPetByIdRequest) (Pet, *_nethttp.Response, error)
/* /*
* UpdatePet Update an existing pet * UpdatePet Update an existing pet
@ -105,7 +104,7 @@ type PetApi interface {
/* /*
* UpdatePetExecute executes the request * UpdatePetExecute executes the request
*/ */
UpdatePetExecute(r ApiUpdatePetRequest) (*_nethttp.Response, GenericOpenAPIError) UpdatePetExecute(r ApiUpdatePetRequest) (*_nethttp.Response, error)
/* /*
* UpdatePetWithForm Updates a pet in the store with form data * UpdatePetWithForm Updates a pet in the store with form data
@ -118,7 +117,7 @@ type PetApi interface {
/* /*
* UpdatePetWithFormExecute executes the request * UpdatePetWithFormExecute executes the request
*/ */
UpdatePetWithFormExecute(r ApiUpdatePetWithFormRequest) (*_nethttp.Response, GenericOpenAPIError) UpdatePetWithFormExecute(r ApiUpdatePetWithFormRequest) (*_nethttp.Response, error)
/* /*
* UploadFile uploads an image * UploadFile uploads an image
@ -132,7 +131,7 @@ type PetApi interface {
* UploadFileExecute executes the request * UploadFileExecute executes the request
* @return ApiResponse * @return ApiResponse
*/ */
UploadFileExecute(r ApiUploadFileRequest) (ApiResponse, *_nethttp.Response, GenericOpenAPIError) UploadFileExecute(r ApiUploadFileRequest) (ApiResponse, *_nethttp.Response, error)
/* /*
* UploadFileWithRequiredFile uploads an image (required) * UploadFileWithRequiredFile uploads an image (required)
@ -146,7 +145,7 @@ type PetApi interface {
* UploadFileWithRequiredFileExecute executes the request * UploadFileWithRequiredFileExecute executes the request
* @return ApiResponse * @return ApiResponse
*/ */
UploadFileWithRequiredFileExecute(r ApiUploadFileWithRequiredFileRequest) (ApiResponse, *_nethttp.Response, GenericOpenAPIError) UploadFileWithRequiredFileExecute(r ApiUploadFileWithRequiredFileRequest) (ApiResponse, *_nethttp.Response, error)
} }
// PetApiService PetApi service // PetApiService PetApi service
@ -163,7 +162,7 @@ func (r ApiAddPetRequest) Body(body Pet) ApiAddPetRequest {
return r return r
} }
func (r ApiAddPetRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiAddPetRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.AddPetExecute(r) return r.ApiService.AddPetExecute(r)
} }
@ -182,20 +181,18 @@ func (a *PetApiService) AddPet(ctx _context.Context) ApiAddPetRequest {
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *PetApiService) AddPetExecute(r ApiAddPetRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) AddPetExecute(r ApiAddPetRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.AddPet") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.AddPet")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/pet" localVarPath := localBasePath + "/pet"
@ -204,8 +201,7 @@ func (a *PetApiService) AddPetExecute(r ApiAddPetRequest) (*_nethttp.Response, G
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.body == nil { if r.body == nil {
executionError.error = "body is required and must be specified" return nil, reportError("body is required and must be specified")
return nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -229,22 +225,18 @@ func (a *PetApiService) AddPetExecute(r ApiAddPetRequest) (*_nethttp.Response, G
localVarPostBody = r.body localVarPostBody = r.body
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -255,7 +247,7 @@ func (a *PetApiService) AddPetExecute(r ApiAddPetRequest) (*_nethttp.Response, G
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiDeletePetRequest struct { type ApiDeletePetRequest struct {
@ -270,7 +262,7 @@ func (r ApiDeletePetRequest) ApiKey(apiKey string) ApiDeletePetRequest {
return r return r
} }
func (r ApiDeletePetRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiDeletePetRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.DeletePetExecute(r) return r.ApiService.DeletePetExecute(r)
} }
@ -291,20 +283,18 @@ func (a *PetApiService) DeletePet(ctx _context.Context, petId int64) ApiDeletePe
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *PetApiService) DeletePetExecute(r ApiDeletePetRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) DeletePetExecute(r ApiDeletePetRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodDelete localVarHTTPMethod = _nethttp.MethodDelete
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.DeletePet") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.DeletePet")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/pet/{petId}" localVarPath := localBasePath + "/pet/{petId}"
@ -336,22 +326,18 @@ func (a *PetApiService) DeletePetExecute(r ApiDeletePetRequest) (*_nethttp.Respo
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -362,7 +348,7 @@ func (a *PetApiService) DeletePetExecute(r ApiDeletePetRequest) (*_nethttp.Respo
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiFindPetsByStatusRequest struct { type ApiFindPetsByStatusRequest struct {
@ -376,7 +362,7 @@ func (r ApiFindPetsByStatusRequest) Status(status []string) ApiFindPetsByStatusR
return r return r
} }
func (r ApiFindPetsByStatusRequest) Execute() ([]Pet, *_nethttp.Response, GenericOpenAPIError) { func (r ApiFindPetsByStatusRequest) Execute() ([]Pet, *_nethttp.Response, error) {
return r.ApiService.FindPetsByStatusExecute(r) return r.ApiService.FindPetsByStatusExecute(r)
} }
@ -397,21 +383,19 @@ func (a *PetApiService) FindPetsByStatus(ctx _context.Context) ApiFindPetsByStat
* Execute executes the request * Execute executes the request
* @return []Pet * @return []Pet
*/ */
func (a *PetApiService) FindPetsByStatusExecute(r ApiFindPetsByStatusRequest) ([]Pet, *_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) FindPetsByStatusExecute(r ApiFindPetsByStatusRequest) ([]Pet, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue []Pet localVarReturnValue []Pet
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.FindPetsByStatus") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.FindPetsByStatus")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/pet/findByStatus" localVarPath := localBasePath + "/pet/findByStatus"
@ -420,8 +404,7 @@ func (a *PetApiService) FindPetsByStatusExecute(r ApiFindPetsByStatusRequest) ([
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.status == nil { if r.status == nil {
executionError.error = "status is required and must be specified" return localVarReturnValue, nil, reportError("status is required and must be specified")
return localVarReturnValue, nil, executionError
} }
localVarQueryParams.Add("status", parameterToString(*r.status, "csv")) localVarQueryParams.Add("status", parameterToString(*r.status, "csv"))
@ -444,22 +427,18 @@ func (a *PetApiService) FindPetsByStatusExecute(r ApiFindPetsByStatusRequest) ([
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -479,7 +458,7 @@ func (a *PetApiService) FindPetsByStatusExecute(r ApiFindPetsByStatusRequest) ([
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiFindPetsByTagsRequest struct { type ApiFindPetsByTagsRequest struct {
@ -493,7 +472,7 @@ func (r ApiFindPetsByTagsRequest) Tags(tags []string) ApiFindPetsByTagsRequest {
return r return r
} }
func (r ApiFindPetsByTagsRequest) Execute() ([]Pet, *_nethttp.Response, GenericOpenAPIError) { func (r ApiFindPetsByTagsRequest) Execute() ([]Pet, *_nethttp.Response, error) {
return r.ApiService.FindPetsByTagsExecute(r) return r.ApiService.FindPetsByTagsExecute(r)
} }
@ -514,21 +493,19 @@ func (a *PetApiService) FindPetsByTags(ctx _context.Context) ApiFindPetsByTagsRe
* Execute executes the request * Execute executes the request
* @return []Pet * @return []Pet
*/ */
func (a *PetApiService) FindPetsByTagsExecute(r ApiFindPetsByTagsRequest) ([]Pet, *_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) FindPetsByTagsExecute(r ApiFindPetsByTagsRequest) ([]Pet, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue []Pet localVarReturnValue []Pet
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.FindPetsByTags") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.FindPetsByTags")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/pet/findByTags" localVarPath := localBasePath + "/pet/findByTags"
@ -537,8 +514,7 @@ func (a *PetApiService) FindPetsByTagsExecute(r ApiFindPetsByTagsRequest) ([]Pet
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.tags == nil { if r.tags == nil {
executionError.error = "tags is required and must be specified" return localVarReturnValue, nil, reportError("tags is required and must be specified")
return localVarReturnValue, nil, executionError
} }
localVarQueryParams.Add("tags", parameterToString(*r.tags, "csv")) localVarQueryParams.Add("tags", parameterToString(*r.tags, "csv"))
@ -561,22 +537,18 @@ func (a *PetApiService) FindPetsByTagsExecute(r ApiFindPetsByTagsRequest) ([]Pet
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -596,7 +568,7 @@ func (a *PetApiService) FindPetsByTagsExecute(r ApiFindPetsByTagsRequest) ([]Pet
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiGetPetByIdRequest struct { type ApiGetPetByIdRequest struct {
@ -606,7 +578,7 @@ type ApiGetPetByIdRequest struct {
} }
func (r ApiGetPetByIdRequest) Execute() (Pet, *_nethttp.Response, GenericOpenAPIError) { func (r ApiGetPetByIdRequest) Execute() (Pet, *_nethttp.Response, error) {
return r.ApiService.GetPetByIdExecute(r) return r.ApiService.GetPetByIdExecute(r)
} }
@ -629,21 +601,19 @@ func (a *PetApiService) GetPetById(ctx _context.Context, petId int64) ApiGetPetB
* Execute executes the request * Execute executes the request
* @return Pet * @return Pet
*/ */
func (a *PetApiService) GetPetByIdExecute(r ApiGetPetByIdRequest) (Pet, *_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) GetPetByIdExecute(r ApiGetPetByIdRequest) (Pet, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue Pet localVarReturnValue Pet
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.GetPetById") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.GetPetById")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/pet/{petId}" localVarPath := localBasePath + "/pet/{petId}"
@ -686,22 +656,18 @@ func (a *PetApiService) GetPetByIdExecute(r ApiGetPetByIdRequest) (Pet, *_nethtt
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -721,7 +687,7 @@ func (a *PetApiService) GetPetByIdExecute(r ApiGetPetByIdRequest) (Pet, *_nethtt
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiUpdatePetRequest struct { type ApiUpdatePetRequest struct {
@ -735,7 +701,7 @@ func (r ApiUpdatePetRequest) Body(body Pet) ApiUpdatePetRequest {
return r return r
} }
func (r ApiUpdatePetRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiUpdatePetRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.UpdatePetExecute(r) return r.ApiService.UpdatePetExecute(r)
} }
@ -754,20 +720,18 @@ func (a *PetApiService) UpdatePet(ctx _context.Context) ApiUpdatePetRequest {
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *PetApiService) UpdatePetExecute(r ApiUpdatePetRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) UpdatePetExecute(r ApiUpdatePetRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPut localVarHTTPMethod = _nethttp.MethodPut
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UpdatePet") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UpdatePet")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/pet" localVarPath := localBasePath + "/pet"
@ -776,8 +740,7 @@ func (a *PetApiService) UpdatePetExecute(r ApiUpdatePetRequest) (*_nethttp.Respo
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.body == nil { if r.body == nil {
executionError.error = "body is required and must be specified" return nil, reportError("body is required and must be specified")
return nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -801,22 +764,18 @@ func (a *PetApiService) UpdatePetExecute(r ApiUpdatePetRequest) (*_nethttp.Respo
localVarPostBody = r.body localVarPostBody = r.body
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -827,7 +786,7 @@ func (a *PetApiService) UpdatePetExecute(r ApiUpdatePetRequest) (*_nethttp.Respo
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiUpdatePetWithFormRequest struct { type ApiUpdatePetWithFormRequest struct {
@ -847,7 +806,7 @@ func (r ApiUpdatePetWithFormRequest) Status(status string) ApiUpdatePetWithFormR
return r return r
} }
func (r ApiUpdatePetWithFormRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiUpdatePetWithFormRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.UpdatePetWithFormExecute(r) return r.ApiService.UpdatePetWithFormExecute(r)
} }
@ -868,20 +827,18 @@ func (a *PetApiService) UpdatePetWithForm(ctx _context.Context, petId int64) Api
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *PetApiService) UpdatePetWithFormExecute(r ApiUpdatePetWithFormRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) UpdatePetWithFormExecute(r ApiUpdatePetWithFormRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UpdatePetWithForm") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UpdatePetWithForm")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/pet/{petId}" localVarPath := localBasePath + "/pet/{petId}"
@ -916,22 +873,18 @@ func (a *PetApiService) UpdatePetWithFormExecute(r ApiUpdatePetWithFormRequest)
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -942,7 +895,7 @@ func (a *PetApiService) UpdatePetWithFormExecute(r ApiUpdatePetWithFormRequest)
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiUploadFileRequest struct { type ApiUploadFileRequest struct {
@ -962,7 +915,7 @@ func (r ApiUploadFileRequest) File(file *os.File) ApiUploadFileRequest {
return r return r
} }
func (r ApiUploadFileRequest) Execute() (ApiResponse, *_nethttp.Response, GenericOpenAPIError) { func (r ApiUploadFileRequest) Execute() (ApiResponse, *_nethttp.Response, error) {
return r.ApiService.UploadFileExecute(r) return r.ApiService.UploadFileExecute(r)
} }
@ -984,21 +937,19 @@ func (a *PetApiService) UploadFile(ctx _context.Context, petId int64) ApiUploadF
* Execute executes the request * Execute executes the request
* @return ApiResponse * @return ApiResponse
*/ */
func (a *PetApiService) UploadFileExecute(r ApiUploadFileRequest) (ApiResponse, *_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) UploadFileExecute(r ApiUploadFileRequest) (ApiResponse, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue ApiResponse localVarReturnValue ApiResponse
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UploadFile") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UploadFile")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/pet/{petId}/uploadImage" localVarPath := localBasePath + "/pet/{petId}/uploadImage"
@ -1041,22 +992,18 @@ func (a *PetApiService) UploadFileExecute(r ApiUploadFileRequest) (ApiResponse,
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -1076,7 +1023,7 @@ func (a *PetApiService) UploadFileExecute(r ApiUploadFileRequest) (ApiResponse,
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiUploadFileWithRequiredFileRequest struct { type ApiUploadFileWithRequiredFileRequest struct {
@ -1096,7 +1043,7 @@ func (r ApiUploadFileWithRequiredFileRequest) AdditionalMetadata(additionalMetad
return r return r
} }
func (r ApiUploadFileWithRequiredFileRequest) Execute() (ApiResponse, *_nethttp.Response, GenericOpenAPIError) { func (r ApiUploadFileWithRequiredFileRequest) Execute() (ApiResponse, *_nethttp.Response, error) {
return r.ApiService.UploadFileWithRequiredFileExecute(r) return r.ApiService.UploadFileWithRequiredFileExecute(r)
} }
@ -1118,21 +1065,19 @@ func (a *PetApiService) UploadFileWithRequiredFile(ctx _context.Context, petId i
* Execute executes the request * Execute executes the request
* @return ApiResponse * @return ApiResponse
*/ */
func (a *PetApiService) UploadFileWithRequiredFileExecute(r ApiUploadFileWithRequiredFileRequest) (ApiResponse, *_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) UploadFileWithRequiredFileExecute(r ApiUploadFileWithRequiredFileRequest) (ApiResponse, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue ApiResponse localVarReturnValue ApiResponse
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UploadFileWithRequiredFile") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UploadFileWithRequiredFile")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/fake/{petId}/uploadImageWithRequiredFile" localVarPath := localBasePath + "/fake/{petId}/uploadImageWithRequiredFile"
@ -1142,8 +1087,7 @@ func (a *PetApiService) UploadFileWithRequiredFileExecute(r ApiUploadFileWithReq
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.requiredFile == nil { if r.requiredFile == nil {
executionError.error = "requiredFile is required and must be specified" return localVarReturnValue, nil, reportError("requiredFile is required and must be specified")
return localVarReturnValue, nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -1176,22 +1120,18 @@ func (a *PetApiService) UploadFileWithRequiredFileExecute(r ApiUploadFileWithReq
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -1211,5 +1151,5 @@ func (a *PetApiService) UploadFileWithRequiredFileExecute(r ApiUploadFileWithReq
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }

98
samples/client/petstore/go/go-petstore/api_store.go
View File

@ -11,7 +11,6 @@
package petstore package petstore
import ( import (
"bytes"
_context "context" _context "context"
_ioutil "io/ioutil" _ioutil "io/ioutil"
_nethttp "net/http" _nethttp "net/http"
@ -38,7 +37,7 @@ type StoreApi interface {
/* /*
* DeleteOrderExecute executes the request * DeleteOrderExecute executes the request
*/ */
DeleteOrderExecute(r ApiDeleteOrderRequest) (*_nethttp.Response, GenericOpenAPIError) DeleteOrderExecute(r ApiDeleteOrderRequest) (*_nethttp.Response, error)
/* /*
* GetInventory Returns pet inventories by status * GetInventory Returns pet inventories by status
@ -52,7 +51,7 @@ type StoreApi interface {
* GetInventoryExecute executes the request * GetInventoryExecute executes the request
* @return map[string]int32 * @return map[string]int32
*/ */
GetInventoryExecute(r ApiGetInventoryRequest) (map[string]int32, *_nethttp.Response, GenericOpenAPIError) GetInventoryExecute(r ApiGetInventoryRequest) (map[string]int32, *_nethttp.Response, error)
/* /*
* GetOrderById Find purchase order by ID * GetOrderById Find purchase order by ID
@ -67,7 +66,7 @@ type StoreApi interface {
* GetOrderByIdExecute executes the request * GetOrderByIdExecute executes the request
* @return Order * @return Order
*/ */
GetOrderByIdExecute(r ApiGetOrderByIdRequest) (Order, *_nethttp.Response, GenericOpenAPIError) GetOrderByIdExecute(r ApiGetOrderByIdRequest) (Order, *_nethttp.Response, error)
/* /*
* PlaceOrder Place an order for a pet * PlaceOrder Place an order for a pet
@ -80,7 +79,7 @@ type StoreApi interface {
* PlaceOrderExecute executes the request * PlaceOrderExecute executes the request
* @return Order * @return Order
*/ */
PlaceOrderExecute(r ApiPlaceOrderRequest) (Order, *_nethttp.Response, GenericOpenAPIError) PlaceOrderExecute(r ApiPlaceOrderRequest) (Order, *_nethttp.Response, error)
} }
// StoreApiService StoreApi service // StoreApiService StoreApi service
@ -93,7 +92,7 @@ type ApiDeleteOrderRequest struct {
} }
func (r ApiDeleteOrderRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiDeleteOrderRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.DeleteOrderExecute(r) return r.ApiService.DeleteOrderExecute(r)
} }
@ -115,20 +114,18 @@ func (a *StoreApiService) DeleteOrder(ctx _context.Context, orderId string) ApiD
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *StoreApiService) DeleteOrderExecute(r ApiDeleteOrderRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *StoreApiService) DeleteOrderExecute(r ApiDeleteOrderRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodDelete localVarHTTPMethod = _nethttp.MethodDelete
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.DeleteOrder") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.DeleteOrder")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/store/order/{order_id}" localVarPath := localBasePath + "/store/order/{order_id}"
@ -157,22 +154,18 @@ func (a *StoreApiService) DeleteOrderExecute(r ApiDeleteOrderRequest) (*_nethttp
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -183,7 +176,7 @@ func (a *StoreApiService) DeleteOrderExecute(r ApiDeleteOrderRequest) (*_nethttp
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiGetInventoryRequest struct { type ApiGetInventoryRequest struct {
@ -192,7 +185,7 @@ type ApiGetInventoryRequest struct {
} }
func (r ApiGetInventoryRequest) Execute() (map[string]int32, *_nethttp.Response, GenericOpenAPIError) { func (r ApiGetInventoryRequest) Execute() (map[string]int32, *_nethttp.Response, error) {
return r.ApiService.GetInventoryExecute(r) return r.ApiService.GetInventoryExecute(r)
} }
@ -213,21 +206,19 @@ func (a *StoreApiService) GetInventory(ctx _context.Context) ApiGetInventoryRequ
* Execute executes the request * Execute executes the request
* @return map[string]int32 * @return map[string]int32
*/ */
func (a *StoreApiService) GetInventoryExecute(r ApiGetInventoryRequest) (map[string]int32, *_nethttp.Response, GenericOpenAPIError) { func (a *StoreApiService) GetInventoryExecute(r ApiGetInventoryRequest) (map[string]int32, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue map[string]int32 localVarReturnValue map[string]int32
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.GetInventory") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.GetInventory")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/store/inventory" localVarPath := localBasePath + "/store/inventory"
@ -269,22 +260,18 @@ func (a *StoreApiService) GetInventoryExecute(r ApiGetInventoryRequest) (map[str
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -304,7 +291,7 @@ func (a *StoreApiService) GetInventoryExecute(r ApiGetInventoryRequest) (map[str
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiGetOrderByIdRequest struct { type ApiGetOrderByIdRequest struct {
@ -314,7 +301,7 @@ type ApiGetOrderByIdRequest struct {
} }
func (r ApiGetOrderByIdRequest) Execute() (Order, *_nethttp.Response, GenericOpenAPIError) { func (r ApiGetOrderByIdRequest) Execute() (Order, *_nethttp.Response, error) {
return r.ApiService.GetOrderByIdExecute(r) return r.ApiService.GetOrderByIdExecute(r)
} }
@ -337,21 +324,19 @@ func (a *StoreApiService) GetOrderById(ctx _context.Context, orderId int64) ApiG
* Execute executes the request * Execute executes the request
* @return Order * @return Order
*/ */
func (a *StoreApiService) GetOrderByIdExecute(r ApiGetOrderByIdRequest) (Order, *_nethttp.Response, GenericOpenAPIError) { func (a *StoreApiService) GetOrderByIdExecute(r ApiGetOrderByIdRequest) (Order, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue Order localVarReturnValue Order
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.GetOrderById") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.GetOrderById")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/store/order/{order_id}" localVarPath := localBasePath + "/store/order/{order_id}"
@ -361,12 +346,10 @@ func (a *StoreApiService) GetOrderByIdExecute(r ApiGetOrderByIdRequest) (Order,
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.orderId < 1 { if r.orderId < 1 {
executionError.error = "orderId must be greater than 1" return localVarReturnValue, nil, reportError("orderId must be greater than 1")
return localVarReturnValue, nil, executionError
} }
if r.orderId > 5 { if r.orderId > 5 {
executionError.error = "orderId must be less than 5" return localVarReturnValue, nil, reportError("orderId must be less than 5")
return localVarReturnValue, nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -388,22 +371,18 @@ func (a *StoreApiService) GetOrderByIdExecute(r ApiGetOrderByIdRequest) (Order,
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -423,7 +402,7 @@ func (a *StoreApiService) GetOrderByIdExecute(r ApiGetOrderByIdRequest) (Order,
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiPlaceOrderRequest struct { type ApiPlaceOrderRequest struct {
@ -437,7 +416,7 @@ func (r ApiPlaceOrderRequest) Body(body Order) ApiPlaceOrderRequest {
return r return r
} }
func (r ApiPlaceOrderRequest) Execute() (Order, *_nethttp.Response, GenericOpenAPIError) { func (r ApiPlaceOrderRequest) Execute() (Order, *_nethttp.Response, error) {
return r.ApiService.PlaceOrderExecute(r) return r.ApiService.PlaceOrderExecute(r)
} }
@ -457,21 +436,19 @@ func (a *StoreApiService) PlaceOrder(ctx _context.Context) ApiPlaceOrderRequest
* Execute executes the request * Execute executes the request
* @return Order * @return Order
*/ */
func (a *StoreApiService) PlaceOrderExecute(r ApiPlaceOrderRequest) (Order, *_nethttp.Response, GenericOpenAPIError) { func (a *StoreApiService) PlaceOrderExecute(r ApiPlaceOrderRequest) (Order, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue Order localVarReturnValue Order
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.PlaceOrder") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.PlaceOrder")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/store/order" localVarPath := localBasePath + "/store/order"
@ -480,8 +457,7 @@ func (a *StoreApiService) PlaceOrderExecute(r ApiPlaceOrderRequest) (Order, *_ne
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.body == nil { if r.body == nil {
executionError.error = "body is required and must be specified" return localVarReturnValue, nil, reportError("body is required and must be specified")
return localVarReturnValue, nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -505,22 +481,18 @@ func (a *StoreApiService) PlaceOrderExecute(r ApiPlaceOrderRequest) (Order, *_ne
localVarPostBody = r.body localVarPostBody = r.body
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -540,5 +512,5 @@ func (a *StoreApiService) PlaceOrderExecute(r ApiPlaceOrderRequest) (Order, *_ne
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }

195
samples/client/petstore/go/go-petstore/api_user.go
View File

@ -11,7 +11,6 @@
package petstore package petstore
import ( import (
"bytes"
_context "context" _context "context"
_ioutil "io/ioutil" _ioutil "io/ioutil"
_nethttp "net/http" _nethttp "net/http"
@ -37,7 +36,7 @@ type UserApi interface {
/* /*
* CreateUserExecute executes the request * CreateUserExecute executes the request
*/ */
CreateUserExecute(r ApiCreateUserRequest) (*_nethttp.Response, GenericOpenAPIError) CreateUserExecute(r ApiCreateUserRequest) (*_nethttp.Response, error)
/* /*
* CreateUsersWithArrayInput Creates list of users with given input array * CreateUsersWithArrayInput Creates list of users with given input array
@ -49,7 +48,7 @@ type UserApi interface {
/* /*
* CreateUsersWithArrayInputExecute executes the request * CreateUsersWithArrayInputExecute executes the request
*/ */
CreateUsersWithArrayInputExecute(r ApiCreateUsersWithArrayInputRequest) (*_nethttp.Response, GenericOpenAPIError) CreateUsersWithArrayInputExecute(r ApiCreateUsersWithArrayInputRequest) (*_nethttp.Response, error)
/* /*
* CreateUsersWithListInput Creates list of users with given input array * CreateUsersWithListInput Creates list of users with given input array
@ -61,7 +60,7 @@ type UserApi interface {
/* /*
* CreateUsersWithListInputExecute executes the request * CreateUsersWithListInputExecute executes the request
*/ */
CreateUsersWithListInputExecute(r ApiCreateUsersWithListInputRequest) (*_nethttp.Response, GenericOpenAPIError) CreateUsersWithListInputExecute(r ApiCreateUsersWithListInputRequest) (*_nethttp.Response, error)
/* /*
* DeleteUser Delete user * DeleteUser Delete user
@ -75,7 +74,7 @@ type UserApi interface {
/* /*
* DeleteUserExecute executes the request * DeleteUserExecute executes the request
*/ */
DeleteUserExecute(r ApiDeleteUserRequest) (*_nethttp.Response, GenericOpenAPIError) DeleteUserExecute(r ApiDeleteUserRequest) (*_nethttp.Response, error)
/* /*
* GetUserByName Get user by user name * GetUserByName Get user by user name
@ -89,7 +88,7 @@ type UserApi interface {
* GetUserByNameExecute executes the request * GetUserByNameExecute executes the request
* @return User * @return User
*/ */
GetUserByNameExecute(r ApiGetUserByNameRequest) (User, *_nethttp.Response, GenericOpenAPIError) GetUserByNameExecute(r ApiGetUserByNameRequest) (User, *_nethttp.Response, error)
/* /*
* LoginUser Logs user into the system * LoginUser Logs user into the system
@ -102,7 +101,7 @@ type UserApi interface {
* LoginUserExecute executes the request * LoginUserExecute executes the request
* @return string * @return string
*/ */
LoginUserExecute(r ApiLoginUserRequest) (string, *_nethttp.Response, GenericOpenAPIError) LoginUserExecute(r ApiLoginUserRequest) (string, *_nethttp.Response, error)
/* /*
* LogoutUser Logs out current logged in user session * LogoutUser Logs out current logged in user session
@ -114,7 +113,7 @@ type UserApi interface {
/* /*
* LogoutUserExecute executes the request * LogoutUserExecute executes the request
*/ */
LogoutUserExecute(r ApiLogoutUserRequest) (*_nethttp.Response, GenericOpenAPIError) LogoutUserExecute(r ApiLogoutUserRequest) (*_nethttp.Response, error)
/* /*
* UpdateUser Updated user * UpdateUser Updated user
@ -128,7 +127,7 @@ type UserApi interface {
/* /*
* UpdateUserExecute executes the request * UpdateUserExecute executes the request
*/ */
UpdateUserExecute(r ApiUpdateUserRequest) (*_nethttp.Response, GenericOpenAPIError) UpdateUserExecute(r ApiUpdateUserRequest) (*_nethttp.Response, error)
} }
// UserApiService UserApi service // UserApiService UserApi service
@ -145,7 +144,7 @@ func (r ApiCreateUserRequest) Body(body User) ApiCreateUserRequest {
return r return r
} }
func (r ApiCreateUserRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiCreateUserRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.CreateUserExecute(r) return r.ApiService.CreateUserExecute(r)
} }
@ -165,20 +164,18 @@ func (a *UserApiService) CreateUser(ctx _context.Context) ApiCreateUserRequest {
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *UserApiService) CreateUserExecute(r ApiCreateUserRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) CreateUserExecute(r ApiCreateUserRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.CreateUser") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.CreateUser")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/user" localVarPath := localBasePath + "/user"
@ -187,8 +184,7 @@ func (a *UserApiService) CreateUserExecute(r ApiCreateUserRequest) (*_nethttp.Re
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.body == nil { if r.body == nil {
executionError.error = "body is required and must be specified" return nil, reportError("body is required and must be specified")
return nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -212,22 +208,18 @@ func (a *UserApiService) CreateUserExecute(r ApiCreateUserRequest) (*_nethttp.Re
localVarPostBody = r.body localVarPostBody = r.body
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -238,7 +230,7 @@ func (a *UserApiService) CreateUserExecute(r ApiCreateUserRequest) (*_nethttp.Re
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiCreateUsersWithArrayInputRequest struct { type ApiCreateUsersWithArrayInputRequest struct {
@ -252,7 +244,7 @@ func (r ApiCreateUsersWithArrayInputRequest) Body(body []User) ApiCreateUsersWit
return r return r
} }
func (r ApiCreateUsersWithArrayInputRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiCreateUsersWithArrayInputRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.CreateUsersWithArrayInputExecute(r) return r.ApiService.CreateUsersWithArrayInputExecute(r)
} }
@ -271,20 +263,18 @@ func (a *UserApiService) CreateUsersWithArrayInput(ctx _context.Context) ApiCrea
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *UserApiService) CreateUsersWithArrayInputExecute(r ApiCreateUsersWithArrayInputRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) CreateUsersWithArrayInputExecute(r ApiCreateUsersWithArrayInputRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.CreateUsersWithArrayInput") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.CreateUsersWithArrayInput")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/user/createWithArray" localVarPath := localBasePath + "/user/createWithArray"
@ -293,8 +283,7 @@ func (a *UserApiService) CreateUsersWithArrayInputExecute(r ApiCreateUsersWithAr
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.body == nil { if r.body == nil {
executionError.error = "body is required and must be specified" return nil, reportError("body is required and must be specified")
return nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -318,22 +307,18 @@ func (a *UserApiService) CreateUsersWithArrayInputExecute(r ApiCreateUsersWithAr
localVarPostBody = r.body localVarPostBody = r.body
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -344,7 +329,7 @@ func (a *UserApiService) CreateUsersWithArrayInputExecute(r ApiCreateUsersWithAr
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiCreateUsersWithListInputRequest struct { type ApiCreateUsersWithListInputRequest struct {
@ -358,7 +343,7 @@ func (r ApiCreateUsersWithListInputRequest) Body(body []User) ApiCreateUsersWith
return r return r
} }
func (r ApiCreateUsersWithListInputRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiCreateUsersWithListInputRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.CreateUsersWithListInputExecute(r) return r.ApiService.CreateUsersWithListInputExecute(r)
} }
@ -377,20 +362,18 @@ func (a *UserApiService) CreateUsersWithListInput(ctx _context.Context) ApiCreat
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *UserApiService) CreateUsersWithListInputExecute(r ApiCreateUsersWithListInputRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) CreateUsersWithListInputExecute(r ApiCreateUsersWithListInputRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.CreateUsersWithListInput") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.CreateUsersWithListInput")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/user/createWithList" localVarPath := localBasePath + "/user/createWithList"
@ -399,8 +382,7 @@ func (a *UserApiService) CreateUsersWithListInputExecute(r ApiCreateUsersWithLis
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.body == nil { if r.body == nil {
executionError.error = "body is required and must be specified" return nil, reportError("body is required and must be specified")
return nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -424,22 +406,18 @@ func (a *UserApiService) CreateUsersWithListInputExecute(r ApiCreateUsersWithLis
localVarPostBody = r.body localVarPostBody = r.body
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -450,7 +428,7 @@ func (a *UserApiService) CreateUsersWithListInputExecute(r ApiCreateUsersWithLis
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiDeleteUserRequest struct { type ApiDeleteUserRequest struct {
@ -460,7 +438,7 @@ type ApiDeleteUserRequest struct {
} }
func (r ApiDeleteUserRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiDeleteUserRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.DeleteUserExecute(r) return r.ApiService.DeleteUserExecute(r)
} }
@ -482,20 +460,18 @@ func (a *UserApiService) DeleteUser(ctx _context.Context, username string) ApiDe
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *UserApiService) DeleteUserExecute(r ApiDeleteUserRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) DeleteUserExecute(r ApiDeleteUserRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodDelete localVarHTTPMethod = _nethttp.MethodDelete
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.DeleteUser") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.DeleteUser")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/user/{username}" localVarPath := localBasePath + "/user/{username}"
@ -524,22 +500,18 @@ func (a *UserApiService) DeleteUserExecute(r ApiDeleteUserRequest) (*_nethttp.Re
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -550,7 +522,7 @@ func (a *UserApiService) DeleteUserExecute(r ApiDeleteUserRequest) (*_nethttp.Re
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiGetUserByNameRequest struct { type ApiGetUserByNameRequest struct {
@ -560,7 +532,7 @@ type ApiGetUserByNameRequest struct {
} }
func (r ApiGetUserByNameRequest) Execute() (User, *_nethttp.Response, GenericOpenAPIError) { func (r ApiGetUserByNameRequest) Execute() (User, *_nethttp.Response, error) {
return r.ApiService.GetUserByNameExecute(r) return r.ApiService.GetUserByNameExecute(r)
} }
@ -582,21 +554,19 @@ func (a *UserApiService) GetUserByName(ctx _context.Context, username string) Ap
* Execute executes the request * Execute executes the request
* @return User * @return User
*/ */
func (a *UserApiService) GetUserByNameExecute(r ApiGetUserByNameRequest) (User, *_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) GetUserByNameExecute(r ApiGetUserByNameRequest) (User, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue User localVarReturnValue User
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.GetUserByName") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.GetUserByName")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/user/{username}" localVarPath := localBasePath + "/user/{username}"
@ -625,22 +595,18 @@ func (a *UserApiService) GetUserByNameExecute(r ApiGetUserByNameRequest) (User,
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -660,7 +626,7 @@ func (a *UserApiService) GetUserByNameExecute(r ApiGetUserByNameRequest) (User,
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiLoginUserRequest struct { type ApiLoginUserRequest struct {
@ -679,7 +645,7 @@ func (r ApiLoginUserRequest) Password(password string) ApiLoginUserRequest {
return r return r
} }
func (r ApiLoginUserRequest) Execute() (string, *_nethttp.Response, GenericOpenAPIError) { func (r ApiLoginUserRequest) Execute() (string, *_nethttp.Response, error) {
return r.ApiService.LoginUserExecute(r) return r.ApiService.LoginUserExecute(r)
} }
@ -699,21 +665,19 @@ func (a *UserApiService) LoginUser(ctx _context.Context) ApiLoginUserRequest {
* Execute executes the request * Execute executes the request
* @return string * @return string
*/ */
func (a *UserApiService) LoginUserExecute(r ApiLoginUserRequest) (string, *_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) LoginUserExecute(r ApiLoginUserRequest) (string, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue string localVarReturnValue string
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.LoginUser") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.LoginUser")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/user/login" localVarPath := localBasePath + "/user/login"
@ -722,12 +686,10 @@ func (a *UserApiService) LoginUserExecute(r ApiLoginUserRequest) (string, *_neth
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.username == nil { if r.username == nil {
executionError.error = "username is required and must be specified" return localVarReturnValue, nil, reportError("username is required and must be specified")
return localVarReturnValue, nil, executionError
} }
if r.password == nil { if r.password == nil {
executionError.error = "password is required and must be specified" return localVarReturnValue, nil, reportError("password is required and must be specified")
return localVarReturnValue, nil, executionError
} }
localVarQueryParams.Add("username", parameterToString(*r.username, "")) localVarQueryParams.Add("username", parameterToString(*r.username, ""))
@ -751,22 +713,18 @@ func (a *UserApiService) LoginUserExecute(r ApiLoginUserRequest) (string, *_neth
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -786,7 +744,7 @@ func (a *UserApiService) LoginUserExecute(r ApiLoginUserRequest) (string, *_neth
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiLogoutUserRequest struct { type ApiLogoutUserRequest struct {
@ -795,7 +753,7 @@ type ApiLogoutUserRequest struct {
} }
func (r ApiLogoutUserRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiLogoutUserRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.LogoutUserExecute(r) return r.ApiService.LogoutUserExecute(r)
} }
@ -814,20 +772,18 @@ func (a *UserApiService) LogoutUser(ctx _context.Context) ApiLogoutUserRequest {
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *UserApiService) LogoutUserExecute(r ApiLogoutUserRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) LogoutUserExecute(r ApiLogoutUserRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.LogoutUser") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.LogoutUser")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/user/logout" localVarPath := localBasePath + "/user/logout"
@ -855,22 +811,18 @@ func (a *UserApiService) LogoutUserExecute(r ApiLogoutUserRequest) (*_nethttp.Re
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -881,7 +833,7 @@ func (a *UserApiService) LogoutUserExecute(r ApiLogoutUserRequest) (*_nethttp.Re
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiUpdateUserRequest struct { type ApiUpdateUserRequest struct {
@ -896,7 +848,7 @@ func (r ApiUpdateUserRequest) Body(body User) ApiUpdateUserRequest {
return r return r
} }
func (r ApiUpdateUserRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiUpdateUserRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.UpdateUserExecute(r) return r.ApiService.UpdateUserExecute(r)
} }
@ -918,20 +870,18 @@ func (a *UserApiService) UpdateUser(ctx _context.Context, username string) ApiUp
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *UserApiService) UpdateUserExecute(r ApiUpdateUserRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) UpdateUserExecute(r ApiUpdateUserRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPut localVarHTTPMethod = _nethttp.MethodPut
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.UpdateUser") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.UpdateUser")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/user/{username}" localVarPath := localBasePath + "/user/{username}"
@ -941,8 +891,7 @@ func (a *UserApiService) UpdateUserExecute(r ApiUpdateUserRequest) (*_nethttp.Re
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.body == nil { if r.body == nil {
executionError.error = "body is required and must be specified" return nil, reportError("body is required and must be specified")
return nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -966,22 +915,18 @@ func (a *UserApiService) UpdateUserExecute(r ApiUpdateUserRequest) (*_nethttp.Re
localVarPostBody = r.body localVarPostBody = r.body
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -992,5 +937,5 @@ func (a *UserApiService) UpdateUserExecute(r ApiUpdateUserRequest) (*_nethttp.Re
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }

2
samples/client/petstore/go/go-petstore/docs/AnotherFakeApi.md
View File

@ -34,7 +34,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.AnotherFakeApi.Call123TestSpecialTags(context.Background()).Body(body).Execute() resp, r, err := api_client.AnotherFakeApi.Call123TestSpecialTags(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `AnotherFakeApi.Call123TestSpecialTags``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `AnotherFakeApi.Call123TestSpecialTags``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }

28
samples/client/petstore/go/go-petstore/docs/FakeApi.md
View File

@ -47,7 +47,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.CreateXmlItem(context.Background()).XmlItem(xmlItem).Execute() resp, r, err := api_client.FakeApi.CreateXmlItem(context.Background()).XmlItem(xmlItem).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.CreateXmlItem``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.CreateXmlItem``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -111,7 +111,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.FakeOuterBooleanSerialize(context.Background()).Body(body).Execute() resp, r, err := api_client.FakeApi.FakeOuterBooleanSerialize(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterBooleanSerialize``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterBooleanSerialize``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -177,7 +177,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.FakeOuterCompositeSerialize(context.Background()).Body(body).Execute() resp, r, err := api_client.FakeApi.FakeOuterCompositeSerialize(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterCompositeSerialize``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterCompositeSerialize``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -243,7 +243,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.FakeOuterNumberSerialize(context.Background()).Body(body).Execute() resp, r, err := api_client.FakeApi.FakeOuterNumberSerialize(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterNumberSerialize``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterNumberSerialize``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -309,7 +309,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.FakeOuterStringSerialize(context.Background()).Body(body).Execute() resp, r, err := api_client.FakeApi.FakeOuterStringSerialize(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterStringSerialize``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterStringSerialize``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -375,7 +375,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestBodyWithFileSchema(context.Background()).Body(body).Execute() resp, r, err := api_client.FakeApi.TestBodyWithFileSchema(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestBodyWithFileSchema``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestBodyWithFileSchema``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -438,7 +438,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestBodyWithQueryParams(context.Background()).Query(query).Body(body).Execute() resp, r, err := api_client.FakeApi.TestBodyWithQueryParams(context.Background()).Query(query).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestBodyWithQueryParams``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestBodyWithQueryParams``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -503,7 +503,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestClientModel(context.Background()).Body(body).Execute() resp, r, err := api_client.FakeApi.TestClientModel(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestClientModel``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestClientModel``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -583,7 +583,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestEndpointParameters(context.Background()).Number(number).Double(double).PatternWithoutDelimiter(patternWithoutDelimiter).Byte_(byte_).Integer(integer).Int32_(int32_).Int64_(int64_).Float(float).String_(string_).Binary(binary).Date(date).DateTime(dateTime).Password(password).Callback(callback).Execute() resp, r, err := api_client.FakeApi.TestEndpointParameters(context.Background()).Number(number).Double(double).PatternWithoutDelimiter(patternWithoutDelimiter).Byte_(byte_).Integer(integer).Int32_(int32_).Int64_(int64_).Float(float).String_(string_).Binary(binary).Date(date).DateTime(dateTime).Password(password).Callback(callback).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestEndpointParameters``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestEndpointParameters``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -667,7 +667,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestEnumParameters(context.Background()).EnumHeaderStringArray(enumHeaderStringArray).EnumHeaderString(enumHeaderString).EnumQueryStringArray(enumQueryStringArray).EnumQueryString(enumQueryString).EnumQueryInteger(enumQueryInteger).EnumQueryDouble(enumQueryDouble).EnumFormStringArray(enumFormStringArray).EnumFormString(enumFormString).Execute() resp, r, err := api_client.FakeApi.TestEnumParameters(context.Background()).EnumHeaderStringArray(enumHeaderStringArray).EnumHeaderString(enumHeaderString).EnumQueryStringArray(enumQueryStringArray).EnumQueryString(enumQueryString).EnumQueryInteger(enumQueryInteger).EnumQueryDouble(enumQueryDouble).EnumFormStringArray(enumFormStringArray).EnumFormString(enumFormString).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestEnumParameters``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestEnumParameters``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -743,7 +743,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestGroupParameters(context.Background()).RequiredStringGroup(requiredStringGroup).RequiredBooleanGroup(requiredBooleanGroup).RequiredInt64Group(requiredInt64Group).StringGroup(stringGroup).BooleanGroup(booleanGroup).Int64Group(int64Group).Execute() resp, r, err := api_client.FakeApi.TestGroupParameters(context.Background()).RequiredStringGroup(requiredStringGroup).RequiredBooleanGroup(requiredBooleanGroup).RequiredInt64Group(requiredInt64Group).StringGroup(stringGroup).BooleanGroup(booleanGroup).Int64Group(int64Group).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestGroupParameters``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestGroupParameters``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -810,7 +810,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestInlineAdditionalProperties(context.Background()).Param(param).Execute() resp, r, err := api_client.FakeApi.TestInlineAdditionalProperties(context.Background()).Param(param).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestInlineAdditionalProperties``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestInlineAdditionalProperties``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -873,7 +873,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestJsonFormData(context.Background()).Param(param).Param2(param2).Execute() resp, r, err := api_client.FakeApi.TestJsonFormData(context.Background()).Param(param).Param2(param2).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestJsonFormData``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestJsonFormData``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -942,7 +942,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestQueryParameterCollectionFormat(context.Background()).Pipe(pipe).Ioutil(ioutil).Http(http).Url(url).Context(context).Execute() resp, r, err := api_client.FakeApi.TestQueryParameterCollectionFormat(context.Background()).Pipe(pipe).Ioutil(ioutil).Http(http).Url(url).Context(context).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestQueryParameterCollectionFormat``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestQueryParameterCollectionFormat``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }

2
samples/client/petstore/go/go-petstore/docs/FakeClassnameTags123Api.md
View File

@ -34,7 +34,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeClassnameTags123Api.TestClassname(context.Background()).Body(body).Execute() resp, r, err := api_client.FakeClassnameTags123Api.TestClassname(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeClassnameTags123Api.TestClassname``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeClassnameTags123Api.TestClassname``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }

18
samples/client/petstore/go/go-petstore/docs/PetApi.md
View File

@ -40,7 +40,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.AddPet(context.Background()).Body(body).Execute() resp, r, err := api_client.PetApi.AddPet(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.AddPet``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.AddPet``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -103,7 +103,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.DeletePet(context.Background(), petId).ApiKey(apiKey).Execute() resp, r, err := api_client.PetApi.DeletePet(context.Background(), petId).ApiKey(apiKey).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.DeletePet``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.DeletePet``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -172,7 +172,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.FindPetsByStatus(context.Background()).Status(status).Execute() resp, r, err := api_client.PetApi.FindPetsByStatus(context.Background()).Status(status).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.FindPetsByStatus``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.FindPetsByStatus``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -238,7 +238,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.FindPetsByTags(context.Background()).Tags(tags).Execute() resp, r, err := api_client.PetApi.FindPetsByTags(context.Background()).Tags(tags).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.FindPetsByTags``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.FindPetsByTags``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -304,7 +304,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.GetPetById(context.Background(), petId).Execute() resp, r, err := api_client.PetApi.GetPetById(context.Background(), petId).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.GetPetById``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.GetPetById``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -372,7 +372,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.UpdatePet(context.Background()).Body(body).Execute() resp, r, err := api_client.PetApi.UpdatePet(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UpdatePet``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UpdatePet``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -436,7 +436,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.UpdatePetWithForm(context.Background(), petId).Name(name).Status(status).Execute() resp, r, err := api_client.PetApi.UpdatePetWithForm(context.Background(), petId).Name(name).Status(status).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UpdatePetWithForm``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UpdatePetWithForm``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -506,7 +506,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.UploadFile(context.Background(), petId).AdditionalMetadata(additionalMetadata).File(file).Execute() resp, r, err := api_client.PetApi.UploadFile(context.Background(), petId).AdditionalMetadata(additionalMetadata).File(file).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UploadFile``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UploadFile``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -578,7 +578,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.UploadFileWithRequiredFile(context.Background(), petId).RequiredFile(requiredFile).AdditionalMetadata(additionalMetadata).Execute() resp, r, err := api_client.PetApi.UploadFileWithRequiredFile(context.Background(), petId).RequiredFile(requiredFile).AdditionalMetadata(additionalMetadata).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UploadFileWithRequiredFile``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UploadFileWithRequiredFile``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }

8
samples/client/petstore/go/go-petstore/docs/StoreApi.md
View File

@ -37,7 +37,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.StoreApi.DeleteOrder(context.Background(), orderId).Execute() resp, r, err := api_client.StoreApi.DeleteOrder(context.Background(), orderId).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.DeleteOrder``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.DeleteOrder``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -104,7 +104,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.StoreApi.GetInventory(context.Background()).Execute() resp, r, err := api_client.StoreApi.GetInventory(context.Background()).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.GetInventory``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.GetInventory``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -166,7 +166,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.StoreApi.GetOrderById(context.Background(), orderId).Execute() resp, r, err := api_client.StoreApi.GetOrderById(context.Background(), orderId).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.GetOrderById``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.GetOrderById``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -234,7 +234,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.StoreApi.PlaceOrder(context.Background()).Body(body).Execute() resp, r, err := api_client.StoreApi.PlaceOrder(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.PlaceOrder``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.PlaceOrder``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }

16
samples/client/petstore/go/go-petstore/docs/UserApi.md
View File

@ -41,7 +41,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.CreateUser(context.Background()).Body(body).Execute() resp, r, err := api_client.UserApi.CreateUser(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.CreateUser``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.CreateUser``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -103,7 +103,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.CreateUsersWithArrayInput(context.Background()).Body(body).Execute() resp, r, err := api_client.UserApi.CreateUsersWithArrayInput(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.CreateUsersWithArrayInput``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.CreateUsersWithArrayInput``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -165,7 +165,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.CreateUsersWithListInput(context.Background()).Body(body).Execute() resp, r, err := api_client.UserApi.CreateUsersWithListInput(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.CreateUsersWithListInput``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.CreateUsersWithListInput``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -229,7 +229,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.DeleteUser(context.Background(), username).Execute() resp, r, err := api_client.UserApi.DeleteUser(context.Background(), username).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.DeleteUser``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.DeleteUser``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -295,7 +295,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.GetUserByName(context.Background(), username).Execute() resp, r, err := api_client.UserApi.GetUserByName(context.Background(), username).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.GetUserByName``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.GetUserByName``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -364,7 +364,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.LoginUser(context.Background()).Username(username).Password(password).Execute() resp, r, err := api_client.UserApi.LoginUser(context.Background()).Username(username).Password(password).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.LoginUser``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.LoginUser``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -428,7 +428,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.LogoutUser(context.Background()).Execute() resp, r, err := api_client.UserApi.LogoutUser(context.Background()).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.LogoutUser``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.LogoutUser``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -489,7 +489,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.UpdateUser(context.Background(), username).Body(body).Execute() resp, r, err := api_client.UserApi.UpdateUser(context.Background(), username).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.UpdateUser``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.UpdateUser``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }

36
samples/client/petstore/go/mock/mock_api_pet.go
View File

@ -20,70 +20,70 @@ func (m *MockPetApi) AddPet(ctx context.Context) sw.ApiAddPetRequest {
return sw.ApiAddPetRequest{ApiService: m} return sw.ApiAddPetRequest{ApiService: m}
} }
func (m *MockPetApi) AddPetExecute(r sw.ApiAddPetRequest) (*http.Response, sw.GenericOpenAPIError) { func (m *MockPetApi) AddPetExecute(r sw.ApiAddPetRequest) (*http.Response, error) {
return &http.Response{StatusCode:200}, sw.GenericOpenAPIError{} return &http.Response{StatusCode:200}, nil
} }
func (m *MockPetApi) DeletePet(ctx context.Context, petId int64) sw.ApiDeletePetRequest { func (m *MockPetApi) DeletePet(ctx context.Context, petId int64) sw.ApiDeletePetRequest {
return sw.ApiDeletePetRequest{ApiService: m} return sw.ApiDeletePetRequest{ApiService: m}
} }
func (m *MockPetApi) DeletePetExecute(r sw.ApiDeletePetRequest) (*http.Response, sw.GenericOpenAPIError) { func (m *MockPetApi) DeletePetExecute(r sw.ApiDeletePetRequest) (*http.Response, error) {
return &http.Response{StatusCode:200}, sw.GenericOpenAPIError{} return &http.Response{StatusCode:200}, nil
} }
func (m *MockPetApi) FindPetsByStatus(ctx context.Context) sw.ApiFindPetsByStatusRequest { func (m *MockPetApi) FindPetsByStatus(ctx context.Context) sw.ApiFindPetsByStatusRequest {
return sw.ApiFindPetsByStatusRequest{ApiService: m} return sw.ApiFindPetsByStatusRequest{ApiService: m}
} }
func (m *MockPetApi) FindPetsByStatusExecute(r sw.ApiFindPetsByStatusRequest) ([]sw.Pet, *http.Response, sw.GenericOpenAPIError) { func (m *MockPetApi) FindPetsByStatusExecute(r sw.ApiFindPetsByStatusRequest) ([]sw.Pet, *http.Response, error) {
return []sw.Pet{}, &http.Response{StatusCode:200}, sw.GenericOpenAPIError{} return []sw.Pet{}, &http.Response{StatusCode:200}, nil
} }
func (m *MockPetApi) FindPetsByTags(ctx context.Context) sw.ApiFindPetsByTagsRequest { func (m *MockPetApi) FindPetsByTags(ctx context.Context) sw.ApiFindPetsByTagsRequest {
return sw.ApiFindPetsByTagsRequest{ApiService: m} return sw.ApiFindPetsByTagsRequest{ApiService: m}
} }
func (m *MockPetApi) FindPetsByTagsExecute(r sw.ApiFindPetsByTagsRequest) ([]sw.Pet, *http.Response, sw.GenericOpenAPIError) { func (m *MockPetApi) FindPetsByTagsExecute(r sw.ApiFindPetsByTagsRequest) ([]sw.Pet, *http.Response, error) {
return []sw.Pet{}, &http.Response{StatusCode:200}, sw.GenericOpenAPIError{} return []sw.Pet{}, &http.Response{StatusCode:200}, nil
} }
func (m *MockPetApi) GetPetById(ctx context.Context, petId int64) sw.ApiGetPetByIdRequest { func (m *MockPetApi) GetPetById(ctx context.Context, petId int64) sw.ApiGetPetByIdRequest {
return sw.ApiGetPetByIdRequest{ApiService: m} return sw.ApiGetPetByIdRequest{ApiService: m}
} }
func (m *MockPetApi) GetPetByIdExecute(r sw.ApiGetPetByIdRequest) (sw.Pet, *http.Response, sw.GenericOpenAPIError) { func (m *MockPetApi) GetPetByIdExecute(r sw.ApiGetPetByIdRequest) (sw.Pet, *http.Response, error) {
return sw.Pet{}, &http.Response{StatusCode:200}, sw.GenericOpenAPIError{} return sw.Pet{}, &http.Response{StatusCode:200}, nil
} }
func (m *MockPetApi) UpdatePet(ctx context.Context) sw.ApiUpdatePetRequest { func (m *MockPetApi) UpdatePet(ctx context.Context) sw.ApiUpdatePetRequest {
return sw.ApiUpdatePetRequest{ApiService: m} return sw.ApiUpdatePetRequest{ApiService: m}
} }
func (m *MockPetApi) UpdatePetExecute(r sw.ApiUpdatePetRequest) (*http.Response, sw.GenericOpenAPIError) { func (m *MockPetApi) UpdatePetExecute(r sw.ApiUpdatePetRequest) (*http.Response, error) {
return &http.Response{StatusCode:200}, sw.GenericOpenAPIError{} return &http.Response{StatusCode:200}, nil
} }
func (m *MockPetApi) UpdatePetWithForm(ctx context.Context, petId int64) sw.ApiUpdatePetWithFormRequest { func (m *MockPetApi) UpdatePetWithForm(ctx context.Context, petId int64) sw.ApiUpdatePetWithFormRequest {
return sw.ApiUpdatePetWithFormRequest{ApiService: m} return sw.ApiUpdatePetWithFormRequest{ApiService: m}
} }
func (m *MockPetApi) UpdatePetWithFormExecute(r sw.ApiUpdatePetWithFormRequest) (*http.Response, sw.GenericOpenAPIError) { func (m *MockPetApi) UpdatePetWithFormExecute(r sw.ApiUpdatePetWithFormRequest) (*http.Response, error) {
return &http.Response{StatusCode:200}, sw.GenericOpenAPIError{} return &http.Response{StatusCode:200}, nil
} }
func (m *MockPetApi) UploadFile(ctx context.Context, petId int64) sw.ApiUploadFileRequest { func (m *MockPetApi) UploadFile(ctx context.Context, petId int64) sw.ApiUploadFileRequest {
return sw.ApiUploadFileRequest{ApiService: m} return sw.ApiUploadFileRequest{ApiService: m}
} }
func (m *MockPetApi) UploadFileExecute(r sw.ApiUploadFileRequest) (sw.ApiResponse, *http.Response, sw.GenericOpenAPIError) { func (m *MockPetApi) UploadFileExecute(r sw.ApiUploadFileRequest) (sw.ApiResponse, *http.Response, error) {
return sw.ApiResponse{}, &http.Response{StatusCode:200}, sw.GenericOpenAPIError{} return sw.ApiResponse{}, &http.Response{StatusCode:200}, nil
} }
func (m *MockPetApi) UploadFileWithRequiredFile(ctx context.Context, petId int64) sw.ApiUploadFileWithRequiredFileRequest { func (m *MockPetApi) UploadFileWithRequiredFile(ctx context.Context, petId int64) sw.ApiUploadFileWithRequiredFileRequest {
return sw.ApiUploadFileWithRequiredFileRequest{ApiService: m} return sw.ApiUploadFileWithRequiredFileRequest{ApiService: m}
} }
func (m *MockPetApi) UploadFileWithRequiredFileExecute(r sw.ApiUploadFileWithRequiredFileRequest) (sw.ApiResponse, *http.Response, sw.GenericOpenAPIError) { func (m *MockPetApi) UploadFileWithRequiredFileExecute(r sw.ApiUploadFileWithRequiredFileRequest) (sw.ApiResponse, *http.Response, error) {
return sw.ApiResponse{}, &http.Response{StatusCode:200}, sw.GenericOpenAPIError{} return sw.ApiResponse{}, &http.Response{StatusCode:200}, nil
} }

25
samples/client/petstore/go/pet_api_test.go
View File

@ -34,7 +34,7 @@ func TestAddPet(t *testing.T) {
r, err := client.PetApi.AddPet(context.Background()).Body(newPet).Execute() r, err := client.PetApi.AddPet(context.Background()).Body(newPet).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -54,7 +54,7 @@ func TestAddPetMock(t *testing.T) {
func TestFindPetsByStatusWithMissingParam(t *testing.T) { func TestFindPetsByStatusWithMissingParam(t *testing.T) {
_, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status(nil).Execute() _, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status(nil).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while testing TestFindPetsByStatusWithMissingParam: %v", err) t.Fatalf("Error while testing TestFindPetsByStatusWithMissingParam: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -69,12 +69,13 @@ func TestGetPetById(t *testing.T) {
func TestGetPetByIdWithInvalidID(t *testing.T) { func TestGetPetByIdWithInvalidID(t *testing.T) {
resp, r, err := client.PetApi.GetPetById(context.Background(), 999999999).Execute() resp, r, err := client.PetApi.GetPetById(context.Background(), 999999999).Execute()
if r != nil && r.StatusCode == 404 { if r != nil && r.StatusCode == 404 {
assertedError := err assertedError, ok := err.(sw.GenericOpenAPIError)
a := assert.New(t) a := assert.New(t)
a.True(ok)
a.Contains(string(assertedError.Body()), "type") a.Contains(string(assertedError.Body()), "type")
a.Contains(assertedError.Error(), "Not Found") a.Contains(assertedError.Error(), "Not Found")
} else if err.Error() != "" { } else if err != nil {
t.Fatalf("Error while getting pet by invalid id: %v", err) t.Fatalf("Error while getting pet by invalid id: %v", err)
t.Log(r) t.Log(r)
} else { } else {
@ -84,7 +85,7 @@ func TestGetPetByIdWithInvalidID(t *testing.T) {
func TestUpdatePetWithForm(t *testing.T) { func TestUpdatePetWithForm(t *testing.T) {
r, err := client.PetApi.UpdatePetWithForm(context.Background(), 12830).Name("golang").Status("available").Execute() r, err := client.PetApi.UpdatePetWithForm(context.Background(), 12830).Name("golang").Status("available").Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while updating pet by id: %v", err) t.Fatalf("Error while updating pet by id: %v", err)
t.Log(r) t.Log(r)
} }
@ -99,7 +100,7 @@ func TestUpdatePetWithForm(t *testing.T) {
func TestFindPetsByTag(t *testing.T) { func TestFindPetsByTag(t *testing.T) {
var found = false var found = false
resp, r, err := client.PetApi.FindPetsByTags(context.Background()).Tags([]string{"tag2"}).Execute() resp, r, err := client.PetApi.FindPetsByTags(context.Background()).Tags([]string{"tag2"}).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while getting pet by tag: %v", err) t.Fatalf("Error while getting pet by tag: %v", err)
t.Log(r) t.Log(r)
} else { } else {
@ -128,7 +129,7 @@ func TestFindPetsByTag(t *testing.T) {
func TestFindPetsByStatus(t *testing.T) { func TestFindPetsByStatus(t *testing.T) {
resp, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status([]string{"available"}).Execute() resp, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status([]string{"available"}).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while getting pet by id: %v", err) t.Fatalf("Error while getting pet by id: %v", err)
t.Log(r) t.Log(r)
} else { } else {
@ -155,7 +156,7 @@ func TestUploadFile(t *testing.T) {
_, r, err := client.PetApi.UploadFile(context.Background(), 12830).AdditionalMetadata("golang").File(file).Execute() _, r, err := client.PetApi.UploadFile(context.Background(), 12830).AdditionalMetadata("golang").File(file).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while uploading file: %v", err) t.Fatalf("Error while uploading file: %v", err)
} }
@ -173,7 +174,7 @@ func TestUploadFileRequired(t *testing.T) {
_, r, err := client.PetApi.UploadFileWithRequiredFile(context.Background(), 12830).RequiredFile(file).AdditionalMetadata("golang").Execute() _, r, err := client.PetApi.UploadFileWithRequiredFile(context.Background(), 12830).RequiredFile(file).AdditionalMetadata("golang").Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while uploading file: %v", err) t.Fatalf("Error while uploading file: %v", err)
} }
@ -185,7 +186,7 @@ func TestUploadFileRequired(t *testing.T) {
func TestDeletePet(t *testing.T) { func TestDeletePet(t *testing.T) {
r, err := client.PetApi.DeletePet(context.Background(), 12830).Execute() r, err := client.PetApi.DeletePet(context.Background(), 12830).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -275,7 +276,7 @@ func waitOnFunctions(t *testing.T, errc chan error, n int) {
func deletePet(t *testing.T, id int64) { func deletePet(t *testing.T, id int64) {
r, err := client.PetApi.DeletePet(context.Background(), id).Execute() r, err := client.PetApi.DeletePet(context.Background(), id).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -286,7 +287,7 @@ func deletePet(t *testing.T, id int64) {
func isPetCorrect(t *testing.T, id int64, name string, status string) { func isPetCorrect(t *testing.T, id int64, name string, status string) {
assert := assert.New(t) assert := assert.New(t)
resp, r, err := client.PetApi.GetPetById(context.Background(), id).Execute() resp, r, err := client.PetApi.GetPetById(context.Background(), id).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while getting pet by id: %v", err) t.Fatalf("Error while getting pet by id: %v", err)
} else { } else {
assert.Equal(*resp.Id, int64(id), "Pet id should be equal") assert.Equal(*resp.Id, int64(id), "Pet id should be equal")

2
samples/client/petstore/go/store_api_test.go
View File

@ -20,7 +20,7 @@ func TestPlaceOrder(t *testing.T) {
_, r, err := client.StoreApi.PlaceOrder(context.Background()).Body(newOrder).Execute() _, r, err := client.StoreApi.PlaceOrder(context.Background()).Body(newOrder).Execute()
if err.Error() != "" { if err != nil {
// Skip parsing time error due to error in Petstore Test Server // Skip parsing time error due to error in Petstore Test Server
// https://github.com/OpenAPITools/openapi-generator/issues/1292 // https://github.com/OpenAPITools/openapi-generator/issues/1292
if regexp. if regexp.

12
samples/client/petstore/go/user_api_test.go
View File

@ -22,7 +22,7 @@ func TestCreateUser(t *testing.T) {
apiResponse, err := client.UserApi.CreateUser(context.Background()).Body(newUser).Execute() apiResponse, err := client.UserApi.CreateUser(context.Background()).Body(newUser).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding user: %v", err) t.Fatalf("Error while adding user: %v", err)
} }
if apiResponse.StatusCode != 200 { if apiResponse.StatusCode != 200 {
@ -56,7 +56,7 @@ func TestCreateUsersWithArrayInput(t *testing.T) {
} }
apiResponse, err := client.UserApi.CreateUsersWithArrayInput(context.Background()).Body(newUsers).Execute() apiResponse, err := client.UserApi.CreateUsersWithArrayInput(context.Background()).Body(newUsers).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding users: %v", err) t.Fatalf("Error while adding users: %v", err)
} }
if apiResponse.StatusCode != 200 { if apiResponse.StatusCode != 200 {
@ -82,7 +82,7 @@ func TestGetUserByName(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
resp, apiResponse, err := client.UserApi.GetUserByName(context.Background(), "gopher").Execute() resp, apiResponse, err := client.UserApi.GetUserByName(context.Background(), "gopher").Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while getting user by id: %v", err) t.Fatalf("Error while getting user by id: %v", err)
} else { } else {
assert.Equal(*resp.Id, int64(1000), "User id should be equal") assert.Equal(*resp.Id, int64(1000), "User id should be equal")
@ -99,7 +99,7 @@ func TestGetUserByNameWithInvalidID(t *testing.T) {
resp, apiResponse, err := client.UserApi.GetUserByName(context.Background(), "999999999").Execute() resp, apiResponse, err := client.UserApi.GetUserByName(context.Background(), "999999999").Execute()
if apiResponse != nil && apiResponse.StatusCode == 404 { if apiResponse != nil && apiResponse.StatusCode == 404 {
return // This is a pass condition. API will return with a 404 error. return // This is a pass condition. API will return with a 404 error.
} else if err.Error() != "" { } else if err != nil {
t.Fatalf("Error while getting user by invalid id: %v", err) t.Fatalf("Error while getting user by invalid id: %v", err)
t.Log(apiResponse) t.Log(apiResponse)
} else { } else {
@ -124,7 +124,7 @@ func TestUpdateUser(t *testing.T) {
UserStatus: sw.PtrInt32(1)} UserStatus: sw.PtrInt32(1)}
apiResponse, err := client.UserApi.UpdateUser(context.Background(), "gopher").Body(newUser).Execute() apiResponse, err := client.UserApi.UpdateUser(context.Background(), "gopher").Body(newUser).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting user by id: %v", err) t.Fatalf("Error while deleting user by id: %v", err)
} }
if apiResponse.StatusCode != 200 { if apiResponse.StatusCode != 200 {
@ -133,7 +133,7 @@ func TestUpdateUser(t *testing.T) {
//verify changings are correct //verify changings are correct
resp, apiResponse, err := client.UserApi.GetUserByName(context.Background(), "gopher").Execute() resp, apiResponse, err := client.UserApi.GetUserByName(context.Background(), "gopher").Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while getting user by id: %v", err) t.Fatalf("Error while getting user by id: %v", err)
} else { } else {
assert.Equal(*resp.Id, int64(1000), "User id should be equal") assert.Equal(*resp.Id, int64(1000), "User id should be equal")

81
samples/openapi3/client/extensions/x-auth-id-alias/go-experimental/api_usage.go
View File

@ -11,7 +11,6 @@
package x_auth_id_alias package x_auth_id_alias
import ( import (
"bytes"
_context "context" _context "context"
_ioutil "io/ioutil" _ioutil "io/ioutil"
_nethttp "net/http" _nethttp "net/http"
@ -32,7 +31,7 @@ type ApiAnyKeyRequest struct {
} }
func (r ApiAnyKeyRequest) Execute() (map[string]interface{}, *_nethttp.Response, GenericOpenAPIError) { func (r ApiAnyKeyRequest) Execute() (map[string]interface{}, *_nethttp.Response, error) {
return r.ApiService.AnyKeyExecute(r) return r.ApiService.AnyKeyExecute(r)
} }
@ -53,21 +52,19 @@ func (a *UsageApiService) AnyKey(ctx _context.Context) ApiAnyKeyRequest {
* Execute executes the request * Execute executes the request
* @return map[string]interface{} * @return map[string]interface{}
*/ */
func (a *UsageApiService) AnyKeyExecute(r ApiAnyKeyRequest) (map[string]interface{}, *_nethttp.Response, GenericOpenAPIError) { func (a *UsageApiService) AnyKeyExecute(r ApiAnyKeyRequest) (map[string]interface{}, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue map[string]interface{} localVarReturnValue map[string]interface{}
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UsageApiService.AnyKey") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UsageApiService.AnyKey")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/any" localVarPath := localBasePath + "/any"
@ -123,22 +120,18 @@ func (a *UsageApiService) AnyKeyExecute(r ApiAnyKeyRequest) (map[string]interfac
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -158,7 +151,7 @@ func (a *UsageApiService) AnyKeyExecute(r ApiAnyKeyRequest) (map[string]interfac
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiBothKeysRequest struct { type ApiBothKeysRequest struct {
@ -167,7 +160,7 @@ type ApiBothKeysRequest struct {
} }
func (r ApiBothKeysRequest) Execute() (map[string]interface{}, *_nethttp.Response, GenericOpenAPIError) { func (r ApiBothKeysRequest) Execute() (map[string]interface{}, *_nethttp.Response, error) {
return r.ApiService.BothKeysExecute(r) return r.ApiService.BothKeysExecute(r)
} }
@ -188,21 +181,19 @@ func (a *UsageApiService) BothKeys(ctx _context.Context) ApiBothKeysRequest {
* Execute executes the request * Execute executes the request
* @return map[string]interface{} * @return map[string]interface{}
*/ */
func (a *UsageApiService) BothKeysExecute(r ApiBothKeysRequest) (map[string]interface{}, *_nethttp.Response, GenericOpenAPIError) { func (a *UsageApiService) BothKeysExecute(r ApiBothKeysRequest) (map[string]interface{}, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue map[string]interface{} localVarReturnValue map[string]interface{}
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UsageApiService.BothKeys") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UsageApiService.BothKeys")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/both" localVarPath := localBasePath + "/both"
@ -258,22 +249,18 @@ func (a *UsageApiService) BothKeysExecute(r ApiBothKeysRequest) (map[string]inte
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -293,7 +280,7 @@ func (a *UsageApiService) BothKeysExecute(r ApiBothKeysRequest) (map[string]inte
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiKeyInHeaderRequest struct { type ApiKeyInHeaderRequest struct {
@ -302,7 +289,7 @@ type ApiKeyInHeaderRequest struct {
} }
func (r ApiKeyInHeaderRequest) Execute() (map[string]interface{}, *_nethttp.Response, GenericOpenAPIError) { func (r ApiKeyInHeaderRequest) Execute() (map[string]interface{}, *_nethttp.Response, error) {
return r.ApiService.KeyInHeaderExecute(r) return r.ApiService.KeyInHeaderExecute(r)
} }
@ -323,21 +310,19 @@ func (a *UsageApiService) KeyInHeader(ctx _context.Context) ApiKeyInHeaderReques
* Execute executes the request * Execute executes the request
* @return map[string]interface{} * @return map[string]interface{}
*/ */
func (a *UsageApiService) KeyInHeaderExecute(r ApiKeyInHeaderRequest) (map[string]interface{}, *_nethttp.Response, GenericOpenAPIError) { func (a *UsageApiService) KeyInHeaderExecute(r ApiKeyInHeaderRequest) (map[string]interface{}, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue map[string]interface{} localVarReturnValue map[string]interface{}
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UsageApiService.KeyInHeader") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UsageApiService.KeyInHeader")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/header" localVarPath := localBasePath + "/header"
@ -379,22 +364,18 @@ func (a *UsageApiService) KeyInHeaderExecute(r ApiKeyInHeaderRequest) (map[strin
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -414,7 +395,7 @@ func (a *UsageApiService) KeyInHeaderExecute(r ApiKeyInHeaderRequest) (map[strin
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiKeyInQueryRequest struct { type ApiKeyInQueryRequest struct {
@ -423,7 +404,7 @@ type ApiKeyInQueryRequest struct {
} }
func (r ApiKeyInQueryRequest) Execute() (map[string]interface{}, *_nethttp.Response, GenericOpenAPIError) { func (r ApiKeyInQueryRequest) Execute() (map[string]interface{}, *_nethttp.Response, error) {
return r.ApiService.KeyInQueryExecute(r) return r.ApiService.KeyInQueryExecute(r)
} }
@ -444,21 +425,19 @@ func (a *UsageApiService) KeyInQuery(ctx _context.Context) ApiKeyInQueryRequest
* Execute executes the request * Execute executes the request
* @return map[string]interface{} * @return map[string]interface{}
*/ */
func (a *UsageApiService) KeyInQueryExecute(r ApiKeyInQueryRequest) (map[string]interface{}, *_nethttp.Response, GenericOpenAPIError) { func (a *UsageApiService) KeyInQueryExecute(r ApiKeyInQueryRequest) (map[string]interface{}, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue map[string]interface{} localVarReturnValue map[string]interface{}
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UsageApiService.KeyInQuery") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UsageApiService.KeyInQuery")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/query" localVarPath := localBasePath + "/query"
@ -500,22 +479,18 @@ func (a *UsageApiService) KeyInQueryExecute(r ApiKeyInQueryRequest) (map[string]
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -535,5 +510,5 @@ func (a *UsageApiService) KeyInQueryExecute(r ApiKeyInQueryRequest) (map[string]
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }

8
samples/openapi3/client/extensions/x-auth-id-alias/go-experimental/docs/UsageApi.md
View File

@ -36,7 +36,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UsageApi.AnyKey(context.Background()).Execute() resp, r, err := api_client.UsageApi.AnyKey(context.Background()).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UsageApi.AnyKey``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UsageApi.AnyKey``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -97,7 +97,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UsageApi.BothKeys(context.Background()).Execute() resp, r, err := api_client.UsageApi.BothKeys(context.Background()).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UsageApi.BothKeys``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UsageApi.BothKeys``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -158,7 +158,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UsageApi.KeyInHeader(context.Background()).Execute() resp, r, err := api_client.UsageApi.KeyInHeader(context.Background()).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UsageApi.KeyInHeader``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UsageApi.KeyInHeader``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -219,7 +219,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UsageApi.KeyInQuery(context.Background()).Execute() resp, r, err := api_client.UsageApi.KeyInQuery(context.Background()).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UsageApi.KeyInQuery``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UsageApi.KeyInQuery``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }

32
samples/openapi3/client/petstore/go/auth_test.go
View File

@ -43,7 +43,7 @@ func TestOAuth2(t *testing.T) {
r, err := client.PetApi.AddPet(context.Background()).Pet(newPet).Execute() r, err := client.PetApi.AddPet(context.Background()).Pet(newPet).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -52,7 +52,7 @@ func TestOAuth2(t *testing.T) {
r, err = client.PetApi.DeletePet(auth, 12992).Execute() r, err = client.PetApi.DeletePet(auth, 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -78,7 +78,7 @@ func TestBasicAuth(t *testing.T) {
r, err := client.PetApi.AddPet(auth).Pet(newPet).Execute() r, err := client.PetApi.AddPet(auth).Pet(newPet).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -87,7 +87,7 @@ func TestBasicAuth(t *testing.T) {
r, err = client.PetApi.DeletePet(auth, 12992).Execute() r, err = client.PetApi.DeletePet(auth, 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -108,7 +108,7 @@ func TestAccessToken(t *testing.T) {
r, err := client.PetApi.AddPet(nil).Pet(newPet).Execute() r, err := client.PetApi.AddPet(nil).Pet(newPet).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -117,7 +117,7 @@ func TestAccessToken(t *testing.T) {
r, err = client.PetApi.DeletePet(auth, 12992).Execute() r, err = client.PetApi.DeletePet(auth, 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -138,7 +138,7 @@ func TestAPIKeyNoPrefix(t *testing.T) {
r, err := client.PetApi.AddPet(context.Background()).Pet(newPet).Execute() r, err := client.PetApi.AddPet(context.Background()).Pet(newPet).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -146,7 +146,7 @@ func TestAPIKeyNoPrefix(t *testing.T) {
} }
_, r, err = client.PetApi.GetPetById(auth, 12992).Execute() _, r, err = client.PetApi.GetPetById(auth, 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
@ -156,7 +156,7 @@ func TestAPIKeyNoPrefix(t *testing.T) {
} }
r, err = client.PetApi.DeletePet(auth, 12992).Execute() r, err = client.PetApi.DeletePet(auth, 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -173,7 +173,7 @@ func TestAPIKeyWithPrefix(t *testing.T) {
r, err := client.PetApi.AddPet(nil).Pet(newPet).Execute() r, err := client.PetApi.AddPet(nil).Pet(newPet).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -181,7 +181,7 @@ func TestAPIKeyWithPrefix(t *testing.T) {
} }
_, r, err = client.PetApi.GetPetById(auth, 12992).Execute() _, r, err = client.PetApi.GetPetById(auth, 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
@ -191,7 +191,7 @@ func TestAPIKeyWithPrefix(t *testing.T) {
} }
r, err = client.PetApi.DeletePet(auth, 12992).Execute() r, err = client.PetApi.DeletePet(auth, 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -206,7 +206,7 @@ func TestDefaultHeader(t *testing.T) {
r, err := client.PetApi.AddPet(context.Background()).Pet(newPet).Execute() r, err := client.PetApi.AddPet(context.Background()).Pet(newPet).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -215,7 +215,7 @@ func TestDefaultHeader(t *testing.T) {
r, err = client.PetApi.DeletePet(context.Background(), 12992).Execute() r, err = client.PetApi.DeletePet(context.Background(), 12992).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -230,7 +230,7 @@ func TestDefaultHeader(t *testing.T) {
func TestHostOverride(t *testing.T) { func TestHostOverride(t *testing.T) {
_, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status(nil).Execute() _, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status(nil).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while finding pets by status: %v", err) t.Fatalf("Error while finding pets by status: %v", err)
} }
@ -242,7 +242,7 @@ func TestHostOverride(t *testing.T) {
func TestSchemeOverride(t *testing.T) { func TestSchemeOverride(t *testing.T) {
_, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status(nil).Execute() _, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status(nil).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while finding pets by status: %v", err) t.Fatalf("Error while finding pets by status: %v", err)
} }

2
samples/openapi3/client/petstore/go/fake_api_test.go
View File

@ -19,7 +19,7 @@ func TestPutBodyWithFileSchema(t *testing.T) {
r, err := client.FakeApi.TestBodyWithFileSchema(context.Background()).FileSchemaTestClass(schema).Execute() r, err := client.FakeApi.TestBodyWithFileSchema(context.Background()).FileSchemaTestClass(schema).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {

26
samples/openapi3/client/petstore/go/go-petstore/api_another_fake.go
View File

@ -11,7 +11,6 @@
package petstore package petstore
import ( import (
"bytes"
_context "context" _context "context"
_ioutil "io/ioutil" _ioutil "io/ioutil"
_nethttp "net/http" _nethttp "net/http"
@ -37,7 +36,7 @@ type AnotherFakeApi interface {
* Call123TestSpecialTagsExecute executes the request * Call123TestSpecialTagsExecute executes the request
* @return Client * @return Client
*/ */
Call123TestSpecialTagsExecute(r ApiCall123TestSpecialTagsRequest) (Client, *_nethttp.Response, GenericOpenAPIError) Call123TestSpecialTagsExecute(r ApiCall123TestSpecialTagsRequest) (Client, *_nethttp.Response, error)
} }
// AnotherFakeApiService AnotherFakeApi service // AnotherFakeApiService AnotherFakeApi service
@ -54,7 +53,7 @@ func (r ApiCall123TestSpecialTagsRequest) Client(client Client) ApiCall123TestSp
return r return r
} }
func (r ApiCall123TestSpecialTagsRequest) Execute() (Client, *_nethttp.Response, GenericOpenAPIError) { func (r ApiCall123TestSpecialTagsRequest) Execute() (Client, *_nethttp.Response, error) {
return r.ApiService.Call123TestSpecialTagsExecute(r) return r.ApiService.Call123TestSpecialTagsExecute(r)
} }
@ -75,21 +74,19 @@ func (a *AnotherFakeApiService) Call123TestSpecialTags(ctx _context.Context) Api
* Execute executes the request * Execute executes the request
* @return Client * @return Client
*/ */
func (a *AnotherFakeApiService) Call123TestSpecialTagsExecute(r ApiCall123TestSpecialTagsRequest) (Client, *_nethttp.Response, GenericOpenAPIError) { func (a *AnotherFakeApiService) Call123TestSpecialTagsExecute(r ApiCall123TestSpecialTagsRequest) (Client, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPatch localVarHTTPMethod = _nethttp.MethodPatch
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue Client localVarReturnValue Client
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AnotherFakeApiService.Call123TestSpecialTags") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AnotherFakeApiService.Call123TestSpecialTags")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/another-fake/dummy" localVarPath := localBasePath + "/another-fake/dummy"
@ -98,8 +95,7 @@ func (a *AnotherFakeApiService) Call123TestSpecialTagsExecute(r ApiCall123TestSp
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.client == nil { if r.client == nil {
executionError.error = "client is required and must be specified" return localVarReturnValue, nil, reportError("client is required and must be specified")
return localVarReturnValue, nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -123,22 +119,18 @@ func (a *AnotherFakeApiService) Call123TestSpecialTagsExecute(r ApiCall123TestSp
localVarPostBody = r.client localVarPostBody = r.client
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -158,5 +150,5 @@ func (a *AnotherFakeApiService) Call123TestSpecialTagsExecute(r ApiCall123TestSp
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }

23
samples/openapi3/client/petstore/go/go-petstore/api_default.go
View File

@ -11,7 +11,6 @@
package petstore package petstore
import ( import (
"bytes"
_context "context" _context "context"
_ioutil "io/ioutil" _ioutil "io/ioutil"
_nethttp "net/http" _nethttp "net/http"
@ -36,7 +35,7 @@ type DefaultApi interface {
* FooGetExecute executes the request * FooGetExecute executes the request
* @return InlineResponseDefault * @return InlineResponseDefault
*/ */
FooGetExecute(r ApiFooGetRequest) (InlineResponseDefault, *_nethttp.Response, GenericOpenAPIError) FooGetExecute(r ApiFooGetRequest) (InlineResponseDefault, *_nethttp.Response, error)
} }
// DefaultApiService DefaultApi service // DefaultApiService DefaultApi service
@ -48,7 +47,7 @@ type ApiFooGetRequest struct {
} }
func (r ApiFooGetRequest) Execute() (InlineResponseDefault, *_nethttp.Response, GenericOpenAPIError) { func (r ApiFooGetRequest) Execute() (InlineResponseDefault, *_nethttp.Response, error) {
return r.ApiService.FooGetExecute(r) return r.ApiService.FooGetExecute(r)
} }
@ -68,21 +67,19 @@ func (a *DefaultApiService) FooGet(ctx _context.Context) ApiFooGetRequest {
* Execute executes the request * Execute executes the request
* @return InlineResponseDefault * @return InlineResponseDefault
*/ */
func (a *DefaultApiService) FooGetExecute(r ApiFooGetRequest) (InlineResponseDefault, *_nethttp.Response, GenericOpenAPIError) { func (a *DefaultApiService) FooGetExecute(r ApiFooGetRequest) (InlineResponseDefault, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue InlineResponseDefault localVarReturnValue InlineResponseDefault
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DefaultApiService.FooGet") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DefaultApiService.FooGet")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/foo" localVarPath := localBasePath + "/foo"
@ -110,22 +107,18 @@ func (a *DefaultApiService) FooGetExecute(r ApiFooGetRequest) (InlineResponseDef
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -152,5 +145,5 @@ func (a *DefaultApiService) FooGetExecute(r ApiFooGetRequest) (InlineResponseDef
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }

378
samples/openapi3/client/petstore/go/go-petstore/api_fake.go
View File

File diff suppressed because it is too large Load Diff

26
samples/openapi3/client/petstore/go/go-petstore/api_fake_classname_tags123.go
View File

@ -11,7 +11,6 @@
package petstore package petstore
import ( import (
"bytes"
_context "context" _context "context"
_ioutil "io/ioutil" _ioutil "io/ioutil"
_nethttp "net/http" _nethttp "net/http"
@ -37,7 +36,7 @@ type FakeClassnameTags123Api interface {
* TestClassnameExecute executes the request * TestClassnameExecute executes the request
* @return Client * @return Client
*/ */
TestClassnameExecute(r ApiTestClassnameRequest) (Client, *_nethttp.Response, GenericOpenAPIError) TestClassnameExecute(r ApiTestClassnameRequest) (Client, *_nethttp.Response, error)
} }
// FakeClassnameTags123ApiService FakeClassnameTags123Api service // FakeClassnameTags123ApiService FakeClassnameTags123Api service
@ -54,7 +53,7 @@ func (r ApiTestClassnameRequest) Client(client Client) ApiTestClassnameRequest {
return r return r
} }
func (r ApiTestClassnameRequest) Execute() (Client, *_nethttp.Response, GenericOpenAPIError) { func (r ApiTestClassnameRequest) Execute() (Client, *_nethttp.Response, error) {
return r.ApiService.TestClassnameExecute(r) return r.ApiService.TestClassnameExecute(r)
} }
@ -75,21 +74,19 @@ func (a *FakeClassnameTags123ApiService) TestClassname(ctx _context.Context) Api
* Execute executes the request * Execute executes the request
* @return Client * @return Client
*/ */
func (a *FakeClassnameTags123ApiService) TestClassnameExecute(r ApiTestClassnameRequest) (Client, *_nethttp.Response, GenericOpenAPIError) { func (a *FakeClassnameTags123ApiService) TestClassnameExecute(r ApiTestClassnameRequest) (Client, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPatch localVarHTTPMethod = _nethttp.MethodPatch
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue Client localVarReturnValue Client
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FakeClassnameTags123ApiService.TestClassname") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FakeClassnameTags123ApiService.TestClassname")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/fake_classname_test" localVarPath := localBasePath + "/fake_classname_test"
@ -98,8 +95,7 @@ func (a *FakeClassnameTags123ApiService) TestClassnameExecute(r ApiTestClassname
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.client == nil { if r.client == nil {
executionError.error = "client is required and must be specified" return localVarReturnValue, nil, reportError("client is required and must be specified")
return localVarReturnValue, nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -137,22 +133,18 @@ func (a *FakeClassnameTags123ApiService) TestClassnameExecute(r ApiTestClassname
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -172,5 +164,5 @@ func (a *FakeClassnameTags123ApiService) TestClassnameExecute(r ApiTestClassname
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }

214
samples/openapi3/client/petstore/go/go-petstore/api_pet.go
View File

@ -11,7 +11,6 @@
package petstore package petstore
import ( import (
"bytes"
_context "context" _context "context"
_ioutil "io/ioutil" _ioutil "io/ioutil"
_nethttp "net/http" _nethttp "net/http"
@ -37,7 +36,7 @@ type PetApi interface {
/* /*
* AddPetExecute executes the request * AddPetExecute executes the request
*/ */
AddPetExecute(r ApiAddPetRequest) (*_nethttp.Response, GenericOpenAPIError) AddPetExecute(r ApiAddPetRequest) (*_nethttp.Response, error)
/* /*
* DeletePet Deletes a pet * DeletePet Deletes a pet
@ -50,7 +49,7 @@ type PetApi interface {
/* /*
* DeletePetExecute executes the request * DeletePetExecute executes the request
*/ */
DeletePetExecute(r ApiDeletePetRequest) (*_nethttp.Response, GenericOpenAPIError) DeletePetExecute(r ApiDeletePetRequest) (*_nethttp.Response, error)
/* /*
* FindPetsByStatus Finds Pets by status * FindPetsByStatus Finds Pets by status
@ -64,7 +63,7 @@ type PetApi interface {
* FindPetsByStatusExecute executes the request * FindPetsByStatusExecute executes the request
* @return []Pet * @return []Pet
*/ */
FindPetsByStatusExecute(r ApiFindPetsByStatusRequest) ([]Pet, *_nethttp.Response, GenericOpenAPIError) FindPetsByStatusExecute(r ApiFindPetsByStatusRequest) ([]Pet, *_nethttp.Response, error)
/* /*
* FindPetsByTags Finds Pets by tags * FindPetsByTags Finds Pets by tags
@ -78,7 +77,7 @@ type PetApi interface {
* FindPetsByTagsExecute executes the request * FindPetsByTagsExecute executes the request
* @return []Pet * @return []Pet
*/ */
FindPetsByTagsExecute(r ApiFindPetsByTagsRequest) ([]Pet, *_nethttp.Response, GenericOpenAPIError) FindPetsByTagsExecute(r ApiFindPetsByTagsRequest) ([]Pet, *_nethttp.Response, error)
/* /*
* GetPetById Find pet by ID * GetPetById Find pet by ID
@ -93,7 +92,7 @@ type PetApi interface {
* GetPetByIdExecute executes the request * GetPetByIdExecute executes the request
* @return Pet * @return Pet
*/ */
GetPetByIdExecute(r ApiGetPetByIdRequest) (Pet, *_nethttp.Response, GenericOpenAPIError) GetPetByIdExecute(r ApiGetPetByIdRequest) (Pet, *_nethttp.Response, error)
/* /*
* UpdatePet Update an existing pet * UpdatePet Update an existing pet
@ -105,7 +104,7 @@ type PetApi interface {
/* /*
* UpdatePetExecute executes the request * UpdatePetExecute executes the request
*/ */
UpdatePetExecute(r ApiUpdatePetRequest) (*_nethttp.Response, GenericOpenAPIError) UpdatePetExecute(r ApiUpdatePetRequest) (*_nethttp.Response, error)
/* /*
* UpdatePetWithForm Updates a pet in the store with form data * UpdatePetWithForm Updates a pet in the store with form data
@ -118,7 +117,7 @@ type PetApi interface {
/* /*
* UpdatePetWithFormExecute executes the request * UpdatePetWithFormExecute executes the request
*/ */
UpdatePetWithFormExecute(r ApiUpdatePetWithFormRequest) (*_nethttp.Response, GenericOpenAPIError) UpdatePetWithFormExecute(r ApiUpdatePetWithFormRequest) (*_nethttp.Response, error)
/* /*
* UploadFile uploads an image * UploadFile uploads an image
@ -132,7 +131,7 @@ type PetApi interface {
* UploadFileExecute executes the request * UploadFileExecute executes the request
* @return ApiResponse * @return ApiResponse
*/ */
UploadFileExecute(r ApiUploadFileRequest) (ApiResponse, *_nethttp.Response, GenericOpenAPIError) UploadFileExecute(r ApiUploadFileRequest) (ApiResponse, *_nethttp.Response, error)
/* /*
* UploadFileWithRequiredFile uploads an image (required) * UploadFileWithRequiredFile uploads an image (required)
@ -146,7 +145,7 @@ type PetApi interface {
* UploadFileWithRequiredFileExecute executes the request * UploadFileWithRequiredFileExecute executes the request
* @return ApiResponse * @return ApiResponse
*/ */
UploadFileWithRequiredFileExecute(r ApiUploadFileWithRequiredFileRequest) (ApiResponse, *_nethttp.Response, GenericOpenAPIError) UploadFileWithRequiredFileExecute(r ApiUploadFileWithRequiredFileRequest) (ApiResponse, *_nethttp.Response, error)
} }
// PetApiService PetApi service // PetApiService PetApi service
@ -163,7 +162,7 @@ func (r ApiAddPetRequest) Pet(pet Pet) ApiAddPetRequest {
return r return r
} }
func (r ApiAddPetRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiAddPetRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.AddPetExecute(r) return r.ApiService.AddPetExecute(r)
} }
@ -182,20 +181,18 @@ func (a *PetApiService) AddPet(ctx _context.Context) ApiAddPetRequest {
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *PetApiService) AddPetExecute(r ApiAddPetRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) AddPetExecute(r ApiAddPetRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.AddPet") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.AddPet")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/pet" localVarPath := localBasePath + "/pet"
@ -204,8 +201,7 @@ func (a *PetApiService) AddPetExecute(r ApiAddPetRequest) (*_nethttp.Response, G
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.pet == nil { if r.pet == nil {
executionError.error = "pet is required and must be specified" return nil, reportError("pet is required and must be specified")
return nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -229,22 +225,18 @@ func (a *PetApiService) AddPetExecute(r ApiAddPetRequest) (*_nethttp.Response, G
localVarPostBody = r.pet localVarPostBody = r.pet
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -255,7 +247,7 @@ func (a *PetApiService) AddPetExecute(r ApiAddPetRequest) (*_nethttp.Response, G
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiDeletePetRequest struct { type ApiDeletePetRequest struct {
@ -270,7 +262,7 @@ func (r ApiDeletePetRequest) ApiKey(apiKey string) ApiDeletePetRequest {
return r return r
} }
func (r ApiDeletePetRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiDeletePetRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.DeletePetExecute(r) return r.ApiService.DeletePetExecute(r)
} }
@ -291,20 +283,18 @@ func (a *PetApiService) DeletePet(ctx _context.Context, petId int64) ApiDeletePe
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *PetApiService) DeletePetExecute(r ApiDeletePetRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) DeletePetExecute(r ApiDeletePetRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodDelete localVarHTTPMethod = _nethttp.MethodDelete
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.DeletePet") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.DeletePet")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/pet/{petId}" localVarPath := localBasePath + "/pet/{petId}"
@ -336,22 +326,18 @@ func (a *PetApiService) DeletePetExecute(r ApiDeletePetRequest) (*_nethttp.Respo
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -362,7 +348,7 @@ func (a *PetApiService) DeletePetExecute(r ApiDeletePetRequest) (*_nethttp.Respo
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiFindPetsByStatusRequest struct { type ApiFindPetsByStatusRequest struct {
@ -376,7 +362,7 @@ func (r ApiFindPetsByStatusRequest) Status(status []string) ApiFindPetsByStatusR
return r return r
} }
func (r ApiFindPetsByStatusRequest) Execute() ([]Pet, *_nethttp.Response, GenericOpenAPIError) { func (r ApiFindPetsByStatusRequest) Execute() ([]Pet, *_nethttp.Response, error) {
return r.ApiService.FindPetsByStatusExecute(r) return r.ApiService.FindPetsByStatusExecute(r)
} }
@ -397,21 +383,19 @@ func (a *PetApiService) FindPetsByStatus(ctx _context.Context) ApiFindPetsByStat
* Execute executes the request * Execute executes the request
* @return []Pet * @return []Pet
*/ */
func (a *PetApiService) FindPetsByStatusExecute(r ApiFindPetsByStatusRequest) ([]Pet, *_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) FindPetsByStatusExecute(r ApiFindPetsByStatusRequest) ([]Pet, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue []Pet localVarReturnValue []Pet
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.FindPetsByStatus") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.FindPetsByStatus")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/pet/findByStatus" localVarPath := localBasePath + "/pet/findByStatus"
@ -420,8 +404,7 @@ func (a *PetApiService) FindPetsByStatusExecute(r ApiFindPetsByStatusRequest) ([
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.status == nil { if r.status == nil {
executionError.error = "status is required and must be specified" return localVarReturnValue, nil, reportError("status is required and must be specified")
return localVarReturnValue, nil, executionError
} }
localVarQueryParams.Add("status", parameterToString(*r.status, "csv")) localVarQueryParams.Add("status", parameterToString(*r.status, "csv"))
@ -444,22 +427,18 @@ func (a *PetApiService) FindPetsByStatusExecute(r ApiFindPetsByStatusRequest) ([
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -479,7 +458,7 @@ func (a *PetApiService) FindPetsByStatusExecute(r ApiFindPetsByStatusRequest) ([
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiFindPetsByTagsRequest struct { type ApiFindPetsByTagsRequest struct {
@ -493,7 +472,7 @@ func (r ApiFindPetsByTagsRequest) Tags(tags []string) ApiFindPetsByTagsRequest {
return r return r
} }
func (r ApiFindPetsByTagsRequest) Execute() ([]Pet, *_nethttp.Response, GenericOpenAPIError) { func (r ApiFindPetsByTagsRequest) Execute() ([]Pet, *_nethttp.Response, error) {
return r.ApiService.FindPetsByTagsExecute(r) return r.ApiService.FindPetsByTagsExecute(r)
} }
@ -514,21 +493,19 @@ func (a *PetApiService) FindPetsByTags(ctx _context.Context) ApiFindPetsByTagsRe
* Execute executes the request * Execute executes the request
* @return []Pet * @return []Pet
*/ */
func (a *PetApiService) FindPetsByTagsExecute(r ApiFindPetsByTagsRequest) ([]Pet, *_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) FindPetsByTagsExecute(r ApiFindPetsByTagsRequest) ([]Pet, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue []Pet localVarReturnValue []Pet
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.FindPetsByTags") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.FindPetsByTags")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/pet/findByTags" localVarPath := localBasePath + "/pet/findByTags"
@ -537,8 +514,7 @@ func (a *PetApiService) FindPetsByTagsExecute(r ApiFindPetsByTagsRequest) ([]Pet
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.tags == nil { if r.tags == nil {
executionError.error = "tags is required and must be specified" return localVarReturnValue, nil, reportError("tags is required and must be specified")
return localVarReturnValue, nil, executionError
} }
localVarQueryParams.Add("tags", parameterToString(*r.tags, "csv")) localVarQueryParams.Add("tags", parameterToString(*r.tags, "csv"))
@ -561,22 +537,18 @@ func (a *PetApiService) FindPetsByTagsExecute(r ApiFindPetsByTagsRequest) ([]Pet
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -596,7 +568,7 @@ func (a *PetApiService) FindPetsByTagsExecute(r ApiFindPetsByTagsRequest) ([]Pet
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiGetPetByIdRequest struct { type ApiGetPetByIdRequest struct {
@ -606,7 +578,7 @@ type ApiGetPetByIdRequest struct {
} }
func (r ApiGetPetByIdRequest) Execute() (Pet, *_nethttp.Response, GenericOpenAPIError) { func (r ApiGetPetByIdRequest) Execute() (Pet, *_nethttp.Response, error) {
return r.ApiService.GetPetByIdExecute(r) return r.ApiService.GetPetByIdExecute(r)
} }
@ -629,21 +601,19 @@ func (a *PetApiService) GetPetById(ctx _context.Context, petId int64) ApiGetPetB
* Execute executes the request * Execute executes the request
* @return Pet * @return Pet
*/ */
func (a *PetApiService) GetPetByIdExecute(r ApiGetPetByIdRequest) (Pet, *_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) GetPetByIdExecute(r ApiGetPetByIdRequest) (Pet, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue Pet localVarReturnValue Pet
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.GetPetById") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.GetPetById")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/pet/{petId}" localVarPath := localBasePath + "/pet/{petId}"
@ -686,22 +656,18 @@ func (a *PetApiService) GetPetByIdExecute(r ApiGetPetByIdRequest) (Pet, *_nethtt
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -721,7 +687,7 @@ func (a *PetApiService) GetPetByIdExecute(r ApiGetPetByIdRequest) (Pet, *_nethtt
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiUpdatePetRequest struct { type ApiUpdatePetRequest struct {
@ -735,7 +701,7 @@ func (r ApiUpdatePetRequest) Pet(pet Pet) ApiUpdatePetRequest {
return r return r
} }
func (r ApiUpdatePetRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiUpdatePetRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.UpdatePetExecute(r) return r.ApiService.UpdatePetExecute(r)
} }
@ -754,20 +720,18 @@ func (a *PetApiService) UpdatePet(ctx _context.Context) ApiUpdatePetRequest {
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *PetApiService) UpdatePetExecute(r ApiUpdatePetRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) UpdatePetExecute(r ApiUpdatePetRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPut localVarHTTPMethod = _nethttp.MethodPut
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UpdatePet") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UpdatePet")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/pet" localVarPath := localBasePath + "/pet"
@ -776,8 +740,7 @@ func (a *PetApiService) UpdatePetExecute(r ApiUpdatePetRequest) (*_nethttp.Respo
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.pet == nil { if r.pet == nil {
executionError.error = "pet is required and must be specified" return nil, reportError("pet is required and must be specified")
return nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -801,22 +764,18 @@ func (a *PetApiService) UpdatePetExecute(r ApiUpdatePetRequest) (*_nethttp.Respo
localVarPostBody = r.pet localVarPostBody = r.pet
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -827,7 +786,7 @@ func (a *PetApiService) UpdatePetExecute(r ApiUpdatePetRequest) (*_nethttp.Respo
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiUpdatePetWithFormRequest struct { type ApiUpdatePetWithFormRequest struct {
@ -847,7 +806,7 @@ func (r ApiUpdatePetWithFormRequest) Status(status string) ApiUpdatePetWithFormR
return r return r
} }
func (r ApiUpdatePetWithFormRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiUpdatePetWithFormRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.UpdatePetWithFormExecute(r) return r.ApiService.UpdatePetWithFormExecute(r)
} }
@ -868,20 +827,18 @@ func (a *PetApiService) UpdatePetWithForm(ctx _context.Context, petId int64) Api
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *PetApiService) UpdatePetWithFormExecute(r ApiUpdatePetWithFormRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) UpdatePetWithFormExecute(r ApiUpdatePetWithFormRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UpdatePetWithForm") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UpdatePetWithForm")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/pet/{petId}" localVarPath := localBasePath + "/pet/{petId}"
@ -916,22 +873,18 @@ func (a *PetApiService) UpdatePetWithFormExecute(r ApiUpdatePetWithFormRequest)
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -942,7 +895,7 @@ func (a *PetApiService) UpdatePetWithFormExecute(r ApiUpdatePetWithFormRequest)
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiUploadFileRequest struct { type ApiUploadFileRequest struct {
@ -962,7 +915,7 @@ func (r ApiUploadFileRequest) File(file *os.File) ApiUploadFileRequest {
return r return r
} }
func (r ApiUploadFileRequest) Execute() (ApiResponse, *_nethttp.Response, GenericOpenAPIError) { func (r ApiUploadFileRequest) Execute() (ApiResponse, *_nethttp.Response, error) {
return r.ApiService.UploadFileExecute(r) return r.ApiService.UploadFileExecute(r)
} }
@ -984,21 +937,19 @@ func (a *PetApiService) UploadFile(ctx _context.Context, petId int64) ApiUploadF
* Execute executes the request * Execute executes the request
* @return ApiResponse * @return ApiResponse
*/ */
func (a *PetApiService) UploadFileExecute(r ApiUploadFileRequest) (ApiResponse, *_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) UploadFileExecute(r ApiUploadFileRequest) (ApiResponse, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue ApiResponse localVarReturnValue ApiResponse
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UploadFile") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UploadFile")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/pet/{petId}/uploadImage" localVarPath := localBasePath + "/pet/{petId}/uploadImage"
@ -1041,22 +992,18 @@ func (a *PetApiService) UploadFileExecute(r ApiUploadFileRequest) (ApiResponse,
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -1076,7 +1023,7 @@ func (a *PetApiService) UploadFileExecute(r ApiUploadFileRequest) (ApiResponse,
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiUploadFileWithRequiredFileRequest struct { type ApiUploadFileWithRequiredFileRequest struct {
@ -1096,7 +1043,7 @@ func (r ApiUploadFileWithRequiredFileRequest) AdditionalMetadata(additionalMetad
return r return r
} }
func (r ApiUploadFileWithRequiredFileRequest) Execute() (ApiResponse, *_nethttp.Response, GenericOpenAPIError) { func (r ApiUploadFileWithRequiredFileRequest) Execute() (ApiResponse, *_nethttp.Response, error) {
return r.ApiService.UploadFileWithRequiredFileExecute(r) return r.ApiService.UploadFileWithRequiredFileExecute(r)
} }
@ -1118,21 +1065,19 @@ func (a *PetApiService) UploadFileWithRequiredFile(ctx _context.Context, petId i
* Execute executes the request * Execute executes the request
* @return ApiResponse * @return ApiResponse
*/ */
func (a *PetApiService) UploadFileWithRequiredFileExecute(r ApiUploadFileWithRequiredFileRequest) (ApiResponse, *_nethttp.Response, GenericOpenAPIError) { func (a *PetApiService) UploadFileWithRequiredFileExecute(r ApiUploadFileWithRequiredFileRequest) (ApiResponse, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue ApiResponse localVarReturnValue ApiResponse
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UploadFileWithRequiredFile") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PetApiService.UploadFileWithRequiredFile")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/fake/{petId}/uploadImageWithRequiredFile" localVarPath := localBasePath + "/fake/{petId}/uploadImageWithRequiredFile"
@ -1142,8 +1087,7 @@ func (a *PetApiService) UploadFileWithRequiredFileExecute(r ApiUploadFileWithReq
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.requiredFile == nil { if r.requiredFile == nil {
executionError.error = "requiredFile is required and must be specified" return localVarReturnValue, nil, reportError("requiredFile is required and must be specified")
return localVarReturnValue, nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -1176,22 +1120,18 @@ func (a *PetApiService) UploadFileWithRequiredFileExecute(r ApiUploadFileWithReq
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -1211,5 +1151,5 @@ func (a *PetApiService) UploadFileWithRequiredFileExecute(r ApiUploadFileWithReq
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }

98
samples/openapi3/client/petstore/go/go-petstore/api_store.go
View File

@ -11,7 +11,6 @@
package petstore package petstore
import ( import (
"bytes"
_context "context" _context "context"
_ioutil "io/ioutil" _ioutil "io/ioutil"
_nethttp "net/http" _nethttp "net/http"
@ -38,7 +37,7 @@ type StoreApi interface {
/* /*
* DeleteOrderExecute executes the request * DeleteOrderExecute executes the request
*/ */
DeleteOrderExecute(r ApiDeleteOrderRequest) (*_nethttp.Response, GenericOpenAPIError) DeleteOrderExecute(r ApiDeleteOrderRequest) (*_nethttp.Response, error)
/* /*
* GetInventory Returns pet inventories by status * GetInventory Returns pet inventories by status
@ -52,7 +51,7 @@ type StoreApi interface {
* GetInventoryExecute executes the request * GetInventoryExecute executes the request
* @return map[string]int32 * @return map[string]int32
*/ */
GetInventoryExecute(r ApiGetInventoryRequest) (map[string]int32, *_nethttp.Response, GenericOpenAPIError) GetInventoryExecute(r ApiGetInventoryRequest) (map[string]int32, *_nethttp.Response, error)
/* /*
* GetOrderById Find purchase order by ID * GetOrderById Find purchase order by ID
@ -67,7 +66,7 @@ type StoreApi interface {
* GetOrderByIdExecute executes the request * GetOrderByIdExecute executes the request
* @return Order * @return Order
*/ */
GetOrderByIdExecute(r ApiGetOrderByIdRequest) (Order, *_nethttp.Response, GenericOpenAPIError) GetOrderByIdExecute(r ApiGetOrderByIdRequest) (Order, *_nethttp.Response, error)
/* /*
* PlaceOrder Place an order for a pet * PlaceOrder Place an order for a pet
@ -80,7 +79,7 @@ type StoreApi interface {
* PlaceOrderExecute executes the request * PlaceOrderExecute executes the request
* @return Order * @return Order
*/ */
PlaceOrderExecute(r ApiPlaceOrderRequest) (Order, *_nethttp.Response, GenericOpenAPIError) PlaceOrderExecute(r ApiPlaceOrderRequest) (Order, *_nethttp.Response, error)
} }
// StoreApiService StoreApi service // StoreApiService StoreApi service
@ -93,7 +92,7 @@ type ApiDeleteOrderRequest struct {
} }
func (r ApiDeleteOrderRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiDeleteOrderRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.DeleteOrderExecute(r) return r.ApiService.DeleteOrderExecute(r)
} }
@ -115,20 +114,18 @@ func (a *StoreApiService) DeleteOrder(ctx _context.Context, orderId string) ApiD
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *StoreApiService) DeleteOrderExecute(r ApiDeleteOrderRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *StoreApiService) DeleteOrderExecute(r ApiDeleteOrderRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodDelete localVarHTTPMethod = _nethttp.MethodDelete
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.DeleteOrder") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.DeleteOrder")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/store/order/{order_id}" localVarPath := localBasePath + "/store/order/{order_id}"
@ -157,22 +154,18 @@ func (a *StoreApiService) DeleteOrderExecute(r ApiDeleteOrderRequest) (*_nethttp
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -183,7 +176,7 @@ func (a *StoreApiService) DeleteOrderExecute(r ApiDeleteOrderRequest) (*_nethttp
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiGetInventoryRequest struct { type ApiGetInventoryRequest struct {
@ -192,7 +185,7 @@ type ApiGetInventoryRequest struct {
} }
func (r ApiGetInventoryRequest) Execute() (map[string]int32, *_nethttp.Response, GenericOpenAPIError) { func (r ApiGetInventoryRequest) Execute() (map[string]int32, *_nethttp.Response, error) {
return r.ApiService.GetInventoryExecute(r) return r.ApiService.GetInventoryExecute(r)
} }
@ -213,21 +206,19 @@ func (a *StoreApiService) GetInventory(ctx _context.Context) ApiGetInventoryRequ
* Execute executes the request * Execute executes the request
* @return map[string]int32 * @return map[string]int32
*/ */
func (a *StoreApiService) GetInventoryExecute(r ApiGetInventoryRequest) (map[string]int32, *_nethttp.Response, GenericOpenAPIError) { func (a *StoreApiService) GetInventoryExecute(r ApiGetInventoryRequest) (map[string]int32, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue map[string]int32 localVarReturnValue map[string]int32
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.GetInventory") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.GetInventory")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/store/inventory" localVarPath := localBasePath + "/store/inventory"
@ -269,22 +260,18 @@ func (a *StoreApiService) GetInventoryExecute(r ApiGetInventoryRequest) (map[str
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -304,7 +291,7 @@ func (a *StoreApiService) GetInventoryExecute(r ApiGetInventoryRequest) (map[str
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiGetOrderByIdRequest struct { type ApiGetOrderByIdRequest struct {
@ -314,7 +301,7 @@ type ApiGetOrderByIdRequest struct {
} }
func (r ApiGetOrderByIdRequest) Execute() (Order, *_nethttp.Response, GenericOpenAPIError) { func (r ApiGetOrderByIdRequest) Execute() (Order, *_nethttp.Response, error) {
return r.ApiService.GetOrderByIdExecute(r) return r.ApiService.GetOrderByIdExecute(r)
} }
@ -337,21 +324,19 @@ func (a *StoreApiService) GetOrderById(ctx _context.Context, orderId int64) ApiG
* Execute executes the request * Execute executes the request
* @return Order * @return Order
*/ */
func (a *StoreApiService) GetOrderByIdExecute(r ApiGetOrderByIdRequest) (Order, *_nethttp.Response, GenericOpenAPIError) { func (a *StoreApiService) GetOrderByIdExecute(r ApiGetOrderByIdRequest) (Order, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue Order localVarReturnValue Order
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.GetOrderById") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.GetOrderById")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/store/order/{order_id}" localVarPath := localBasePath + "/store/order/{order_id}"
@ -361,12 +346,10 @@ func (a *StoreApiService) GetOrderByIdExecute(r ApiGetOrderByIdRequest) (Order,
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.orderId < 1 { if r.orderId < 1 {
executionError.error = "orderId must be greater than 1" return localVarReturnValue, nil, reportError("orderId must be greater than 1")
return localVarReturnValue, nil, executionError
} }
if r.orderId > 5 { if r.orderId > 5 {
executionError.error = "orderId must be less than 5" return localVarReturnValue, nil, reportError("orderId must be less than 5")
return localVarReturnValue, nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -388,22 +371,18 @@ func (a *StoreApiService) GetOrderByIdExecute(r ApiGetOrderByIdRequest) (Order,
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -423,7 +402,7 @@ func (a *StoreApiService) GetOrderByIdExecute(r ApiGetOrderByIdRequest) (Order,
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiPlaceOrderRequest struct { type ApiPlaceOrderRequest struct {
@ -437,7 +416,7 @@ func (r ApiPlaceOrderRequest) Order(order Order) ApiPlaceOrderRequest {
return r return r
} }
func (r ApiPlaceOrderRequest) Execute() (Order, *_nethttp.Response, GenericOpenAPIError) { func (r ApiPlaceOrderRequest) Execute() (Order, *_nethttp.Response, error) {
return r.ApiService.PlaceOrderExecute(r) return r.ApiService.PlaceOrderExecute(r)
} }
@ -457,21 +436,19 @@ func (a *StoreApiService) PlaceOrder(ctx _context.Context) ApiPlaceOrderRequest
* Execute executes the request * Execute executes the request
* @return Order * @return Order
*/ */
func (a *StoreApiService) PlaceOrderExecute(r ApiPlaceOrderRequest) (Order, *_nethttp.Response, GenericOpenAPIError) { func (a *StoreApiService) PlaceOrderExecute(r ApiPlaceOrderRequest) (Order, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue Order localVarReturnValue Order
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.PlaceOrder") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "StoreApiService.PlaceOrder")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/store/order" localVarPath := localBasePath + "/store/order"
@ -480,8 +457,7 @@ func (a *StoreApiService) PlaceOrderExecute(r ApiPlaceOrderRequest) (Order, *_ne
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.order == nil { if r.order == nil {
executionError.error = "order is required and must be specified" return localVarReturnValue, nil, reportError("order is required and must be specified")
return localVarReturnValue, nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -505,22 +481,18 @@ func (a *StoreApiService) PlaceOrderExecute(r ApiPlaceOrderRequest) (Order, *_ne
localVarPostBody = r.order localVarPostBody = r.order
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -540,5 +512,5 @@ func (a *StoreApiService) PlaceOrderExecute(r ApiPlaceOrderRequest) (Order, *_ne
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }

195
samples/openapi3/client/petstore/go/go-petstore/api_user.go
View File

@ -11,7 +11,6 @@
package petstore package petstore
import ( import (
"bytes"
_context "context" _context "context"
_ioutil "io/ioutil" _ioutil "io/ioutil"
_nethttp "net/http" _nethttp "net/http"
@ -37,7 +36,7 @@ type UserApi interface {
/* /*
* CreateUserExecute executes the request * CreateUserExecute executes the request
*/ */
CreateUserExecute(r ApiCreateUserRequest) (*_nethttp.Response, GenericOpenAPIError) CreateUserExecute(r ApiCreateUserRequest) (*_nethttp.Response, error)
/* /*
* CreateUsersWithArrayInput Creates list of users with given input array * CreateUsersWithArrayInput Creates list of users with given input array
@ -49,7 +48,7 @@ type UserApi interface {
/* /*
* CreateUsersWithArrayInputExecute executes the request * CreateUsersWithArrayInputExecute executes the request
*/ */
CreateUsersWithArrayInputExecute(r ApiCreateUsersWithArrayInputRequest) (*_nethttp.Response, GenericOpenAPIError) CreateUsersWithArrayInputExecute(r ApiCreateUsersWithArrayInputRequest) (*_nethttp.Response, error)
/* /*
* CreateUsersWithListInput Creates list of users with given input array * CreateUsersWithListInput Creates list of users with given input array
@ -61,7 +60,7 @@ type UserApi interface {
/* /*
* CreateUsersWithListInputExecute executes the request * CreateUsersWithListInputExecute executes the request
*/ */
CreateUsersWithListInputExecute(r ApiCreateUsersWithListInputRequest) (*_nethttp.Response, GenericOpenAPIError) CreateUsersWithListInputExecute(r ApiCreateUsersWithListInputRequest) (*_nethttp.Response, error)
/* /*
* DeleteUser Delete user * DeleteUser Delete user
@ -75,7 +74,7 @@ type UserApi interface {
/* /*
* DeleteUserExecute executes the request * DeleteUserExecute executes the request
*/ */
DeleteUserExecute(r ApiDeleteUserRequest) (*_nethttp.Response, GenericOpenAPIError) DeleteUserExecute(r ApiDeleteUserRequest) (*_nethttp.Response, error)
/* /*
* GetUserByName Get user by user name * GetUserByName Get user by user name
@ -89,7 +88,7 @@ type UserApi interface {
* GetUserByNameExecute executes the request * GetUserByNameExecute executes the request
* @return User * @return User
*/ */
GetUserByNameExecute(r ApiGetUserByNameRequest) (User, *_nethttp.Response, GenericOpenAPIError) GetUserByNameExecute(r ApiGetUserByNameRequest) (User, *_nethttp.Response, error)
/* /*
* LoginUser Logs user into the system * LoginUser Logs user into the system
@ -102,7 +101,7 @@ type UserApi interface {
* LoginUserExecute executes the request * LoginUserExecute executes the request
* @return string * @return string
*/ */
LoginUserExecute(r ApiLoginUserRequest) (string, *_nethttp.Response, GenericOpenAPIError) LoginUserExecute(r ApiLoginUserRequest) (string, *_nethttp.Response, error)
/* /*
* LogoutUser Logs out current logged in user session * LogoutUser Logs out current logged in user session
@ -114,7 +113,7 @@ type UserApi interface {
/* /*
* LogoutUserExecute executes the request * LogoutUserExecute executes the request
*/ */
LogoutUserExecute(r ApiLogoutUserRequest) (*_nethttp.Response, GenericOpenAPIError) LogoutUserExecute(r ApiLogoutUserRequest) (*_nethttp.Response, error)
/* /*
* UpdateUser Updated user * UpdateUser Updated user
@ -128,7 +127,7 @@ type UserApi interface {
/* /*
* UpdateUserExecute executes the request * UpdateUserExecute executes the request
*/ */
UpdateUserExecute(r ApiUpdateUserRequest) (*_nethttp.Response, GenericOpenAPIError) UpdateUserExecute(r ApiUpdateUserRequest) (*_nethttp.Response, error)
} }
// UserApiService UserApi service // UserApiService UserApi service
@ -145,7 +144,7 @@ func (r ApiCreateUserRequest) User(user User) ApiCreateUserRequest {
return r return r
} }
func (r ApiCreateUserRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiCreateUserRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.CreateUserExecute(r) return r.ApiService.CreateUserExecute(r)
} }
@ -165,20 +164,18 @@ func (a *UserApiService) CreateUser(ctx _context.Context) ApiCreateUserRequest {
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *UserApiService) CreateUserExecute(r ApiCreateUserRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) CreateUserExecute(r ApiCreateUserRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.CreateUser") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.CreateUser")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/user" localVarPath := localBasePath + "/user"
@ -187,8 +184,7 @@ func (a *UserApiService) CreateUserExecute(r ApiCreateUserRequest) (*_nethttp.Re
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.user == nil { if r.user == nil {
executionError.error = "user is required and must be specified" return nil, reportError("user is required and must be specified")
return nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -212,22 +208,18 @@ func (a *UserApiService) CreateUserExecute(r ApiCreateUserRequest) (*_nethttp.Re
localVarPostBody = r.user localVarPostBody = r.user
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -238,7 +230,7 @@ func (a *UserApiService) CreateUserExecute(r ApiCreateUserRequest) (*_nethttp.Re
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiCreateUsersWithArrayInputRequest struct { type ApiCreateUsersWithArrayInputRequest struct {
@ -252,7 +244,7 @@ func (r ApiCreateUsersWithArrayInputRequest) User(user []User) ApiCreateUsersWit
return r return r
} }
func (r ApiCreateUsersWithArrayInputRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiCreateUsersWithArrayInputRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.CreateUsersWithArrayInputExecute(r) return r.ApiService.CreateUsersWithArrayInputExecute(r)
} }
@ -271,20 +263,18 @@ func (a *UserApiService) CreateUsersWithArrayInput(ctx _context.Context) ApiCrea
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *UserApiService) CreateUsersWithArrayInputExecute(r ApiCreateUsersWithArrayInputRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) CreateUsersWithArrayInputExecute(r ApiCreateUsersWithArrayInputRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.CreateUsersWithArrayInput") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.CreateUsersWithArrayInput")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/user/createWithArray" localVarPath := localBasePath + "/user/createWithArray"
@ -293,8 +283,7 @@ func (a *UserApiService) CreateUsersWithArrayInputExecute(r ApiCreateUsersWithAr
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.user == nil { if r.user == nil {
executionError.error = "user is required and must be specified" return nil, reportError("user is required and must be specified")
return nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -318,22 +307,18 @@ func (a *UserApiService) CreateUsersWithArrayInputExecute(r ApiCreateUsersWithAr
localVarPostBody = r.user localVarPostBody = r.user
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -344,7 +329,7 @@ func (a *UserApiService) CreateUsersWithArrayInputExecute(r ApiCreateUsersWithAr
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiCreateUsersWithListInputRequest struct { type ApiCreateUsersWithListInputRequest struct {
@ -358,7 +343,7 @@ func (r ApiCreateUsersWithListInputRequest) User(user []User) ApiCreateUsersWith
return r return r
} }
func (r ApiCreateUsersWithListInputRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiCreateUsersWithListInputRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.CreateUsersWithListInputExecute(r) return r.ApiService.CreateUsersWithListInputExecute(r)
} }
@ -377,20 +362,18 @@ func (a *UserApiService) CreateUsersWithListInput(ctx _context.Context) ApiCreat
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *UserApiService) CreateUsersWithListInputExecute(r ApiCreateUsersWithListInputRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) CreateUsersWithListInputExecute(r ApiCreateUsersWithListInputRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPost localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.CreateUsersWithListInput") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.CreateUsersWithListInput")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/user/createWithList" localVarPath := localBasePath + "/user/createWithList"
@ -399,8 +382,7 @@ func (a *UserApiService) CreateUsersWithListInputExecute(r ApiCreateUsersWithLis
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.user == nil { if r.user == nil {
executionError.error = "user is required and must be specified" return nil, reportError("user is required and must be specified")
return nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -424,22 +406,18 @@ func (a *UserApiService) CreateUsersWithListInputExecute(r ApiCreateUsersWithLis
localVarPostBody = r.user localVarPostBody = r.user
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -450,7 +428,7 @@ func (a *UserApiService) CreateUsersWithListInputExecute(r ApiCreateUsersWithLis
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiDeleteUserRequest struct { type ApiDeleteUserRequest struct {
@ -460,7 +438,7 @@ type ApiDeleteUserRequest struct {
} }
func (r ApiDeleteUserRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiDeleteUserRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.DeleteUserExecute(r) return r.ApiService.DeleteUserExecute(r)
} }
@ -482,20 +460,18 @@ func (a *UserApiService) DeleteUser(ctx _context.Context, username string) ApiDe
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *UserApiService) DeleteUserExecute(r ApiDeleteUserRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) DeleteUserExecute(r ApiDeleteUserRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodDelete localVarHTTPMethod = _nethttp.MethodDelete
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.DeleteUser") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.DeleteUser")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/user/{username}" localVarPath := localBasePath + "/user/{username}"
@ -524,22 +500,18 @@ func (a *UserApiService) DeleteUserExecute(r ApiDeleteUserRequest) (*_nethttp.Re
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -550,7 +522,7 @@ func (a *UserApiService) DeleteUserExecute(r ApiDeleteUserRequest) (*_nethttp.Re
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiGetUserByNameRequest struct { type ApiGetUserByNameRequest struct {
@ -560,7 +532,7 @@ type ApiGetUserByNameRequest struct {
} }
func (r ApiGetUserByNameRequest) Execute() (User, *_nethttp.Response, GenericOpenAPIError) { func (r ApiGetUserByNameRequest) Execute() (User, *_nethttp.Response, error) {
return r.ApiService.GetUserByNameExecute(r) return r.ApiService.GetUserByNameExecute(r)
} }
@ -582,21 +554,19 @@ func (a *UserApiService) GetUserByName(ctx _context.Context, username string) Ap
* Execute executes the request * Execute executes the request
* @return User * @return User
*/ */
func (a *UserApiService) GetUserByNameExecute(r ApiGetUserByNameRequest) (User, *_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) GetUserByNameExecute(r ApiGetUserByNameRequest) (User, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue User localVarReturnValue User
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.GetUserByName") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.GetUserByName")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/user/{username}" localVarPath := localBasePath + "/user/{username}"
@ -625,22 +595,18 @@ func (a *UserApiService) GetUserByNameExecute(r ApiGetUserByNameRequest) (User,
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -660,7 +626,7 @@ func (a *UserApiService) GetUserByNameExecute(r ApiGetUserByNameRequest) (User,
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiLoginUserRequest struct { type ApiLoginUserRequest struct {
@ -679,7 +645,7 @@ func (r ApiLoginUserRequest) Password(password string) ApiLoginUserRequest {
return r return r
} }
func (r ApiLoginUserRequest) Execute() (string, *_nethttp.Response, GenericOpenAPIError) { func (r ApiLoginUserRequest) Execute() (string, *_nethttp.Response, error) {
return r.ApiService.LoginUserExecute(r) return r.ApiService.LoginUserExecute(r)
} }
@ -699,21 +665,19 @@ func (a *UserApiService) LoginUser(ctx _context.Context) ApiLoginUserRequest {
* Execute executes the request * Execute executes the request
* @return string * @return string
*/ */
func (a *UserApiService) LoginUserExecute(r ApiLoginUserRequest) (string, *_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) LoginUserExecute(r ApiLoginUserRequest) (string, *_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
localVarReturnValue string localVarReturnValue string
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.LoginUser") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.LoginUser")
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
return localVarReturnValue, nil, executionError
} }
localVarPath := localBasePath + "/user/login" localVarPath := localBasePath + "/user/login"
@ -722,12 +686,10 @@ func (a *UserApiService) LoginUserExecute(r ApiLoginUserRequest) (string, *_neth
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.username == nil { if r.username == nil {
executionError.error = "username is required and must be specified" return localVarReturnValue, nil, reportError("username is required and must be specified")
return localVarReturnValue, nil, executionError
} }
if r.password == nil { if r.password == nil {
executionError.error = "password is required and must be specified" return localVarReturnValue, nil, reportError("password is required and must be specified")
return localVarReturnValue, nil, executionError
} }
localVarQueryParams.Add("username", parameterToString(*r.username, "")) localVarQueryParams.Add("username", parameterToString(*r.username, ""))
@ -751,22 +713,18 @@ func (a *UserApiService) LoginUserExecute(r ApiLoginUserRequest) (string, *_neth
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, nil, err
return localVarReturnValue, nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarReturnValue, localVarHTTPResponse, err
return localVarReturnValue, localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -786,7 +744,7 @@ func (a *UserApiService) LoginUserExecute(r ApiLoginUserRequest) (string, *_neth
return localVarReturnValue, localVarHTTPResponse, newErr return localVarReturnValue, localVarHTTPResponse, newErr
} }
return localVarReturnValue, localVarHTTPResponse, executionError return localVarReturnValue, localVarHTTPResponse, nil
} }
type ApiLogoutUserRequest struct { type ApiLogoutUserRequest struct {
@ -795,7 +753,7 @@ type ApiLogoutUserRequest struct {
} }
func (r ApiLogoutUserRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiLogoutUserRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.LogoutUserExecute(r) return r.ApiService.LogoutUserExecute(r)
} }
@ -814,20 +772,18 @@ func (a *UserApiService) LogoutUser(ctx _context.Context) ApiLogoutUserRequest {
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *UserApiService) LogoutUserExecute(r ApiLogoutUserRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) LogoutUserExecute(r ApiLogoutUserRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodGet localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.LogoutUser") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.LogoutUser")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/user/logout" localVarPath := localBasePath + "/user/logout"
@ -855,22 +811,18 @@ func (a *UserApiService) LogoutUserExecute(r ApiLogoutUserRequest) (*_nethttp.Re
} }
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -881,7 +833,7 @@ func (a *UserApiService) LogoutUserExecute(r ApiLogoutUserRequest) (*_nethttp.Re
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }
type ApiUpdateUserRequest struct { type ApiUpdateUserRequest struct {
@ -896,7 +848,7 @@ func (r ApiUpdateUserRequest) User(user User) ApiUpdateUserRequest {
return r return r
} }
func (r ApiUpdateUserRequest) Execute() (*_nethttp.Response, GenericOpenAPIError) { func (r ApiUpdateUserRequest) Execute() (*_nethttp.Response, error) {
return r.ApiService.UpdateUserExecute(r) return r.ApiService.UpdateUserExecute(r)
} }
@ -918,20 +870,18 @@ func (a *UserApiService) UpdateUser(ctx _context.Context, username string) ApiUp
/* /*
* Execute executes the request * Execute executes the request
*/ */
func (a *UserApiService) UpdateUserExecute(r ApiUpdateUserRequest) (*_nethttp.Response, GenericOpenAPIError) { func (a *UserApiService) UpdateUserExecute(r ApiUpdateUserRequest) (*_nethttp.Response, error) {
var ( var (
localVarHTTPMethod = _nethttp.MethodPut localVarHTTPMethod = _nethttp.MethodPut
localVarPostBody interface{} localVarPostBody interface{}
localVarFormFileName string localVarFormFileName string
localVarFileName string localVarFileName string
localVarFileBytes []byte localVarFileBytes []byte
executionError GenericOpenAPIError
) )
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.UpdateUser") localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "UserApiService.UpdateUser")
if err != nil { if err != nil {
executionError.error = err.Error() return nil, GenericOpenAPIError{error: err.Error()}
return nil, executionError
} }
localVarPath := localBasePath + "/user/{username}" localVarPath := localBasePath + "/user/{username}"
@ -941,8 +891,7 @@ func (a *UserApiService) UpdateUserExecute(r ApiUpdateUserRequest) (*_nethttp.Re
localVarQueryParams := _neturl.Values{} localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{} localVarFormParams := _neturl.Values{}
if r.user == nil { if r.user == nil {
executionError.error = "user is required and must be specified" return nil, reportError("user is required and must be specified")
return nil, executionError
} }
// to determine the Content-Type header // to determine the Content-Type header
@ -966,22 +915,18 @@ func (a *UserApiService) UpdateUserExecute(r ApiUpdateUserRequest) (*_nethttp.Re
localVarPostBody = r.user localVarPostBody = r.user
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil { if err != nil {
executionError.error = err.Error() return nil, err
return nil, executionError
} }
localVarHTTPResponse, err := a.client.callAPI(req) localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil { if err != nil || localVarHTTPResponse == nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close() localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = _ioutil.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil { if err != nil {
executionError.error = err.Error() return localVarHTTPResponse, err
return localVarHTTPResponse, executionError
} }
if localVarHTTPResponse.StatusCode >= 300 { if localVarHTTPResponse.StatusCode >= 300 {
@ -992,5 +937,5 @@ func (a *UserApiService) UpdateUserExecute(r ApiUpdateUserRequest) (*_nethttp.Re
return localVarHTTPResponse, newErr return localVarHTTPResponse, newErr
} }
return localVarHTTPResponse, executionError return localVarHTTPResponse, nil
} }

2
samples/openapi3/client/petstore/go/go-petstore/docs/AnotherFakeApi.md
View File

@ -34,7 +34,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.AnotherFakeApi.Call123TestSpecialTags(context.Background()).Client(client).Execute() resp, r, err := api_client.AnotherFakeApi.Call123TestSpecialTags(context.Background()).Client(client).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `AnotherFakeApi.Call123TestSpecialTags``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `AnotherFakeApi.Call123TestSpecialTags``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }

2
samples/openapi3/client/petstore/go/go-petstore/docs/DefaultApi.md
View File

@ -31,7 +31,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.DefaultApi.FooGet(context.Background()).Execute() resp, r, err := api_client.DefaultApi.FooGet(context.Background()).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `DefaultApi.FooGet``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `DefaultApi.FooGet``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }

28
samples/openapi3/client/petstore/go/go-petstore/docs/FakeApi.md
View File

@ -44,7 +44,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.FakeHealthGet(context.Background()).Execute() resp, r, err := api_client.FakeApi.FakeHealthGet(context.Background()).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeHealthGet``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeHealthGet``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -106,7 +106,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.FakeOuterBooleanSerialize(context.Background()).Body(body).Execute() resp, r, err := api_client.FakeApi.FakeOuterBooleanSerialize(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterBooleanSerialize``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterBooleanSerialize``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -172,7 +172,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.FakeOuterCompositeSerialize(context.Background()).OuterComposite(outerComposite).Execute() resp, r, err := api_client.FakeApi.FakeOuterCompositeSerialize(context.Background()).OuterComposite(outerComposite).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterCompositeSerialize``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterCompositeSerialize``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -238,7 +238,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.FakeOuterNumberSerialize(context.Background()).Body(body).Execute() resp, r, err := api_client.FakeApi.FakeOuterNumberSerialize(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterNumberSerialize``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterNumberSerialize``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -304,7 +304,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.FakeOuterStringSerialize(context.Background()).Body(body).Execute() resp, r, err := api_client.FakeApi.FakeOuterStringSerialize(context.Background()).Body(body).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterStringSerialize``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.FakeOuterStringSerialize``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -370,7 +370,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestBodyWithFileSchema(context.Background()).FileSchemaTestClass(fileSchemaTestClass).Execute() resp, r, err := api_client.FakeApi.TestBodyWithFileSchema(context.Background()).FileSchemaTestClass(fileSchemaTestClass).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestBodyWithFileSchema``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestBodyWithFileSchema``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -433,7 +433,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestBodyWithQueryParams(context.Background()).Query(query).User(user).Execute() resp, r, err := api_client.FakeApi.TestBodyWithQueryParams(context.Background()).Query(query).User(user).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestBodyWithQueryParams``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestBodyWithQueryParams``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -498,7 +498,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestClientModel(context.Background()).Client(client).Execute() resp, r, err := api_client.FakeApi.TestClientModel(context.Background()).Client(client).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestClientModel``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestClientModel``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -578,7 +578,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestEndpointParameters(context.Background()).Number(number).Double(double).PatternWithoutDelimiter(patternWithoutDelimiter).Byte_(byte_).Integer(integer).Int32_(int32_).Int64_(int64_).Float(float).String_(string_).Binary(binary).Date(date).DateTime(dateTime).Password(password).Callback(callback).Execute() resp, r, err := api_client.FakeApi.TestEndpointParameters(context.Background()).Number(number).Double(double).PatternWithoutDelimiter(patternWithoutDelimiter).Byte_(byte_).Integer(integer).Int32_(int32_).Int64_(int64_).Float(float).String_(string_).Binary(binary).Date(date).DateTime(dateTime).Password(password).Callback(callback).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestEndpointParameters``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestEndpointParameters``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -662,7 +662,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestEnumParameters(context.Background()).EnumHeaderStringArray(enumHeaderStringArray).EnumHeaderString(enumHeaderString).EnumQueryStringArray(enumQueryStringArray).EnumQueryString(enumQueryString).EnumQueryInteger(enumQueryInteger).EnumQueryDouble(enumQueryDouble).EnumFormStringArray(enumFormStringArray).EnumFormString(enumFormString).Execute() resp, r, err := api_client.FakeApi.TestEnumParameters(context.Background()).EnumHeaderStringArray(enumHeaderStringArray).EnumHeaderString(enumHeaderString).EnumQueryStringArray(enumQueryStringArray).EnumQueryString(enumQueryString).EnumQueryInteger(enumQueryInteger).EnumQueryDouble(enumQueryDouble).EnumFormStringArray(enumFormStringArray).EnumFormString(enumFormString).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestEnumParameters``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestEnumParameters``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -738,7 +738,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestGroupParameters(context.Background()).RequiredStringGroup(requiredStringGroup).RequiredBooleanGroup(requiredBooleanGroup).RequiredInt64Group(requiredInt64Group).StringGroup(stringGroup).BooleanGroup(booleanGroup).Int64Group(int64Group).Execute() resp, r, err := api_client.FakeApi.TestGroupParameters(context.Background()).RequiredStringGroup(requiredStringGroup).RequiredBooleanGroup(requiredBooleanGroup).RequiredInt64Group(requiredInt64Group).StringGroup(stringGroup).BooleanGroup(booleanGroup).Int64Group(int64Group).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestGroupParameters``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestGroupParameters``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -805,7 +805,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestInlineAdditionalProperties(context.Background()).RequestBody(requestBody).Execute() resp, r, err := api_client.FakeApi.TestInlineAdditionalProperties(context.Background()).RequestBody(requestBody).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestInlineAdditionalProperties``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestInlineAdditionalProperties``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -868,7 +868,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestJsonFormData(context.Background()).Param(param).Param2(param2).Execute() resp, r, err := api_client.FakeApi.TestJsonFormData(context.Background()).Param(param).Param2(param2).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestJsonFormData``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestJsonFormData``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -937,7 +937,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeApi.TestQueryParameterCollectionFormat(context.Background()).Pipe(pipe).Ioutil(ioutil).Http(http).Url(url).Context(context).Execute() resp, r, err := api_client.FakeApi.TestQueryParameterCollectionFormat(context.Background()).Pipe(pipe).Ioutil(ioutil).Http(http).Url(url).Context(context).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestQueryParameterCollectionFormat``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeApi.TestQueryParameterCollectionFormat``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }

2
samples/openapi3/client/petstore/go/go-petstore/docs/FakeClassnameTags123Api.md
View File

@ -34,7 +34,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.FakeClassnameTags123Api.TestClassname(context.Background()).Client(client).Execute() resp, r, err := api_client.FakeClassnameTags123Api.TestClassname(context.Background()).Client(client).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `FakeClassnameTags123Api.TestClassname``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `FakeClassnameTags123Api.TestClassname``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }

18
samples/openapi3/client/petstore/go/go-petstore/docs/PetApi.md
View File

@ -40,7 +40,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.AddPet(context.Background()).Pet(pet).Execute() resp, r, err := api_client.PetApi.AddPet(context.Background()).Pet(pet).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.AddPet``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.AddPet``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -103,7 +103,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.DeletePet(context.Background(), petId).ApiKey(apiKey).Execute() resp, r, err := api_client.PetApi.DeletePet(context.Background(), petId).ApiKey(apiKey).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.DeletePet``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.DeletePet``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -172,7 +172,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.FindPetsByStatus(context.Background()).Status(status).Execute() resp, r, err := api_client.PetApi.FindPetsByStatus(context.Background()).Status(status).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.FindPetsByStatus``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.FindPetsByStatus``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -238,7 +238,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.FindPetsByTags(context.Background()).Tags(tags).Execute() resp, r, err := api_client.PetApi.FindPetsByTags(context.Background()).Tags(tags).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.FindPetsByTags``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.FindPetsByTags``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -304,7 +304,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.GetPetById(context.Background(), petId).Execute() resp, r, err := api_client.PetApi.GetPetById(context.Background(), petId).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.GetPetById``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.GetPetById``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -372,7 +372,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.UpdatePet(context.Background()).Pet(pet).Execute() resp, r, err := api_client.PetApi.UpdatePet(context.Background()).Pet(pet).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UpdatePet``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UpdatePet``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -436,7 +436,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.UpdatePetWithForm(context.Background(), petId).Name(name).Status(status).Execute() resp, r, err := api_client.PetApi.UpdatePetWithForm(context.Background(), petId).Name(name).Status(status).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UpdatePetWithForm``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UpdatePetWithForm``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -506,7 +506,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.UploadFile(context.Background(), petId).AdditionalMetadata(additionalMetadata).File(file).Execute() resp, r, err := api_client.PetApi.UploadFile(context.Background(), petId).AdditionalMetadata(additionalMetadata).File(file).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UploadFile``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UploadFile``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -578,7 +578,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.PetApi.UploadFileWithRequiredFile(context.Background(), petId).RequiredFile(requiredFile).AdditionalMetadata(additionalMetadata).Execute() resp, r, err := api_client.PetApi.UploadFileWithRequiredFile(context.Background(), petId).RequiredFile(requiredFile).AdditionalMetadata(additionalMetadata).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UploadFileWithRequiredFile``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `PetApi.UploadFileWithRequiredFile``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }

8
samples/openapi3/client/petstore/go/go-petstore/docs/StoreApi.md
View File

@ -37,7 +37,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.StoreApi.DeleteOrder(context.Background(), orderId).Execute() resp, r, err := api_client.StoreApi.DeleteOrder(context.Background(), orderId).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.DeleteOrder``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.DeleteOrder``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -104,7 +104,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.StoreApi.GetInventory(context.Background()).Execute() resp, r, err := api_client.StoreApi.GetInventory(context.Background()).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.GetInventory``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.GetInventory``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -166,7 +166,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.StoreApi.GetOrderById(context.Background(), orderId).Execute() resp, r, err := api_client.StoreApi.GetOrderById(context.Background(), orderId).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.GetOrderById``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.GetOrderById``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -234,7 +234,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.StoreApi.PlaceOrder(context.Background()).Order(order).Execute() resp, r, err := api_client.StoreApi.PlaceOrder(context.Background()).Order(order).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.PlaceOrder``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `StoreApi.PlaceOrder``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }

16
samples/openapi3/client/petstore/go/go-petstore/docs/UserApi.md
View File

@ -41,7 +41,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.CreateUser(context.Background()).User(user).Execute() resp, r, err := api_client.UserApi.CreateUser(context.Background()).User(user).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.CreateUser``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.CreateUser``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -103,7 +103,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.CreateUsersWithArrayInput(context.Background()).User(user).Execute() resp, r, err := api_client.UserApi.CreateUsersWithArrayInput(context.Background()).User(user).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.CreateUsersWithArrayInput``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.CreateUsersWithArrayInput``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -165,7 +165,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.CreateUsersWithListInput(context.Background()).User(user).Execute() resp, r, err := api_client.UserApi.CreateUsersWithListInput(context.Background()).User(user).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.CreateUsersWithListInput``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.CreateUsersWithListInput``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -229,7 +229,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.DeleteUser(context.Background(), username).Execute() resp, r, err := api_client.UserApi.DeleteUser(context.Background(), username).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.DeleteUser``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.DeleteUser``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -295,7 +295,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.GetUserByName(context.Background(), username).Execute() resp, r, err := api_client.UserApi.GetUserByName(context.Background(), username).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.GetUserByName``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.GetUserByName``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -364,7 +364,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.LoginUser(context.Background()).Username(username).Password(password).Execute() resp, r, err := api_client.UserApi.LoginUser(context.Background()).Username(username).Password(password).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.LoginUser``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.LoginUser``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -428,7 +428,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.LogoutUser(context.Background()).Execute() resp, r, err := api_client.UserApi.LogoutUser(context.Background()).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.LogoutUser``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.LogoutUser``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }
@ -489,7 +489,7 @@ func main() {
configuration := openapiclient.NewConfiguration() configuration := openapiclient.NewConfiguration()
api_client := openapiclient.NewAPIClient(configuration) api_client := openapiclient.NewAPIClient(configuration)
resp, r, err := api_client.UserApi.UpdateUser(context.Background(), username).User(user).Execute() resp, r, err := api_client.UserApi.UpdateUser(context.Background(), username).User(user).Execute()
if err.Error() != "" { if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `UserApi.UpdateUser``: %v\n", err) fmt.Fprintf(os.Stderr, "Error when calling `UserApi.UpdateUser``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
} }

6
samples/openapi3/client/petstore/go/http_signature_test.go
View File

@ -282,11 +282,11 @@ func executeHttpSignatureAuth(t *testing.T, authConfig *sw.HttpSignatureAuth, ex
authConfig.SigningScheme, authConfig.SigningAlgorithm, authConfig.SignatureMaxValidity, authConfig.SignedHeaders) authConfig.SigningScheme, authConfig.SigningAlgorithm, authConfig.SignatureMaxValidity, authConfig.SignedHeaders)
r, err2 := apiClient.PetApi.AddPet(authCtx).Pet(newPet).Execute() r, err2 := apiClient.PetApi.AddPet(authCtx).Pet(newPet).Execute()
if expectSuccess && err2.Error() != "" { if expectSuccess && err2 != nil {
t.Fatalf("Error while adding pet: %v", err2) t.Fatalf("Error while adding pet: %v", err2)
} }
if !expectSuccess { if !expectSuccess {
if err2.Error() == "" { if err2 == nil {
t.Fatalf("Error was expected, but no error was generated") t.Fatalf("Error was expected, but no error was generated")
} else { } else {
// Do not continue. Error is expected. // Do not continue. Error is expected.
@ -298,7 +298,7 @@ func executeHttpSignatureAuth(t *testing.T, authConfig *sw.HttpSignatureAuth, ex
} }
_, r, err = apiClient.PetApi.GetPetById(authCtx, 12992).Execute() _, r, err = apiClient.PetApi.GetPetById(authCtx, 12992).Execute()
if expectSuccess && err.Error() != "" { if expectSuccess && err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }

25
samples/openapi3/client/petstore/go/pet_api_test.go
View File

@ -33,7 +33,7 @@ func TestAddPet(t *testing.T) {
r, err := client.PetApi.AddPet(context.Background()).Pet(newPet).Execute() r, err := client.PetApi.AddPet(context.Background()).Pet(newPet).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding pet: %v", err) t.Fatalf("Error while adding pet: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -44,7 +44,7 @@ func TestAddPet(t *testing.T) {
func TestFindPetsByStatusWithMissingParam(t *testing.T) { func TestFindPetsByStatusWithMissingParam(t *testing.T) {
_, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status(nil).Execute() _, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status(nil).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while testing TestFindPetsByStatusWithMissingParam: %v", err) t.Fatalf("Error while testing TestFindPetsByStatusWithMissingParam: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -59,12 +59,13 @@ func TestGetPetById(t *testing.T) {
func TestGetPetByIdWithInvalidID(t *testing.T) { func TestGetPetByIdWithInvalidID(t *testing.T) {
resp, r, err := client.PetApi.GetPetById(context.Background(), 999999999).Execute() resp, r, err := client.PetApi.GetPetById(context.Background(), 999999999).Execute()
if r != nil && r.StatusCode == 404 { if r != nil && r.StatusCode == 404 {
assertedError:= err assertedError, ok := err.(sw.GenericOpenAPIError)
a := assert.New(t) a := assert.New(t)
a.True(ok)
a.Contains(string(assertedError.Body()), "type") a.Contains(string(assertedError.Body()), "type")
a.Contains(assertedError.Error(), "Not Found") a.Contains(assertedError.Error(), "Not Found")
} else if err.Error() != "" { } else if err != nil {
t.Fatalf("Error while getting pet by invalid id: %v", err) t.Fatalf("Error while getting pet by invalid id: %v", err)
t.Log(r) t.Log(r)
} else { } else {
@ -74,7 +75,7 @@ func TestGetPetByIdWithInvalidID(t *testing.T) {
func TestUpdatePetWithForm(t *testing.T) { func TestUpdatePetWithForm(t *testing.T) {
r, err := client.PetApi.UpdatePetWithForm(context.Background(), 12830).Name("golang").Status("available").Execute() r, err := client.PetApi.UpdatePetWithForm(context.Background(), 12830).Name("golang").Status("available").Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while updating pet by id: %v", err) t.Fatalf("Error while updating pet by id: %v", err)
t.Log(r) t.Log(r)
} }
@ -89,7 +90,7 @@ func TestUpdatePetWithForm(t *testing.T) {
func TestFindPetsByTag(t *testing.T) { func TestFindPetsByTag(t *testing.T) {
var found = false var found = false
resp, r, err := client.PetApi.FindPetsByTags(context.Background()).Tags([]string{"tag2"}).Execute() resp, r, err := client.PetApi.FindPetsByTags(context.Background()).Tags([]string{"tag2"}).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while getting pet by tag: %v", err) t.Fatalf("Error while getting pet by tag: %v", err)
t.Log(r) t.Log(r)
} else { } else {
@ -118,7 +119,7 @@ func TestFindPetsByTag(t *testing.T) {
func TestFindPetsByStatus(t *testing.T) { func TestFindPetsByStatus(t *testing.T) {
resp, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status([]string{"available"}).Execute() resp, r, err := client.PetApi.FindPetsByStatus(context.Background()).Status([]string{"available"}).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while getting pet by id: %v", err) t.Fatalf("Error while getting pet by id: %v", err)
t.Log(r) t.Log(r)
} else { } else {
@ -145,7 +146,7 @@ func TestUploadFile(t *testing.T) {
_, r, err := client.PetApi.UploadFile(context.Background(), 12830).AdditionalMetadata("golang").File(file).Execute() _, r, err := client.PetApi.UploadFile(context.Background(), 12830).AdditionalMetadata("golang").File(file).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while uploading file: %v", err) t.Fatalf("Error while uploading file: %v", err)
} }
@ -163,7 +164,7 @@ func TestUploadFileRequired(t *testing.T) {
_, r, err := client.PetApi.UploadFileWithRequiredFile(context.Background(), 12830).RequiredFile(file).AdditionalMetadata("golang").Execute() _, r, err := client.PetApi.UploadFileWithRequiredFile(context.Background(), 12830).RequiredFile(file).AdditionalMetadata("golang").Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while uploading file: %v", err) t.Fatalf("Error while uploading file: %v", err)
} }
@ -175,7 +176,7 @@ func TestUploadFileRequired(t *testing.T) {
func TestDeletePet(t *testing.T) { func TestDeletePet(t *testing.T) {
r, err := client.PetApi.DeletePet(context.Background(), 12830).Execute() r, err := client.PetApi.DeletePet(context.Background(), 12830).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -265,7 +266,7 @@ func waitOnFunctions(t *testing.T, errc chan error, n int) {
func deletePet(t *testing.T, id int64) { func deletePet(t *testing.T, id int64) {
r, err := client.PetApi.DeletePet(context.Background(), id).Execute() r, err := client.PetApi.DeletePet(context.Background(), id).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting pet by id: %v", err) t.Fatalf("Error while deleting pet by id: %v", err)
} }
if r.StatusCode != 200 { if r.StatusCode != 200 {
@ -276,7 +277,7 @@ func deletePet(t *testing.T, id int64) {
func isPetCorrect(t *testing.T, id int64, name string, status string) { func isPetCorrect(t *testing.T, id int64, name string, status string) {
assert := assert.New(t) assert := assert.New(t)
resp, r, err := client.PetApi.GetPetById(context.Background(), id).Execute() resp, r, err := client.PetApi.GetPetById(context.Background(), id).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while getting pet by id: %v", err) t.Fatalf("Error while getting pet by id: %v", err)
} else { } else {
assert.Equal(*resp.Id, int64(id), "Pet id should be equal") assert.Equal(*resp.Id, int64(id), "Pet id should be equal")

2
samples/openapi3/client/petstore/go/store_api_test.go
View File

@ -20,7 +20,7 @@ func TestPlaceOrder(t *testing.T) {
_, r, err := client.StoreApi.PlaceOrder(context.Background()).Order(newOrder).Execute() _, r, err := client.StoreApi.PlaceOrder(context.Background()).Order(newOrder).Execute()
if err.Error() != "" { if err != nil {
// Skip parsing time error due to error in Petstore Test Server // Skip parsing time error due to error in Petstore Test Server
// https://github.com/OpenAPITools/openapi-generator/issues/1292 // https://github.com/OpenAPITools/openapi-generator/issues/1292
if regexp. if regexp.

12
samples/openapi3/client/petstore/go/user_api_test.go
View File

@ -22,7 +22,7 @@ func TestCreateUser(t *testing.T) {
apiResponse, err := client.UserApi.CreateUser(context.Background()).User(newUser).Execute() apiResponse, err := client.UserApi.CreateUser(context.Background()).User(newUser).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding user: %v", err) t.Fatalf("Error while adding user: %v", err)
} }
if apiResponse.StatusCode != 200 { if apiResponse.StatusCode != 200 {
@ -56,7 +56,7 @@ func TestCreateUsersWithArrayInput(t *testing.T) {
} }
apiResponse, err := client.UserApi.CreateUsersWithArrayInput(context.Background()).User(newUsers).Execute() apiResponse, err := client.UserApi.CreateUsersWithArrayInput(context.Background()).User(newUsers).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while adding users: %v", err) t.Fatalf("Error while adding users: %v", err)
} }
if apiResponse.StatusCode != 200 { if apiResponse.StatusCode != 200 {
@ -83,7 +83,7 @@ func TestGetUserByName(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
resp, apiResponse, err := client.UserApi.GetUserByName(context.Background(), "gopher").Execute() resp, apiResponse, err := client.UserApi.GetUserByName(context.Background(), "gopher").Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while getting user by id: %v", err) t.Fatalf("Error while getting user by id: %v", err)
} else { } else {
assert.Equal(*resp.Id, int64(1000), "User id should be equal") assert.Equal(*resp.Id, int64(1000), "User id should be equal")
@ -100,7 +100,7 @@ func TestGetUserByNameWithInvalidID(t *testing.T) {
resp, apiResponse, err := client.UserApi.GetUserByName(context.Background(), "999999999").Execute() resp, apiResponse, err := client.UserApi.GetUserByName(context.Background(), "999999999").Execute()
if apiResponse != nil && apiResponse.StatusCode == 404 { if apiResponse != nil && apiResponse.StatusCode == 404 {
return // This is a pass condition. API will return with a 404 error. return // This is a pass condition. API will return with a 404 error.
} else if err.Error() != "" { } else if err != nil {
t.Fatalf("Error while getting user by invalid id: %v", err) t.Fatalf("Error while getting user by invalid id: %v", err)
t.Log(apiResponse) t.Log(apiResponse)
} else { } else {
@ -125,7 +125,7 @@ func TestUpdateUser(t *testing.T) {
UserStatus: sw.PtrInt32(1)} UserStatus: sw.PtrInt32(1)}
apiResponse, err := client.UserApi.UpdateUser(context.Background(), "gopher").User(newUser).Execute() apiResponse, err := client.UserApi.UpdateUser(context.Background(), "gopher").User(newUser).Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while deleting user by id: %v", err) t.Fatalf("Error while deleting user by id: %v", err)
} }
if apiResponse.StatusCode != 200 { if apiResponse.StatusCode != 200 {
@ -134,7 +134,7 @@ func TestUpdateUser(t *testing.T) {
//verify changings are correct //verify changings are correct
resp, apiResponse, err := client.UserApi.GetUserByName(context.Background(), "gopher").Execute() resp, apiResponse, err := client.UserApi.GetUserByName(context.Background(), "gopher").Execute()
if err.Error() != "" { if err != nil {
t.Fatalf("Error while getting user by id: %v", err) t.Fatalf("Error while getting user by id: %v", err)
} else { } else {
assert.Equal(*resp.Id, int64(1000), "User id should be equal") assert.Equal(*resp.Id, int64(1000), "User id should be equal")