[REQ][GO] add awsv4 signature support (#4784)

* [REQ][GO] add awsv4 signature support for client

OpenAPI format does not support AWS Signature method.
This commit add support for AWSv4 signature in GO client generation by adding "withAWSV4Signature" option.
"withAWSV4Signature" option is false by default.

Signed-off-by: Jérome Jutteau <jerome.jutteau@outscale.com>

* [REQ][GO] update samples for awsv4 signature support

Signed-off-by: Jérome Jutteau <jerome.jutteau@outscale.com>

samples/openapi3/server/petstore/go-api-server/.openapi-generator/VERSION

@@ -1 +1 @@
-4.2.0-SNAPSHOT
+4.2.3-SNAPSHOT

samples/openapi3/server/petstore/go-api-server/go/api_another_fake.go

@@ -10,11 +10,48 @@
 package petstoreserver
 
 import (
+	"encoding/json"
 	"net/http"
+	"strings"
+
+	"github.com/gorilla/mux"
 )
 
-// Call123TestSpecialTags - To test special tags
-func Call123TestSpecialTags(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+// A AnotherFakeApiController binds http requests to an api service and writes the service results to the http response
+type AnotherFakeApiController struct {
+	service AnotherFakeApiServicer
+}
+
+// NewAnotherFakeApiController creates a default api controller
+func NewAnotherFakeApiController(s AnotherFakeApiServicer) Router {
+	return &AnotherFakeApiController{ service: s }
+}
+
+// Routes returns all of the api route for the AnotherFakeApiController
+func (c *AnotherFakeApiController) Routes() Routes {
+	return Routes{ 
+		{
+			"Call123TestSpecialTags",
+			strings.ToUpper("Patch"),
+			"/v2/another-fake/dummy",
+			c.Call123TestSpecialTags,
+		},
+	}
+}
+
+// Call123TestSpecialTags - To test special tags
+func (c *AnotherFakeApiController) Call123TestSpecialTags(w http.ResponseWriter, r *http.Request) { 
+	client := &Client{}
+	if err := json.NewDecoder(r.Body).Decode(&client); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.Call123TestSpecialTags(*client)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }

samples/openapi3/server/petstore/go-api-server/go/api_default.go

@@ -10,11 +10,42 @@
 package petstoreserver
 
 import (
+	"encoding/json"
 	"net/http"
+	"strings"
+
+	"github.com/gorilla/mux"
 )
 
-// FooGet - 
-func FooGet(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+// A DefaultApiController binds http requests to an api service and writes the service results to the http response
+type DefaultApiController struct {
+	service DefaultApiServicer
+}
+
+// NewDefaultApiController creates a default api controller
+func NewDefaultApiController(s DefaultApiServicer) Router {
+	return &DefaultApiController{ service: s }
+}
+
+// Routes returns all of the api route for the DefaultApiController
+func (c *DefaultApiController) Routes() Routes {
+	return Routes{ 
+		{
+			"FooGet",
+			strings.ToUpper("Get"),
+			"/v2/foo",
+			c.FooGet,
+		},
+	}
+}
+
+// FooGet - 
+func (c *DefaultApiController) FooGet(w http.ResponseWriter, r *http.Request) { 
+	result, err := c.service.FooGet()
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }

samples/openapi3/server/petstore/go-api-server/go/api_fake.go

@@ -10,89 +10,389 @@
 package petstoreserver
 
 import (
+	"encoding/json"
 	"net/http"
+	"strings"
+
+	"github.com/gorilla/mux"
 )
 
+// A FakeApiController binds http requests to an api service and writes the service results to the http response
+type FakeApiController struct {
+	service FakeApiServicer
+}
+
+// NewFakeApiController creates a default api controller
+func NewFakeApiController(s FakeApiServicer) Router {
+	return &FakeApiController{ service: s }
+}
+
+// Routes returns all of the api route for the FakeApiController
+func (c *FakeApiController) Routes() Routes {
+	return Routes{ 
+		{
+			"FakeHealthGet",
+			strings.ToUpper("Get"),
+			"/v2/fake/health",
+			c.FakeHealthGet,
+		},
+		{
+			"FakeOuterBooleanSerialize",
+			strings.ToUpper("Post"),
+			"/v2/fake/outer/boolean",
+			c.FakeOuterBooleanSerialize,
+		},
+		{
+			"FakeOuterCompositeSerialize",
+			strings.ToUpper("Post"),
+			"/v2/fake/outer/composite",
+			c.FakeOuterCompositeSerialize,
+		},
+		{
+			"FakeOuterNumberSerialize",
+			strings.ToUpper("Post"),
+			"/v2/fake/outer/number",
+			c.FakeOuterNumberSerialize,
+		},
+		{
+			"FakeOuterStringSerialize",
+			strings.ToUpper("Post"),
+			"/v2/fake/outer/string",
+			c.FakeOuterStringSerialize,
+		},
+		{
+			"TestBodyWithFileSchema",
+			strings.ToUpper("Put"),
+			"/v2/fake/body-with-file-schema",
+			c.TestBodyWithFileSchema,
+		},
+		{
+			"TestBodyWithQueryParams",
+			strings.ToUpper("Put"),
+			"/v2/fake/body-with-query-params",
+			c.TestBodyWithQueryParams,
+		},
+		{
+			"TestClientModel",
+			strings.ToUpper("Patch"),
+			"/v2/fake",
+			c.TestClientModel,
+		},
+		{
+			"TestEndpointParameters",
+			strings.ToUpper("Post"),
+			"/v2/fake",
+			c.TestEndpointParameters,
+		},
+		{
+			"TestEnumParameters",
+			strings.ToUpper("Get"),
+			"/v2/fake",
+			c.TestEnumParameters,
+		},
+		{
+			"TestGroupParameters",
+			strings.ToUpper("Delete"),
+			"/v2/fake",
+			c.TestGroupParameters,
+		},
+		{
+			"TestInlineAdditionalProperties",
+			strings.ToUpper("Post"),
+			"/v2/fake/inline-additionalProperties",
+			c.TestInlineAdditionalProperties,
+		},
+		{
+			"TestJsonFormData",
+			strings.ToUpper("Get"),
+			"/v2/fake/jsonFormData",
+			c.TestJsonFormData,
+		},
+		{
+			"TestQueryParameterCollectionFormat",
+			strings.ToUpper("Put"),
+			"/v2/fake/test-query-paramters",
+			c.TestQueryParameterCollectionFormat,
+		},
+	}
+}
+
 // FakeHealthGet - Health check endpoint
-func FakeHealthGet(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *FakeApiController) FakeHealthGet(w http.ResponseWriter, r *http.Request) { 
+	result, err := c.service.FakeHealthGet()
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // FakeOuterBooleanSerialize - 
-func FakeOuterBooleanSerialize(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *FakeApiController) FakeOuterBooleanSerialize(w http.ResponseWriter, r *http.Request) { 
+	body := &bool{}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.FakeOuterBooleanSerialize(*body)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // FakeOuterCompositeSerialize - 
-func FakeOuterCompositeSerialize(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *FakeApiController) FakeOuterCompositeSerialize(w http.ResponseWriter, r *http.Request) { 
+	outerComposite := &OuterComposite{}
+	if err := json.NewDecoder(r.Body).Decode(&outerComposite); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.FakeOuterCompositeSerialize(*outerComposite)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // FakeOuterNumberSerialize - 
-func FakeOuterNumberSerialize(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *FakeApiController) FakeOuterNumberSerialize(w http.ResponseWriter, r *http.Request) { 
+	body := &float32{}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.FakeOuterNumberSerialize(*body)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // FakeOuterStringSerialize - 
-func FakeOuterStringSerialize(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *FakeApiController) FakeOuterStringSerialize(w http.ResponseWriter, r *http.Request) { 
+	body := &string{}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.FakeOuterStringSerialize(*body)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // TestBodyWithFileSchema - 
-func TestBodyWithFileSchema(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *FakeApiController) TestBodyWithFileSchema(w http.ResponseWriter, r *http.Request) { 
+	fileSchemaTestClass := &FileSchemaTestClass{}
+	if err := json.NewDecoder(r.Body).Decode(&fileSchemaTestClass); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.TestBodyWithFileSchema(*fileSchemaTestClass)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // TestBodyWithQueryParams - 
-func TestBodyWithQueryParams(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *FakeApiController) TestBodyWithQueryParams(w http.ResponseWriter, r *http.Request) { 
+	query := r.URL.Query()
+	query := query.Get("query")
+	user := &User{}
+	if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.TestBodyWithQueryParams(query, *user)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // TestClientModel - To test \"client\" model
-func TestClientModel(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *FakeApiController) TestClientModel(w http.ResponseWriter, r *http.Request) { 
+	client := &Client{}
+	if err := json.NewDecoder(r.Body).Decode(&client); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.TestClientModel(*client)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // TestEndpointParameters - Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
-func TestEndpointParameters(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *FakeApiController) TestEndpointParameters(w http.ResponseWriter, r *http.Request) { 
+	err := r.ParseForm()
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	number := r.FormValue("number")
+	double := r.FormValue("double")
+	patternWithoutDelimiter := r.FormValue("patternWithoutDelimiter")
+	byte_ := r.FormValue("byte_")
+	integer := r.FormValue("integer")
+	int32_ := r.FormValue("int32_")
+	int64_, err := parseIntParameter( r.FormValue("int64_"))
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	float := r.FormValue("float")
+	string_ := r.FormValue("string_")
+	binary, err := ReadFormFileToTempFile(r, "binary")
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	date := r.FormValue("date")
+	dateTime := r.FormValue("dateTime")
+	password := r.FormValue("password")
+	callback := r.FormValue("callback")
+	result, err := c.service.TestEndpointParameters(number, double, patternWithoutDelimiter, byte_, integer, int32_, int64_, float, string_, binary, date, dateTime, password, callback)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // TestEnumParameters - To test enum parameters
-func TestEnumParameters(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *FakeApiController) TestEnumParameters(w http.ResponseWriter, r *http.Request) { 
+	err := r.ParseForm()
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	query := r.URL.Query()
+	enumHeaderStringArray := r.Header.Get("enumHeaderStringArray")
+	enumHeaderString := r.Header.Get("enumHeaderString")
+	enumQueryStringArray := strings.Split(query.Get("enumQueryStringArray"), ",")
+	enumQueryString := query.Get("enumQueryString")
+	enumQueryInteger := query.Get("enumQueryInteger")
+	enumQueryDouble := query.Get("enumQueryDouble")
+	enumFormStringArray := r.FormValue("enumFormStringArray")
+	enumFormString := r.FormValue("enumFormString")
+	result, err := c.service.TestEnumParameters(enumHeaderStringArray, enumHeaderString, enumQueryStringArray, enumQueryString, enumQueryInteger, enumQueryDouble, enumFormStringArray, enumFormString)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // TestGroupParameters - Fake endpoint to test group parameters (optional)
-func TestGroupParameters(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *FakeApiController) TestGroupParameters(w http.ResponseWriter, r *http.Request) { 
+	query := r.URL.Query()
+	requiredStringGroup := query.Get("requiredStringGroup")
+	requiredBooleanGroup := r.Header.Get("requiredBooleanGroup")
+	requiredInt64Group, err := parseIntParameter(query.Get("requiredInt64Group"))
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	stringGroup := query.Get("stringGroup")
+	booleanGroup := r.Header.Get("booleanGroup")
+	int64Group, err := parseIntParameter(query.Get("int64Group"))
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.TestGroupParameters(requiredStringGroup, requiredBooleanGroup, requiredInt64Group, stringGroup, booleanGroup, int64Group)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // TestInlineAdditionalProperties - test inline additionalProperties
-func TestInlineAdditionalProperties(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *FakeApiController) TestInlineAdditionalProperties(w http.ResponseWriter, r *http.Request) { 
+	requestBody := &map[string]string{}
+	if err := json.NewDecoder(r.Body).Decode(&requestBody); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.TestInlineAdditionalProperties(*requestBody)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // TestJsonFormData - test json serialization of form data
-func TestJsonFormData(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *FakeApiController) TestJsonFormData(w http.ResponseWriter, r *http.Request) { 
+	err := r.ParseForm()
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	param := r.FormValue("param")
+	param2 := r.FormValue("param2")
+	result, err := c.service.TestJsonFormData(param, param2)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // TestQueryParameterCollectionFormat - 
-func TestQueryParameterCollectionFormat(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *FakeApiController) TestQueryParameterCollectionFormat(w http.ResponseWriter, r *http.Request) { 
+	query := r.URL.Query()
+	pipe := strings.Split(query.Get("pipe"), ",")
+	ioutil := strings.Split(query.Get("ioutil"), ",")
+	http := strings.Split(query.Get("http"), ",")
+	url := strings.Split(query.Get("url"), ",")
+	context := strings.Split(query.Get("context"), ",")
+	result, err := c.service.TestQueryParameterCollectionFormat(pipe, ioutil, http, url, context)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }

samples/openapi3/server/petstore/go-api-server/go/api_fake_classname_tags123.go

@@ -10,11 +10,48 @@
 package petstoreserver
 
 import (
+	"encoding/json"
 	"net/http"
+	"strings"
+
+	"github.com/gorilla/mux"
 )
 
-// TestClassname - To test class name in snake case
-func TestClassname(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+// A FakeClassnameTags123ApiController binds http requests to an api service and writes the service results to the http response
+type FakeClassnameTags123ApiController struct {
+	service FakeClassnameTags123ApiServicer
+}
+
+// NewFakeClassnameTags123ApiController creates a default api controller
+func NewFakeClassnameTags123ApiController(s FakeClassnameTags123ApiServicer) Router {
+	return &FakeClassnameTags123ApiController{ service: s }
+}
+
+// Routes returns all of the api route for the FakeClassnameTags123ApiController
+func (c *FakeClassnameTags123ApiController) Routes() Routes {
+	return Routes{ 
+		{
+			"TestClassname",
+			strings.ToUpper("Patch"),
+			"/v2/fake_classname_test",
+			c.TestClassname,
+		},
+	}
+}
+
+// TestClassname - To test class name in snake case
+func (c *FakeClassnameTags123ApiController) TestClassname(w http.ResponseWriter, r *http.Request) { 
+	client := &Client{}
+	if err := json.NewDecoder(r.Body).Decode(&client); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.TestClassname(*client)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }

samples/openapi3/server/petstore/go-api-server/go/api_pet.go

@@ -10,59 +10,264 @@
 package petstoreserver
 
 import (
+	"encoding/json"
 	"net/http"
+	"strings"
+
+	"github.com/gorilla/mux"
 )
 
+// A PetApiController binds http requests to an api service and writes the service results to the http response
+type PetApiController struct {
+	service PetApiServicer
+}
+
+// NewPetApiController creates a default api controller
+func NewPetApiController(s PetApiServicer) Router {
+	return &PetApiController{ service: s }
+}
+
+// Routes returns all of the api route for the PetApiController
+func (c *PetApiController) Routes() Routes {
+	return Routes{ 
+		{
+			"AddPet",
+			strings.ToUpper("Post"),
+			"/v2/pet",
+			c.AddPet,
+		},
+		{
+			"DeletePet",
+			strings.ToUpper("Delete"),
+			"/v2/pet/{petId}",
+			c.DeletePet,
+		},
+		{
+			"FindPetsByStatus",
+			strings.ToUpper("Get"),
+			"/v2/pet/findByStatus",
+			c.FindPetsByStatus,
+		},
+		{
+			"FindPetsByTags",
+			strings.ToUpper("Get"),
+			"/v2/pet/findByTags",
+			c.FindPetsByTags,
+		},
+		{
+			"GetPetById",
+			strings.ToUpper("Get"),
+			"/v2/pet/{petId}",
+			c.GetPetById,
+		},
+		{
+			"UpdatePet",
+			strings.ToUpper("Put"),
+			"/v2/pet",
+			c.UpdatePet,
+		},
+		{
+			"UpdatePetWithForm",
+			strings.ToUpper("Post"),
+			"/v2/pet/{petId}",
+			c.UpdatePetWithForm,
+		},
+		{
+			"UploadFile",
+			strings.ToUpper("Post"),
+			"/v2/pet/{petId}/uploadImage",
+			c.UploadFile,
+		},
+		{
+			"UploadFileWithRequiredFile",
+			strings.ToUpper("Post"),
+			"/v2/fake/{petId}/uploadImageWithRequiredFile",
+			c.UploadFileWithRequiredFile,
+		},
+	}
+}
+
 // AddPet - Add a new pet to the store
-func AddPet(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *PetApiController) AddPet(w http.ResponseWriter, r *http.Request) { 
+	pet := &Pet{}
+	if err := json.NewDecoder(r.Body).Decode(&pet); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.AddPet(*pet)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // DeletePet - Deletes a pet
-func DeletePet(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *PetApiController) DeletePet(w http.ResponseWriter, r *http.Request) { 
+	params := mux.Vars(r)
+	petId, err := parseIntParameter(params["petId"])
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	apiKey := r.Header.Get("apiKey")
+	result, err := c.service.DeletePet(petId, apiKey)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // FindPetsByStatus - Finds Pets by status
-func FindPetsByStatus(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *PetApiController) FindPetsByStatus(w http.ResponseWriter, r *http.Request) { 
+	query := r.URL.Query()
+	status := strings.Split(query.Get("status"), ",")
+	result, err := c.service.FindPetsByStatus(status)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // FindPetsByTags - Finds Pets by tags
-func FindPetsByTags(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *PetApiController) FindPetsByTags(w http.ResponseWriter, r *http.Request) { 
+	query := r.URL.Query()
+	tags := strings.Split(query.Get("tags"), ",")
+	result, err := c.service.FindPetsByTags(tags)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // GetPetById - Find pet by ID
-func GetPetById(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *PetApiController) GetPetById(w http.ResponseWriter, r *http.Request) { 
+	params := mux.Vars(r)
+	petId, err := parseIntParameter(params["petId"])
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.GetPetById(petId)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // UpdatePet - Update an existing pet
-func UpdatePet(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *PetApiController) UpdatePet(w http.ResponseWriter, r *http.Request) { 
+	pet := &Pet{}
+	if err := json.NewDecoder(r.Body).Decode(&pet); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.UpdatePet(*pet)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // UpdatePetWithForm - Updates a pet in the store with form data
-func UpdatePetWithForm(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *PetApiController) UpdatePetWithForm(w http.ResponseWriter, r *http.Request) { 
+	err := r.ParseForm()
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	params := mux.Vars(r)
+	petId, err := parseIntParameter(params["petId"])
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	name := r.FormValue("name")
+	status := r.FormValue("status")
+	result, err := c.service.UpdatePetWithForm(petId, name, status)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // UploadFile - uploads an image
-func UploadFile(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *PetApiController) UploadFile(w http.ResponseWriter, r *http.Request) { 
+	err := r.ParseForm()
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	params := mux.Vars(r)
+	petId, err := parseIntParameter(params["petId"])
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	additionalMetadata := r.FormValue("additionalMetadata")
+	file, err := ReadFormFileToTempFile(r, "file")
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.UploadFile(petId, additionalMetadata, file)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // UploadFileWithRequiredFile - uploads an image (required)
-func UploadFileWithRequiredFile(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *PetApiController) UploadFileWithRequiredFile(w http.ResponseWriter, r *http.Request) { 
+	err := r.ParseForm()
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	params := mux.Vars(r)
+	petId, err := parseIntParameter(params["petId"])
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	requiredFile, err := ReadFormFileToTempFile(r, "requiredFile")
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	additionalMetadata := r.FormValue("additionalMetadata")
+	result, err := c.service.UploadFileWithRequiredFile(petId, requiredFile, additionalMetadata)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }

samples/openapi3/server/petstore/go-api-server/go/api_store.go

@@ -10,29 +10,108 @@
 package petstoreserver
 
 import (
+	"encoding/json"
 	"net/http"
+	"strings"
+
+	"github.com/gorilla/mux"
 )
 
+// A StoreApiController binds http requests to an api service and writes the service results to the http response
+type StoreApiController struct {
+	service StoreApiServicer
+}
+
+// NewStoreApiController creates a default api controller
+func NewStoreApiController(s StoreApiServicer) Router {
+	return &StoreApiController{ service: s }
+}
+
+// Routes returns all of the api route for the StoreApiController
+func (c *StoreApiController) Routes() Routes {
+	return Routes{ 
+		{
+			"DeleteOrder",
+			strings.ToUpper("Delete"),
+			"/v2/store/order/{order_id}",
+			c.DeleteOrder,
+		},
+		{
+			"GetInventory",
+			strings.ToUpper("Get"),
+			"/v2/store/inventory",
+			c.GetInventory,
+		},
+		{
+			"GetOrderById",
+			strings.ToUpper("Get"),
+			"/v2/store/order/{order_id}",
+			c.GetOrderById,
+		},
+		{
+			"PlaceOrder",
+			strings.ToUpper("Post"),
+			"/v2/store/order",
+			c.PlaceOrder,
+		},
+	}
+}
+
 // DeleteOrder - Delete purchase order by ID
-func DeleteOrder(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *StoreApiController) DeleteOrder(w http.ResponseWriter, r *http.Request) { 
+	params := mux.Vars(r)
+	orderId := params["orderId"]
+	result, err := c.service.DeleteOrder(orderId)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // GetInventory - Returns pet inventories by status
-func GetInventory(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *StoreApiController) GetInventory(w http.ResponseWriter, r *http.Request) { 
+	result, err := c.service.GetInventory()
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // GetOrderById - Find purchase order by ID
-func GetOrderById(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *StoreApiController) GetOrderById(w http.ResponseWriter, r *http.Request) { 
+	params := mux.Vars(r)
+	orderId, err := parseIntParameter(params["orderId"])
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.GetOrderById(orderId)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // PlaceOrder - Place an order for a pet
-func PlaceOrder(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *StoreApiController) PlaceOrder(w http.ResponseWriter, r *http.Request) { 
+	order := &Order{}
+	if err := json.NewDecoder(r.Body).Decode(&order); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.PlaceOrder(*order)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }

samples/openapi3/server/petstore/go-api-server/go/api_user.go

@@ -10,53 +10,194 @@
 package petstoreserver
 
 import (
+	"encoding/json"
 	"net/http"
+	"strings"
+
+	"github.com/gorilla/mux"
 )
 
+// A UserApiController binds http requests to an api service and writes the service results to the http response
+type UserApiController struct {
+	service UserApiServicer
+}
+
+// NewUserApiController creates a default api controller
+func NewUserApiController(s UserApiServicer) Router {
+	return &UserApiController{ service: s }
+}
+
+// Routes returns all of the api route for the UserApiController
+func (c *UserApiController) Routes() Routes {
+	return Routes{ 
+		{
+			"CreateUser",
+			strings.ToUpper("Post"),
+			"/v2/user",
+			c.CreateUser,
+		},
+		{
+			"CreateUsersWithArrayInput",
+			strings.ToUpper("Post"),
+			"/v2/user/createWithArray",
+			c.CreateUsersWithArrayInput,
+		},
+		{
+			"CreateUsersWithListInput",
+			strings.ToUpper("Post"),
+			"/v2/user/createWithList",
+			c.CreateUsersWithListInput,
+		},
+		{
+			"DeleteUser",
+			strings.ToUpper("Delete"),
+			"/v2/user/{username}",
+			c.DeleteUser,
+		},
+		{
+			"GetUserByName",
+			strings.ToUpper("Get"),
+			"/v2/user/{username}",
+			c.GetUserByName,
+		},
+		{
+			"LoginUser",
+			strings.ToUpper("Get"),
+			"/v2/user/login",
+			c.LoginUser,
+		},
+		{
+			"LogoutUser",
+			strings.ToUpper("Get"),
+			"/v2/user/logout",
+			c.LogoutUser,
+		},
+		{
+			"UpdateUser",
+			strings.ToUpper("Put"),
+			"/v2/user/{username}",
+			c.UpdateUser,
+		},
+	}
+}
+
 // CreateUser - Create user
-func CreateUser(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *UserApiController) CreateUser(w http.ResponseWriter, r *http.Request) { 
+	user := &User{}
+	if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.CreateUser(*user)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // CreateUsersWithArrayInput - Creates list of users with given input array
-func CreateUsersWithArrayInput(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *UserApiController) CreateUsersWithArrayInput(w http.ResponseWriter, r *http.Request) { 
+	user := &[]User{}
+	if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.CreateUsersWithArrayInput(*user)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // CreateUsersWithListInput - Creates list of users with given input array
-func CreateUsersWithListInput(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *UserApiController) CreateUsersWithListInput(w http.ResponseWriter, r *http.Request) { 
+	user := &[]User{}
+	if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.CreateUsersWithListInput(*user)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // DeleteUser - Delete user
-func DeleteUser(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *UserApiController) DeleteUser(w http.ResponseWriter, r *http.Request) { 
+	params := mux.Vars(r)
+	username := params["username"]
+	result, err := c.service.DeleteUser(username)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // GetUserByName - Get user by user name
-func GetUserByName(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *UserApiController) GetUserByName(w http.ResponseWriter, r *http.Request) { 
+	params := mux.Vars(r)
+	username := params["username"]
+	result, err := c.service.GetUserByName(username)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // LoginUser - Logs user into the system
-func LoginUser(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *UserApiController) LoginUser(w http.ResponseWriter, r *http.Request) { 
+	query := r.URL.Query()
+	username := query.Get("username")
+	password := query.Get("password")
+	result, err := c.service.LoginUser(username, password)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // LogoutUser - Logs out current logged in user session
-func LogoutUser(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *UserApiController) LogoutUser(w http.ResponseWriter, r *http.Request) { 
+	result, err := c.service.LogoutUser()
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }
 
 // UpdateUser - Updated user
-func UpdateUser(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-	w.WriteHeader(http.StatusOK)
+func (c *UserApiController) UpdateUser(w http.ResponseWriter, r *http.Request) { 
+	params := mux.Vars(r)
+	username := params["username"]
+	user := &User{}
+	if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	result, err := c.service.UpdateUser(username, *user)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+	
+	EncodeJSONResponse(result, nil, w)
 }

samples/openapi3/server/petstore/go-api-server/go/routers.go

@@ -10,13 +10,15 @@
 package petstoreserver
 
 import (
-	"fmt"
+	"encoding/json"
+	"io/ioutil"
 	"net/http"
-	"strings"
-
+	"os"
+	"strconv"
 	"github.com/gorilla/mux"
 )
 
+// A Route defines the parameters for an api endpoint
 type Route struct {
 	Name        string
 	Method      string
@@ -24,300 +26,71 @@ type Route struct {
 	HandlerFunc http.HandlerFunc
 }
 
+// Routes are a collection of defined api endpoints
 type Routes []Route
 
-func NewRouter() *mux.Router {
-	router := mux.NewRouter().StrictSlash(true)
-	for _, route := range routes {
-		var handler http.Handler
-		handler = route.HandlerFunc
-		handler = Logger(handler, route.Name)
+// Router defines the required methods for retrieving api routes
+type Router interface { 
+	Routes() Routes
+}
 
-		router.
-			Methods(route.Method).
-			Path(route.Pattern).
-			Name(route.Name).
-			Handler(handler)
+// NewRouter creates a new router for any number of api routers
+func NewRouter(routers ...Router) *mux.Router {
+	router := mux.NewRouter().StrictSlash(true)
+	for _, api := range routers {
+		for _, route := range api.Routes() {
+			var handler http.Handler
+			handler = route.HandlerFunc
+			handler = Logger(handler, route.Name)
+
+			router.
+				Methods(route.Method).
+				Path(route.Pattern).
+				Name(route.Name).
+				Handler(handler)
+		}
 	}
 
 	return router
 }
 
-func Index(w http.ResponseWriter, r *http.Request) {
-	fmt.Fprintf(w, "Hello World!")
+// EncodeJSONResponse uses the json encoder to write an interface to the http response with an optional status code
+func EncodeJSONResponse(i interface{}, status *int, w http.ResponseWriter) error {
+	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+	if status != nil {
+		w.WriteHeader(*status)
+	} else {
+		w.WriteHeader(http.StatusOK)
+	}
+
+	return json.NewEncoder(w).Encode(i)
 }
 
-var routes = Routes{
-	{
-		"Index",
-		"GET",
-		"/v2/",
-		Index,
-	},
+// ReadFormFileToTempFile reads file data from a request form and writes it to a temporary file
+func ReadFormFileToTempFile(r *http.Request, key string) (*os.File, error) {
+	r.ParseForm()
+	formFile, _, err := r.FormFile(key)
+	if err != nil {
+		return nil, err
+	}
 
-	{
-		"Call123TestSpecialTags",
-		strings.ToUpper("Patch"),
-		"/v2/another-fake/dummy",
-		Call123TestSpecialTags,
-	},
+	defer formFile.Close()
+	file, err := ioutil.TempFile("tmp", key)
+	if err != nil {
+		return nil, err
+	}
 
-	{
-		"FooGet",
-		strings.ToUpper("Get"),
-		"/v2/foo",
-		FooGet,
-	},
+	defer file.Close()
+	fileBytes, err := ioutil.ReadAll(formFile)
+	if err != nil {
+		return nil, err
+	}
 
-	{
-		"FakeHealthGet",
-		strings.ToUpper("Get"),
-		"/v2/fake/health",
-		FakeHealthGet,
-	},
-
-	{
-		"FakeOuterBooleanSerialize",
-		strings.ToUpper("Post"),
-		"/v2/fake/outer/boolean",
-		FakeOuterBooleanSerialize,
-	},
-
-	{
-		"FakeOuterCompositeSerialize",
-		strings.ToUpper("Post"),
-		"/v2/fake/outer/composite",
-		FakeOuterCompositeSerialize,
-	},
-
-	{
-		"FakeOuterNumberSerialize",
-		strings.ToUpper("Post"),
-		"/v2/fake/outer/number",
-		FakeOuterNumberSerialize,
-	},
-
-	{
-		"FakeOuterStringSerialize",
-		strings.ToUpper("Post"),
-		"/v2/fake/outer/string",
-		FakeOuterStringSerialize,
-	},
-
-	{
-		"TestBodyWithFileSchema",
-		strings.ToUpper("Put"),
-		"/v2/fake/body-with-file-schema",
-		TestBodyWithFileSchema,
-	},
-
-	{
-		"TestBodyWithQueryParams",
-		strings.ToUpper("Put"),
-		"/v2/fake/body-with-query-params",
-		TestBodyWithQueryParams,
-	},
-
-	{
-		"TestClientModel",
-		strings.ToUpper("Patch"),
-		"/v2/fake",
-		TestClientModel,
-	},
-
-	{
-		"TestEndpointParameters",
-		strings.ToUpper("Post"),
-		"/v2/fake",
-		TestEndpointParameters,
-	},
-
-	{
-		"TestEnumParameters",
-		strings.ToUpper("Get"),
-		"/v2/fake",
-		TestEnumParameters,
-	},
-
-	{
-		"TestGroupParameters",
-		strings.ToUpper("Delete"),
-		"/v2/fake",
-		TestGroupParameters,
-	},
-
-	{
-		"TestInlineAdditionalProperties",
-		strings.ToUpper("Post"),
-		"/v2/fake/inline-additionalProperties",
-		TestInlineAdditionalProperties,
-	},
-
-	{
-		"TestJsonFormData",
-		strings.ToUpper("Get"),
-		"/v2/fake/jsonFormData",
-		TestJsonFormData,
-	},
-
-	{
-		"TestQueryParameterCollectionFormat",
-		strings.ToUpper("Put"),
-		"/v2/fake/test-query-paramters",
-		TestQueryParameterCollectionFormat,
-	},
-
-	{
-		"TestClassname",
-		strings.ToUpper("Patch"),
-		"/v2/fake_classname_test",
-		TestClassname,
-	},
-
-	{
-		"AddPet",
-		strings.ToUpper("Post"),
-		"/v2/pet",
-		AddPet,
-	},
-
-	{
-		"DeletePet",
-		strings.ToUpper("Delete"),
-		"/v2/pet/{petId}",
-		DeletePet,
-	},
-
-	{
-		"FindPetsByStatus",
-		strings.ToUpper("Get"),
-		"/v2/pet/findByStatus",
-		FindPetsByStatus,
-	},
-
-	{
-		"FindPetsByTags",
-		strings.ToUpper("Get"),
-		"/v2/pet/findByTags",
-		FindPetsByTags,
-	},
-
-	{
-		"GetPetById",
-		strings.ToUpper("Get"),
-		"/v2/pet/{petId}",
-		GetPetById,
-	},
-
-	{
-		"UpdatePet",
-		strings.ToUpper("Put"),
-		"/v2/pet",
-		UpdatePet,
-	},
-
-	{
-		"UpdatePetWithForm",
-		strings.ToUpper("Post"),
-		"/v2/pet/{petId}",
-		UpdatePetWithForm,
-	},
-
-	{
-		"UploadFile",
-		strings.ToUpper("Post"),
-		"/v2/pet/{petId}/uploadImage",
-		UploadFile,
-	},
-
-	{
-		"UploadFileWithRequiredFile",
-		strings.ToUpper("Post"),
-		"/v2/fake/{petId}/uploadImageWithRequiredFile",
-		UploadFileWithRequiredFile,
-	},
-
-	{
-		"DeleteOrder",
-		strings.ToUpper("Delete"),
-		"/v2/store/order/{order_id}",
-		DeleteOrder,
-	},
-
-	{
-		"GetInventory",
-		strings.ToUpper("Get"),
-		"/v2/store/inventory",
-		GetInventory,
-	},
-
-	{
-		"GetOrderById",
-		strings.ToUpper("Get"),
-		"/v2/store/order/{order_id}",
-		GetOrderById,
-	},
-
-	{
-		"PlaceOrder",
-		strings.ToUpper("Post"),
-		"/v2/store/order",
-		PlaceOrder,
-	},
-
-	{
-		"CreateUser",
-		strings.ToUpper("Post"),
-		"/v2/user",
-		CreateUser,
-	},
-
-	{
-		"CreateUsersWithArrayInput",
-		strings.ToUpper("Post"),
-		"/v2/user/createWithArray",
-		CreateUsersWithArrayInput,
-	},
-
-	{
-		"CreateUsersWithListInput",
-		strings.ToUpper("Post"),
-		"/v2/user/createWithList",
-		CreateUsersWithListInput,
-	},
-
-	{
-		"DeleteUser",
-		strings.ToUpper("Delete"),
-		"/v2/user/{username}",
-		DeleteUser,
-	},
-
-	{
-		"GetUserByName",
-		strings.ToUpper("Get"),
-		"/v2/user/{username}",
-		GetUserByName,
-	},
-
-	{
-		"LoginUser",
-		strings.ToUpper("Get"),
-		"/v2/user/login",
-		LoginUser,
-	},
-
-	{
-		"LogoutUser",
-		strings.ToUpper("Get"),
-		"/v2/user/logout",
-		LogoutUser,
-	},
-
-	{
-		"UpdateUser",
-		strings.ToUpper("Put"),
-		"/v2/user/{username}",
-		UpdateUser,
-	},
+	file.Write(fileBytes)
+	return file, nil
+}
+
+// parseIntParameter parses a sting parameter to an int64
+func parseIntParameter(param string) (int64, error) {
+	return strconv.ParseInt(param, 10, 64)
 }

samples/openapi3/server/petstore/go-api-server/main.go

@@ -13,20 +13,34 @@ import (
 	"log"
 	"net/http"
 
-	// WARNING!
-	// Change this to a fully-qualified import path
-	// once you place this file into your project.
-	// For example,
-	//
-	//    sw "github.com/myname/myrepo/go"
-	//
-	sw "./go"
+	petstoreserver "github.com/GIT_USER_ID/GIT_REPO_ID/go"
 )
 
 func main() {
 	log.Printf("Server started")
 
-	router := sw.NewRouter()
+	AnotherFakeApiService := petstoreserver.NewAnotherFakeApiService()
+	AnotherFakeApiController := petstoreserver.NewAnotherFakeApiController(AnotherFakeApiService)
+
+	DefaultApiService := petstoreserver.NewDefaultApiService()
+	DefaultApiController := petstoreserver.NewDefaultApiController(DefaultApiService)
+
+	FakeApiService := petstoreserver.NewFakeApiService()
+	FakeApiController := petstoreserver.NewFakeApiController(FakeApiService)
+
+	FakeClassnameTags123ApiService := petstoreserver.NewFakeClassnameTags123ApiService()
+	FakeClassnameTags123ApiController := petstoreserver.NewFakeClassnameTags123ApiController(FakeClassnameTags123ApiService)
+
+	PetApiService := petstoreserver.NewPetApiService()
+	PetApiController := petstoreserver.NewPetApiController(PetApiService)
+
+	StoreApiService := petstoreserver.NewStoreApiService()
+	StoreApiController := petstoreserver.NewStoreApiController(StoreApiService)
+
+	UserApiService := petstoreserver.NewUserApiService()
+	UserApiController := petstoreserver.NewUserApiController(UserApiService)
+
+	router := petstoreserver.NewRouter(AnotherFakeApiController, DefaultApiController, FakeApiController, FakeClassnameTags123ApiController, PetApiController, StoreApiController, UserApiController)
 
 	log.Fatal(http.ListenAndServe(":8080", router))
 }

samples/openapi3/server/petstore/go-gin-api-server/.openapi-generator/VERSION

@@ -1 +1 @@
-4.2.0-SNAPSHOT
+4.2.3-SNAPSHOT