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

[go-server] Fix: param names clash with variables, added suffix (#10243)

Browse Source 
* Postfix "Param" to param names in controller

* Regen samples
This commit is contained in:
Ween Jiann 2021-08-27 13:07:31 +08:00 committed by GitHub
parent 3446bc6337
commit 3b8f66cd1f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 191 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
modules/openapi-generator/src/main/resources/go-server/controller-api.mustache vendored
View File

@ -90,14 +90,14 @@ func (c *{{classname}}Controller) {{nickname}}(w http.ResponseWriter, r *http.Re
{{#allParams}} {{#allParams}}
{{#isPathParam}} {{#isPathParam}}
{{#isLong}} {{#isLong}}
{{paramName}}, err := parseInt64Parameter({{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}}, {{required}}) {{paramName}}Param, err := parseInt64Parameter({{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}}, {{required}})
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
{{/isLong}} {{/isLong}}
{{#isInteger}} {{#isInteger}}
{{paramName}}, err := parseInt32Parameter({{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}}, {{required}}) {{paramName}}Param, err := parseInt32Parameter({{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}}, {{required}})
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
@ -105,26 +105,26 @@ func (c *{{classname}}Controller) {{nickname}}(w http.ResponseWriter, r *http.Re
{{/isInteger}} {{/isInteger}}
{{^isLong}} {{^isLong}}
{{^isInteger}} {{^isInteger}}
{{paramName}} := {{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}} {{paramName}}Param := {{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}}
{{/isInteger}}{{/isLong}} {{/isInteger}}{{/isLong}}
{{/isPathParam}} {{/isPathParam}}
{{#isQueryParam}} {{#isQueryParam}}
{{#isLong}} {{#isLong}}
{{paramName}}, err := parseInt64Parameter(query.Get("{{baseName}}"), {{required}}) {{paramName}}Param, err := parseInt64Parameter(query.Get("{{baseName}}"), {{required}})
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
{{/isLong}} {{/isLong}}
{{#isInteger}} {{#isInteger}}
{{paramName}}, err := parseInt32Parameter(query.Get("{{baseName}}"), {{required}}) {{paramName}}Param, err := parseInt32Parameter(query.Get("{{baseName}}"), {{required}})
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
{{/isInteger}} {{/isInteger}}
{{#isBoolean}} {{#isBoolean}}
{{paramName}}, err := parseBoolParameter(query.Get("{{baseName}}")) {{paramName}}Param, err := parseBoolParameter(query.Get("{{baseName}}"))
if err != nil { if err != nil {
w.WriteHeader(500) w.WriteHeader(500)
return return
@ -133,15 +133,15 @@ func (c *{{classname}}Controller) {{nickname}}(w http.ResponseWriter, r *http.Re
{{^isLong}} {{^isLong}}
{{^isInteger}} {{^isInteger}}
{{^isBoolean}} {{^isBoolean}}
{{paramName}} := {{#isArray}}strings.Split({{/isArray}}query.Get("{{baseName}}"){{#isArray}}, ","){{/isArray}} {{paramName}}Param := {{#isArray}}strings.Split({{/isArray}}query.Get("{{baseName}}"){{#isArray}}, ","){{/isArray}}
{{/isBoolean}} {{/isBoolean}}
{{/isInteger}} {{/isInteger}}
{{/isLong}} {{/isLong}}
{{/isQueryParam}} {{/isQueryParam}}
{{#isFormParam}} {{#isFormParam}}
{{#isFile}}{{#isArray}} {{#isFile}}{{#isArray}}
{{paramName}}, err := ReadFormFilesToTempFiles(r, "{{baseName}}"){{/isArray}}{{^isArray}} {{paramName}}Param, err := ReadFormFilesToTempFiles(r, "{{baseName}}"){{/isArray}}{{^isArray}}
{{paramName}}, err := ReadFormFileToTempFile(r, "{{baseName}}") {{paramName}}Param, err := ReadFormFileToTempFile(r, "{{baseName}}")
{{/isArray}} {{/isArray}}
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
@ -149,16 +149,16 @@ func (c *{{classname}}Controller) {{nickname}}(w http.ResponseWriter, r *http.Re
} }
{{/isFile}} {{/isFile}}
{{#isLong}}{{#isArray}} {{#isLong}}{{#isArray}}
{{paramName}}, err := parseInt64ArrayParameter(r.FormValue("{{baseName}}"), ",", {{required}}){{/isArray}}{{^isArray}} {{paramName}}Param, err := parseInt64ArrayParameter(r.FormValue("{{baseName}}"), ",", {{required}}){{/isArray}}{{^isArray}}
{{paramName}}, err := parseInt64Parameter(r.FormValue("{{baseName}}"), {{required}}){{/isArray}} {{paramName}}Param, err := parseInt64Parameter(r.FormValue("{{baseName}}"), {{required}}){{/isArray}}
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
{{/isLong}} {{/isLong}}
{{#isInteger}}{{#isArray}} {{#isInteger}}{{#isArray}}
{{paramName}}, err := parseInt32ArrayParameter(r.FormValue("{{baseName}}"), ",", {{required}}){{/isArray}}{{^isArray}} {{paramName}}Param, err := parseInt32ArrayParameter(r.FormValue("{{baseName}}"), ",", {{required}}){{/isArray}}{{^isArray}}
{{paramName}}, err := parseInt32Parameter(r.FormValue("{{baseName}}"), {{required}}){{/isArray}} {{paramName}}Param, err := parseInt32Parameter(r.FormValue("{{baseName}}"), {{required}}){{/isArray}}
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
@ -166,26 +166,26 @@ func (c *{{classname}}Controller) {{nickname}}(w http.ResponseWriter, r *http.Re
{{/isInteger}} {{/isInteger}}
{{^isFile}} {{^isFile}}
{{^isLong}} {{^isLong}}
{{paramName}} := r.FormValue("{{baseName}}") {{paramName}}Param := r.FormValue("{{baseName}}")
{{/isLong}} {{/isLong}}
{{/isFile}} {{/isFile}}
{{/isFormParam}} {{/isFormParam}}
{{#isHeaderParam}} {{#isHeaderParam}}
{{paramName}} := r.Header.Get("{{baseName}}") {{paramName}}Param := r.Header.Get("{{baseName}}")
{{/isHeaderParam}} {{/isHeaderParam}}
{{#isBodyParam}} {{#isBodyParam}}
{{paramName}} := {{dataType}}{} {{paramName}}Param := {{dataType}}{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
{{^isAdditionalPropertiesTrue}} {{^isAdditionalPropertiesTrue}}
d.DisallowUnknownFields() d.DisallowUnknownFields()
{{/isAdditionalPropertiesTrue}} {{/isAdditionalPropertiesTrue}}
if err := d.Decode(&{{paramName}}); err != nil { if err := d.Decode(&{{paramName}}Param); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
{{#isArray}} {{#isArray}}
{{#items.isModel}} {{#items.isModel}}
for _, el := range {{paramName}} { for _, el := range {{paramName}}Param {
if err := Assert{{baseType}}Required(el); err != nil { if err := Assert{{baseType}}Required(el); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
@ -195,7 +195,7 @@ func (c *{{classname}}Controller) {{nickname}}(w http.ResponseWriter, r *http.Re
{{/isArray}} {{/isArray}}
{{^isArray}} {{^isArray}}
{{#isModel}} {{#isModel}}
if err := Assert{{baseType}}Required({{paramName}}); err != nil { if err := Assert{{baseType}}Required({{paramName}}Param); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
@ -203,7 +203,7 @@ func (c *{{classname}}Controller) {{nickname}}(w http.ResponseWriter, r *http.Re
{{/isArray}} {{/isArray}}
{{/isBodyParam}} {{/isBodyParam}}
{{/allParams}} {{/allParams}}
result, err := c.service.{{nickname}}(r.Context(){{#allParams}}, {{paramName}}{{/allParams}}) result, err := c.service.{{nickname}}(r.Context(){{#allParams}}, {{paramName}}Param{{/allParams}})
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)

50
samples/server/petstore/go-api-server/go/api_pet.go
View File

@ -103,18 +103,18 @@ func (c *PetApiController) Routes() Routes {
// AddPet - Add a new pet to the store // AddPet - Add a new pet to the store
func (c *PetApiController) AddPet(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) AddPet(w http.ResponseWriter, r *http.Request) {
pet := Pet{} petParam := Pet{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&pet); err != nil { if err := d.Decode(&petParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
if err := AssertPetRequired(pet); err != nil { if err := AssertPetRequired(petParam); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
result, err := c.service.AddPet(r.Context(), pet) result, err := c.service.AddPet(r.Context(), petParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -128,14 +128,14 @@ func (c *PetApiController) AddPet(w http.ResponseWriter, r *http.Request) {
// DeletePet - Deletes a pet // DeletePet - Deletes a pet
func (c *PetApiController) DeletePet(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) DeletePet(w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r) params := mux.Vars(r)
petId, err := parseInt64Parameter(params["petId"], true) petIdParam, err := parseInt64Parameter(params["petId"], true)
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
apiKey := r.Header.Get("api_key") apiKeyParam := r.Header.Get("api_key")
result, err := c.service.DeletePet(r.Context(), petId, apiKey) result, err := c.service.DeletePet(r.Context(), petIdParam, apiKeyParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -149,8 +149,8 @@ func (c *PetApiController) DeletePet(w http.ResponseWriter, r *http.Request) {
// FindPetsByStatus - Finds Pets by status // FindPetsByStatus - Finds Pets by status
func (c *PetApiController) FindPetsByStatus(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) FindPetsByStatus(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query() query := r.URL.Query()
status := strings.Split(query.Get("status"), ",") statusParam := strings.Split(query.Get("status"), ",")
result, err := c.service.FindPetsByStatus(r.Context(), status) result, err := c.service.FindPetsByStatus(r.Context(), statusParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -165,8 +165,8 @@ func (c *PetApiController) FindPetsByStatus(w http.ResponseWriter, r *http.Reque
// Deprecated // Deprecated
func (c *PetApiController) FindPetsByTags(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) FindPetsByTags(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query() query := r.URL.Query()
tags := strings.Split(query.Get("tags"), ",") tagsParam := strings.Split(query.Get("tags"), ",")
result, err := c.service.FindPetsByTags(r.Context(), tags) result, err := c.service.FindPetsByTags(r.Context(), tagsParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -180,13 +180,13 @@ func (c *PetApiController) FindPetsByTags(w http.ResponseWriter, r *http.Request
// GetPetById - Find pet by ID // GetPetById - Find pet by ID
func (c *PetApiController) GetPetById(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) GetPetById(w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r) params := mux.Vars(r)
petId, err := parseInt64Parameter(params["petId"], true) petIdParam, err := parseInt64Parameter(params["petId"], true)
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
result, err := c.service.GetPetById(r.Context(), petId) result, err := c.service.GetPetById(r.Context(), petIdParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -199,18 +199,18 @@ func (c *PetApiController) GetPetById(w http.ResponseWriter, r *http.Request) {
// UpdatePet - Update an existing pet // UpdatePet - Update an existing pet
func (c *PetApiController) UpdatePet(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) UpdatePet(w http.ResponseWriter, r *http.Request) {
pet := Pet{} petParam := Pet{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&pet); err != nil { if err := d.Decode(&petParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
if err := AssertPetRequired(pet); err != nil { if err := AssertPetRequired(petParam); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
result, err := c.service.UpdatePet(r.Context(), pet) result, err := c.service.UpdatePet(r.Context(), petParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -228,15 +228,15 @@ func (c *PetApiController) UpdatePetWithForm(w http.ResponseWriter, r *http.Requ
return return
} }
params := mux.Vars(r) params := mux.Vars(r)
petId, err := parseInt64Parameter(params["petId"], true) petIdParam, err := parseInt64Parameter(params["petId"], true)
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
name := r.FormValue("name") nameParam := r.FormValue("name")
status := r.FormValue("status") statusParam := r.FormValue("status")
result, err := c.service.UpdatePetWithForm(r.Context(), petId, name, status) result, err := c.service.UpdatePetWithForm(r.Context(), petIdParam, nameParam, statusParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -254,20 +254,20 @@ func (c *PetApiController) UploadFile(w http.ResponseWriter, r *http.Request) {
return return
} }
params := mux.Vars(r) params := mux.Vars(r)
petId, err := parseInt64Parameter(params["petId"], true) petIdParam, err := parseInt64Parameter(params["petId"], true)
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
additionalMetadata := r.FormValue("additionalMetadata") additionalMetadataParam := r.FormValue("additionalMetadata")
file, err := ReadFormFileToTempFile(r, "file") fileParam, err := ReadFormFileToTempFile(r, "file")
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
result, err := c.service.UploadFile(r.Context(), petId, additionalMetadata, file) result, err := c.service.UploadFile(r.Context(), petIdParam, additionalMetadataParam, fileParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)

16
samples/server/petstore/go-api-server/go/api_store.go
View File

@ -80,9 +80,9 @@ func (c *StoreApiController) Routes() Routes {
// DeleteOrder - Delete purchase order by ID // DeleteOrder - Delete purchase order by ID
func (c *StoreApiController) DeleteOrder(w http.ResponseWriter, r *http.Request) { func (c *StoreApiController) DeleteOrder(w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r) params := mux.Vars(r)
orderId := params["orderId"] orderIdParam := params["orderId"]
result, err := c.service.DeleteOrder(r.Context(), orderId) result, err := c.service.DeleteOrder(r.Context(), orderIdParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -109,13 +109,13 @@ func (c *StoreApiController) GetInventory(w http.ResponseWriter, r *http.Request
// GetOrderById - Find purchase order by ID // GetOrderById - Find purchase order by ID
func (c *StoreApiController) GetOrderById(w http.ResponseWriter, r *http.Request) { func (c *StoreApiController) GetOrderById(w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r) params := mux.Vars(r)
orderId, err := parseInt64Parameter(params["orderId"], true) orderIdParam, err := parseInt64Parameter(params["orderId"], true)
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
result, err := c.service.GetOrderById(r.Context(), orderId) result, err := c.service.GetOrderById(r.Context(), orderIdParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -128,18 +128,18 @@ func (c *StoreApiController) GetOrderById(w http.ResponseWriter, r *http.Request
// PlaceOrder - Place an order for a pet // PlaceOrder - Place an order for a pet
func (c *StoreApiController) PlaceOrder(w http.ResponseWriter, r *http.Request) { func (c *StoreApiController) PlaceOrder(w http.ResponseWriter, r *http.Request) {
order := Order{} orderParam := Order{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&order); err != nil { if err := d.Decode(&orderParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
if err := AssertOrderRequired(order); err != nil { if err := AssertOrderRequired(orderParam); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
result, err := c.service.PlaceOrder(r.Context(), order) result, err := c.service.PlaceOrder(r.Context(), orderParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)

48
samples/server/petstore/go-api-server/go/api_user.go
View File

@ -103,18 +103,18 @@ func (c *UserApiController) Routes() Routes {
// CreateUser - Create user // CreateUser - Create user
func (c *UserApiController) CreateUser(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) CreateUser(w http.ResponseWriter, r *http.Request) {
user := User{} userParam := User{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&user); err != nil { if err := d.Decode(&userParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
if err := AssertUserRequired(user); err != nil { if err := AssertUserRequired(userParam); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
result, err := c.service.CreateUser(r.Context(), user) result, err := c.service.CreateUser(r.Context(), userParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -127,20 +127,20 @@ func (c *UserApiController) CreateUser(w http.ResponseWriter, r *http.Request) {
// CreateUsersWithArrayInput - Creates list of users with given input array // CreateUsersWithArrayInput - Creates list of users with given input array
func (c *UserApiController) CreateUsersWithArrayInput(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) CreateUsersWithArrayInput(w http.ResponseWriter, r *http.Request) {
user := []User{} userParam := []User{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&user); err != nil { if err := d.Decode(&userParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
for _, el := range user { for _, el := range userParam {
if err := AssertUserRequired(el); err != nil { if err := AssertUserRequired(el); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
} }
result, err := c.service.CreateUsersWithArrayInput(r.Context(), user) result, err := c.service.CreateUsersWithArrayInput(r.Context(), userParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -153,20 +153,20 @@ func (c *UserApiController) CreateUsersWithArrayInput(w http.ResponseWriter, r *
// CreateUsersWithListInput - Creates list of users with given input array // CreateUsersWithListInput - Creates list of users with given input array
func (c *UserApiController) CreateUsersWithListInput(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) CreateUsersWithListInput(w http.ResponseWriter, r *http.Request) {
user := []User{} userParam := []User{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&user); err != nil { if err := d.Decode(&userParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
for _, el := range user { for _, el := range userParam {
if err := AssertUserRequired(el); err != nil { if err := AssertUserRequired(el); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
} }
result, err := c.service.CreateUsersWithListInput(r.Context(), user) result, err := c.service.CreateUsersWithListInput(r.Context(), userParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -180,9 +180,9 @@ func (c *UserApiController) CreateUsersWithListInput(w http.ResponseWriter, r *h
// DeleteUser - Delete user // DeleteUser - Delete user
func (c *UserApiController) DeleteUser(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) DeleteUser(w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r) params := mux.Vars(r)
username := params["username"] usernameParam := params["username"]
result, err := c.service.DeleteUser(r.Context(), username) result, err := c.service.DeleteUser(r.Context(), usernameParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -196,9 +196,9 @@ func (c *UserApiController) DeleteUser(w http.ResponseWriter, r *http.Request) {
// GetUserByName - Get user by user name // GetUserByName - Get user by user name
func (c *UserApiController) GetUserByName(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) GetUserByName(w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r) params := mux.Vars(r)
username := params["username"] usernameParam := params["username"]
result, err := c.service.GetUserByName(r.Context(), username) result, err := c.service.GetUserByName(r.Context(), usernameParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -212,9 +212,9 @@ func (c *UserApiController) GetUserByName(w http.ResponseWriter, r *http.Request
// LoginUser - Logs user into the system // LoginUser - Logs user into the system
func (c *UserApiController) LoginUser(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) LoginUser(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query() query := r.URL.Query()
username := query.Get("username") usernameParam := query.Get("username")
password := query.Get("password") passwordParam := query.Get("password")
result, err := c.service.LoginUser(r.Context(), username, password) result, err := c.service.LoginUser(r.Context(), usernameParam, passwordParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -241,20 +241,20 @@ func (c *UserApiController) LogoutUser(w http.ResponseWriter, r *http.Request) {
// UpdateUser - Updated user // UpdateUser - Updated user
func (c *UserApiController) UpdateUser(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) UpdateUser(w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r) params := mux.Vars(r)
username := params["username"] usernameParam := params["username"]
user := User{} userParam := User{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&user); err != nil { if err := d.Decode(&userParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
if err := AssertUserRequired(user); err != nil { if err := AssertUserRequired(userParam); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
result, err := c.service.UpdateUser(r.Context(), username, user) result, err := c.service.UpdateUser(r.Context(), usernameParam, userParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)

50
samples/server/petstore/go-chi-server/go/api_pet.go
View File

@ -103,18 +103,18 @@ func (c *PetApiController) Routes() Routes {
// AddPet - Add a new pet to the store // AddPet - Add a new pet to the store
func (c *PetApiController) AddPet(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) AddPet(w http.ResponseWriter, r *http.Request) {
pet := Pet{} petParam := Pet{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&pet); err != nil { if err := d.Decode(&petParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
if err := AssertPetRequired(pet); err != nil { if err := AssertPetRequired(petParam); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
result, err := c.service.AddPet(r.Context(), pet) result, err := c.service.AddPet(r.Context(), petParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -127,14 +127,14 @@ func (c *PetApiController) AddPet(w http.ResponseWriter, r *http.Request) {
// DeletePet - Deletes a pet // DeletePet - Deletes a pet
func (c *PetApiController) DeletePet(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) DeletePet(w http.ResponseWriter, r *http.Request) {
petId, err := parseInt64Parameter(chi.URLParam(r, "petId"), true) petIdParam, err := parseInt64Parameter(chi.URLParam(r, "petId"), true)
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
apiKey := r.Header.Get("api_key") apiKeyParam := r.Header.Get("api_key")
result, err := c.service.DeletePet(r.Context(), petId, apiKey) result, err := c.service.DeletePet(r.Context(), petIdParam, apiKeyParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -148,8 +148,8 @@ func (c *PetApiController) DeletePet(w http.ResponseWriter, r *http.Request) {
// FindPetsByStatus - Finds Pets by status // FindPetsByStatus - Finds Pets by status
func (c *PetApiController) FindPetsByStatus(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) FindPetsByStatus(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query() query := r.URL.Query()
status := strings.Split(query.Get("status"), ",") statusParam := strings.Split(query.Get("status"), ",")
result, err := c.service.FindPetsByStatus(r.Context(), status) result, err := c.service.FindPetsByStatus(r.Context(), statusParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -164,8 +164,8 @@ func (c *PetApiController) FindPetsByStatus(w http.ResponseWriter, r *http.Reque
// Deprecated // Deprecated
func (c *PetApiController) FindPetsByTags(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) FindPetsByTags(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query() query := r.URL.Query()
tags := strings.Split(query.Get("tags"), ",") tagsParam := strings.Split(query.Get("tags"), ",")
result, err := c.service.FindPetsByTags(r.Context(), tags) result, err := c.service.FindPetsByTags(r.Context(), tagsParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -178,13 +178,13 @@ func (c *PetApiController) FindPetsByTags(w http.ResponseWriter, r *http.Request
// GetPetById - Find pet by ID // GetPetById - Find pet by ID
func (c *PetApiController) GetPetById(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) GetPetById(w http.ResponseWriter, r *http.Request) {
petId, err := parseInt64Parameter(chi.URLParam(r, "petId"), true) petIdParam, err := parseInt64Parameter(chi.URLParam(r, "petId"), true)
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
result, err := c.service.GetPetById(r.Context(), petId) result, err := c.service.GetPetById(r.Context(), petIdParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -197,18 +197,18 @@ func (c *PetApiController) GetPetById(w http.ResponseWriter, r *http.Request) {
// UpdatePet - Update an existing pet // UpdatePet - Update an existing pet
func (c *PetApiController) UpdatePet(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) UpdatePet(w http.ResponseWriter, r *http.Request) {
pet := Pet{} petParam := Pet{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&pet); err != nil { if err := d.Decode(&petParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
if err := AssertPetRequired(pet); err != nil { if err := AssertPetRequired(petParam); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
result, err := c.service.UpdatePet(r.Context(), pet) result, err := c.service.UpdatePet(r.Context(), petParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -225,15 +225,15 @@ func (c *PetApiController) UpdatePetWithForm(w http.ResponseWriter, r *http.Requ
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
petId, err := parseInt64Parameter(chi.URLParam(r, "petId"), true) petIdParam, err := parseInt64Parameter(chi.URLParam(r, "petId"), true)
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
name := r.FormValue("name") nameParam := r.FormValue("name")
status := r.FormValue("status") statusParam := r.FormValue("status")
result, err := c.service.UpdatePetWithForm(r.Context(), petId, name, status) result, err := c.service.UpdatePetWithForm(r.Context(), petIdParam, nameParam, statusParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -250,20 +250,20 @@ func (c *PetApiController) UploadFile(w http.ResponseWriter, r *http.Request) {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
petId, err := parseInt64Parameter(chi.URLParam(r, "petId"), true) petIdParam, err := parseInt64Parameter(chi.URLParam(r, "petId"), true)
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
additionalMetadata := r.FormValue("additionalMetadata") additionalMetadataParam := r.FormValue("additionalMetadata")
file, err := ReadFormFileToTempFile(r, "file") fileParam, err := ReadFormFileToTempFile(r, "file")
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
result, err := c.service.UploadFile(r.Context(), petId, additionalMetadata, file) result, err := c.service.UploadFile(r.Context(), petIdParam, additionalMetadataParam, fileParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)

16
samples/server/petstore/go-chi-server/go/api_store.go
View File

@ -79,9 +79,9 @@ func (c *StoreApiController) Routes() Routes {
// DeleteOrder - Delete purchase order by ID // DeleteOrder - Delete purchase order by ID
func (c *StoreApiController) DeleteOrder(w http.ResponseWriter, r *http.Request) { func (c *StoreApiController) DeleteOrder(w http.ResponseWriter, r *http.Request) {
orderId := chi.URLParam(r, "orderId") orderIdParam := chi.URLParam(r, "orderId")
result, err := c.service.DeleteOrder(r.Context(), orderId) result, err := c.service.DeleteOrder(r.Context(), orderIdParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -107,13 +107,13 @@ func (c *StoreApiController) GetInventory(w http.ResponseWriter, r *http.Request
// GetOrderById - Find purchase order by ID // GetOrderById - Find purchase order by ID
func (c *StoreApiController) GetOrderById(w http.ResponseWriter, r *http.Request) { func (c *StoreApiController) GetOrderById(w http.ResponseWriter, r *http.Request) {
orderId, err := parseInt64Parameter(chi.URLParam(r, "orderId"), true) orderIdParam, err := parseInt64Parameter(chi.URLParam(r, "orderId"), true)
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
result, err := c.service.GetOrderById(r.Context(), orderId) result, err := c.service.GetOrderById(r.Context(), orderIdParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -126,18 +126,18 @@ func (c *StoreApiController) GetOrderById(w http.ResponseWriter, r *http.Request
// PlaceOrder - Place an order for a pet // PlaceOrder - Place an order for a pet
func (c *StoreApiController) PlaceOrder(w http.ResponseWriter, r *http.Request) { func (c *StoreApiController) PlaceOrder(w http.ResponseWriter, r *http.Request) {
order := Order{} orderParam := Order{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&order); err != nil { if err := d.Decode(&orderParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
if err := AssertOrderRequired(order); err != nil { if err := AssertOrderRequired(orderParam); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
result, err := c.service.PlaceOrder(r.Context(), order) result, err := c.service.PlaceOrder(r.Context(), orderParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)

48
samples/server/petstore/go-chi-server/go/api_user.go
View File

@ -103,18 +103,18 @@ func (c *UserApiController) Routes() Routes {
// CreateUser - Create user // CreateUser - Create user
func (c *UserApiController) CreateUser(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) CreateUser(w http.ResponseWriter, r *http.Request) {
user := User{} userParam := User{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&user); err != nil { if err := d.Decode(&userParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
if err := AssertUserRequired(user); err != nil { if err := AssertUserRequired(userParam); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
result, err := c.service.CreateUser(r.Context(), user) result, err := c.service.CreateUser(r.Context(), userParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -127,20 +127,20 @@ func (c *UserApiController) CreateUser(w http.ResponseWriter, r *http.Request) {
// CreateUsersWithArrayInput - Creates list of users with given input array // CreateUsersWithArrayInput - Creates list of users with given input array
func (c *UserApiController) CreateUsersWithArrayInput(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) CreateUsersWithArrayInput(w http.ResponseWriter, r *http.Request) {
user := []User{} userParam := []User{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&user); err != nil { if err := d.Decode(&userParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
for _, el := range user { for _, el := range userParam {
if err := AssertUserRequired(el); err != nil { if err := AssertUserRequired(el); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
} }
result, err := c.service.CreateUsersWithArrayInput(r.Context(), user) result, err := c.service.CreateUsersWithArrayInput(r.Context(), userParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -153,20 +153,20 @@ func (c *UserApiController) CreateUsersWithArrayInput(w http.ResponseWriter, r *
// CreateUsersWithListInput - Creates list of users with given input array // CreateUsersWithListInput - Creates list of users with given input array
func (c *UserApiController) CreateUsersWithListInput(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) CreateUsersWithListInput(w http.ResponseWriter, r *http.Request) {
user := []User{} userParam := []User{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&user); err != nil { if err := d.Decode(&userParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
for _, el := range user { for _, el := range userParam {
if err := AssertUserRequired(el); err != nil { if err := AssertUserRequired(el); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
} }
result, err := c.service.CreateUsersWithListInput(r.Context(), user) result, err := c.service.CreateUsersWithListInput(r.Context(), userParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -179,9 +179,9 @@ func (c *UserApiController) CreateUsersWithListInput(w http.ResponseWriter, r *h
// DeleteUser - Delete user // DeleteUser - Delete user
func (c *UserApiController) DeleteUser(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) DeleteUser(w http.ResponseWriter, r *http.Request) {
username := chi.URLParam(r, "username") usernameParam := chi.URLParam(r, "username")
result, err := c.service.DeleteUser(r.Context(), username) result, err := c.service.DeleteUser(r.Context(), usernameParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -194,9 +194,9 @@ func (c *UserApiController) DeleteUser(w http.ResponseWriter, r *http.Request) {
// GetUserByName - Get user by user name // GetUserByName - Get user by user name
func (c *UserApiController) GetUserByName(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) GetUserByName(w http.ResponseWriter, r *http.Request) {
username := chi.URLParam(r, "username") usernameParam := chi.URLParam(r, "username")
result, err := c.service.GetUserByName(r.Context(), username) result, err := c.service.GetUserByName(r.Context(), usernameParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -210,9 +210,9 @@ func (c *UserApiController) GetUserByName(w http.ResponseWriter, r *http.Request
// LoginUser - Logs user into the system // LoginUser - Logs user into the system
func (c *UserApiController) LoginUser(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) LoginUser(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query() query := r.URL.Query()
username := query.Get("username") usernameParam := query.Get("username")
password := query.Get("password") passwordParam := query.Get("password")
result, err := c.service.LoginUser(r.Context(), username, password) result, err := c.service.LoginUser(r.Context(), usernameParam, passwordParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -238,20 +238,20 @@ func (c *UserApiController) LogoutUser(w http.ResponseWriter, r *http.Request) {
// UpdateUser - Updated user // UpdateUser - Updated user
func (c *UserApiController) UpdateUser(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) UpdateUser(w http.ResponseWriter, r *http.Request) {
username := chi.URLParam(r, "username") usernameParam := chi.URLParam(r, "username")
user := User{} userParam := User{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&user); err != nil { if err := d.Decode(&userParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
if err := AssertUserRequired(user); err != nil { if err := AssertUserRequired(userParam); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
result, err := c.service.UpdateUser(r.Context(), username, user) result, err := c.service.UpdateUser(r.Context(), usernameParam, userParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)

50
samples/server/petstore/go-server-required/go/api_pet.go
View File

@ -103,18 +103,18 @@ func (c *PetApiController) Routes() Routes {
// AddPet - Add a new pet to the store // AddPet - Add a new pet to the store
func (c *PetApiController) AddPet(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) AddPet(w http.ResponseWriter, r *http.Request) {
pet := Pet{} petParam := Pet{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&pet); err != nil { if err := d.Decode(&petParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
if err := AssertPetRequired(pet); err != nil { if err := AssertPetRequired(petParam); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
result, err := c.service.AddPet(r.Context(), pet) result, err := c.service.AddPet(r.Context(), petParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -127,14 +127,14 @@ func (c *PetApiController) AddPet(w http.ResponseWriter, r *http.Request) {
// DeletePet - Deletes a pet // DeletePet - Deletes a pet
func (c *PetApiController) DeletePet(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) DeletePet(w http.ResponseWriter, r *http.Request) {
petId, err := parseInt64Parameter(chi.URLParam(r, "petId"), true) petIdParam, err := parseInt64Parameter(chi.URLParam(r, "petId"), true)
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
apiKey := r.Header.Get("api_key") apiKeyParam := r.Header.Get("api_key")
result, err := c.service.DeletePet(r.Context(), petId, apiKey) result, err := c.service.DeletePet(r.Context(), petIdParam, apiKeyParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -148,8 +148,8 @@ func (c *PetApiController) DeletePet(w http.ResponseWriter, r *http.Request) {
// FindPetsByStatus - Finds Pets by status // FindPetsByStatus - Finds Pets by status
func (c *PetApiController) FindPetsByStatus(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) FindPetsByStatus(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query() query := r.URL.Query()
status := strings.Split(query.Get("status"), ",") statusParam := strings.Split(query.Get("status"), ",")
result, err := c.service.FindPetsByStatus(r.Context(), status) result, err := c.service.FindPetsByStatus(r.Context(), statusParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -164,8 +164,8 @@ func (c *PetApiController) FindPetsByStatus(w http.ResponseWriter, r *http.Reque
// Deprecated // Deprecated
func (c *PetApiController) FindPetsByTags(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) FindPetsByTags(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query() query := r.URL.Query()
tags := strings.Split(query.Get("tags"), ",") tagsParam := strings.Split(query.Get("tags"), ",")
result, err := c.service.FindPetsByTags(r.Context(), tags) result, err := c.service.FindPetsByTags(r.Context(), tagsParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -178,13 +178,13 @@ func (c *PetApiController) FindPetsByTags(w http.ResponseWriter, r *http.Request
// GetPetById - Find pet by ID // GetPetById - Find pet by ID
func (c *PetApiController) GetPetById(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) GetPetById(w http.ResponseWriter, r *http.Request) {
petId, err := parseInt64Parameter(chi.URLParam(r, "petId"), true) petIdParam, err := parseInt64Parameter(chi.URLParam(r, "petId"), true)
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
result, err := c.service.GetPetById(r.Context(), petId) result, err := c.service.GetPetById(r.Context(), petIdParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -197,18 +197,18 @@ func (c *PetApiController) GetPetById(w http.ResponseWriter, r *http.Request) {
// UpdatePet - Update an existing pet // UpdatePet - Update an existing pet
func (c *PetApiController) UpdatePet(w http.ResponseWriter, r *http.Request) { func (c *PetApiController) UpdatePet(w http.ResponseWriter, r *http.Request) {
pet := Pet{} petParam := Pet{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&pet); err != nil { if err := d.Decode(&petParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
if err := AssertPetRequired(pet); err != nil { if err := AssertPetRequired(petParam); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
result, err := c.service.UpdatePet(r.Context(), pet) result, err := c.service.UpdatePet(r.Context(), petParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -225,15 +225,15 @@ func (c *PetApiController) UpdatePetWithForm(w http.ResponseWriter, r *http.Requ
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
petId, err := parseInt64Parameter(chi.URLParam(r, "petId"), true) petIdParam, err := parseInt64Parameter(chi.URLParam(r, "petId"), true)
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
name := r.FormValue("name") nameParam := r.FormValue("name")
status := r.FormValue("status") statusParam := r.FormValue("status")
result, err := c.service.UpdatePetWithForm(r.Context(), petId, name, status) result, err := c.service.UpdatePetWithForm(r.Context(), petIdParam, nameParam, statusParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -250,20 +250,20 @@ func (c *PetApiController) UploadFile(w http.ResponseWriter, r *http.Request) {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
petId, err := parseInt64Parameter(chi.URLParam(r, "petId"), true) petIdParam, err := parseInt64Parameter(chi.URLParam(r, "petId"), true)
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
additionalMetadata := r.FormValue("additionalMetadata") additionalMetadataParam := r.FormValue("additionalMetadata")
file, err := ReadFormFileToTempFile(r, "file") fileParam, err := ReadFormFileToTempFile(r, "file")
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
result, err := c.service.UploadFile(r.Context(), petId, additionalMetadata, file) result, err := c.service.UploadFile(r.Context(), petIdParam, additionalMetadataParam, fileParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)

16
samples/server/petstore/go-server-required/go/api_store.go
View File

@ -79,9 +79,9 @@ func (c *StoreApiController) Routes() Routes {
// DeleteOrder - Delete purchase order by ID // DeleteOrder - Delete purchase order by ID
func (c *StoreApiController) DeleteOrder(w http.ResponseWriter, r *http.Request) { func (c *StoreApiController) DeleteOrder(w http.ResponseWriter, r *http.Request) {
orderId := chi.URLParam(r, "orderId") orderIdParam := chi.URLParam(r, "orderId")
result, err := c.service.DeleteOrder(r.Context(), orderId) result, err := c.service.DeleteOrder(r.Context(), orderIdParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -107,13 +107,13 @@ func (c *StoreApiController) GetInventory(w http.ResponseWriter, r *http.Request
// GetOrderById - Find purchase order by ID // GetOrderById - Find purchase order by ID
func (c *StoreApiController) GetOrderById(w http.ResponseWriter, r *http.Request) { func (c *StoreApiController) GetOrderById(w http.ResponseWriter, r *http.Request) {
orderId, err := parseInt64Parameter(chi.URLParam(r, "orderId"), true) orderIdParam, err := parseInt64Parameter(chi.URLParam(r, "orderId"), true)
if err != nil { if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
result, err := c.service.GetOrderById(r.Context(), orderId) result, err := c.service.GetOrderById(r.Context(), orderIdParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -126,18 +126,18 @@ func (c *StoreApiController) GetOrderById(w http.ResponseWriter, r *http.Request
// PlaceOrder - Place an order for a pet // PlaceOrder - Place an order for a pet
func (c *StoreApiController) PlaceOrder(w http.ResponseWriter, r *http.Request) { func (c *StoreApiController) PlaceOrder(w http.ResponseWriter, r *http.Request) {
order := Order{} orderParam := Order{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&order); err != nil { if err := d.Decode(&orderParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
if err := AssertOrderRequired(order); err != nil { if err := AssertOrderRequired(orderParam); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
result, err := c.service.PlaceOrder(r.Context(), order) result, err := c.service.PlaceOrder(r.Context(), orderParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)

48
samples/server/petstore/go-server-required/go/api_user.go
View File

@ -103,18 +103,18 @@ func (c *UserApiController) Routes() Routes {
// CreateUser - Create user // CreateUser - Create user
func (c *UserApiController) CreateUser(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) CreateUser(w http.ResponseWriter, r *http.Request) {
user := User{} userParam := User{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&user); err != nil { if err := d.Decode(&userParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
if err := AssertUserRequired(user); err != nil { if err := AssertUserRequired(userParam); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
result, err := c.service.CreateUser(r.Context(), user) result, err := c.service.CreateUser(r.Context(), userParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -127,20 +127,20 @@ func (c *UserApiController) CreateUser(w http.ResponseWriter, r *http.Request) {
// CreateUsersWithArrayInput - Creates list of users with given input array // CreateUsersWithArrayInput - Creates list of users with given input array
func (c *UserApiController) CreateUsersWithArrayInput(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) CreateUsersWithArrayInput(w http.ResponseWriter, r *http.Request) {
user := []User{} userParam := []User{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&user); err != nil { if err := d.Decode(&userParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
for _, el := range user { for _, el := range userParam {
if err := AssertUserRequired(el); err != nil { if err := AssertUserRequired(el); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
} }
result, err := c.service.CreateUsersWithArrayInput(r.Context(), user) result, err := c.service.CreateUsersWithArrayInput(r.Context(), userParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -153,20 +153,20 @@ func (c *UserApiController) CreateUsersWithArrayInput(w http.ResponseWriter, r *
// CreateUsersWithListInput - Creates list of users with given input array // CreateUsersWithListInput - Creates list of users with given input array
func (c *UserApiController) CreateUsersWithListInput(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) CreateUsersWithListInput(w http.ResponseWriter, r *http.Request) {
user := []User{} userParam := []User{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&user); err != nil { if err := d.Decode(&userParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
for _, el := range user { for _, el := range userParam {
if err := AssertUserRequired(el); err != nil { if err := AssertUserRequired(el); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
} }
result, err := c.service.CreateUsersWithListInput(r.Context(), user) result, err := c.service.CreateUsersWithListInput(r.Context(), userParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -179,9 +179,9 @@ func (c *UserApiController) CreateUsersWithListInput(w http.ResponseWriter, r *h
// DeleteUser - Delete user // DeleteUser - Delete user
func (c *UserApiController) DeleteUser(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) DeleteUser(w http.ResponseWriter, r *http.Request) {
username := chi.URLParam(r, "username") usernameParam := chi.URLParam(r, "username")
result, err := c.service.DeleteUser(r.Context(), username) result, err := c.service.DeleteUser(r.Context(), usernameParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -194,9 +194,9 @@ func (c *UserApiController) DeleteUser(w http.ResponseWriter, r *http.Request) {
// GetUserByName - Get user by user name // GetUserByName - Get user by user name
func (c *UserApiController) GetUserByName(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) GetUserByName(w http.ResponseWriter, r *http.Request) {
username := chi.URLParam(r, "username") usernameParam := chi.URLParam(r, "username")
result, err := c.service.GetUserByName(r.Context(), username) result, err := c.service.GetUserByName(r.Context(), usernameParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -210,9 +210,9 @@ func (c *UserApiController) GetUserByName(w http.ResponseWriter, r *http.Request
// LoginUser - Logs user into the system // LoginUser - Logs user into the system
func (c *UserApiController) LoginUser(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) LoginUser(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query() query := r.URL.Query()
username := query.Get("username") usernameParam := query.Get("username")
password := query.Get("password") passwordParam := query.Get("password")
result, err := c.service.LoginUser(r.Context(), username, password) result, err := c.service.LoginUser(r.Context(), usernameParam, passwordParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)
@ -238,20 +238,20 @@ func (c *UserApiController) LogoutUser(w http.ResponseWriter, r *http.Request) {
// UpdateUser - Updated user // UpdateUser - Updated user
func (c *UserApiController) UpdateUser(w http.ResponseWriter, r *http.Request) { func (c *UserApiController) UpdateUser(w http.ResponseWriter, r *http.Request) {
username := chi.URLParam(r, "username") usernameParam := chi.URLParam(r, "username")
user := User{} userParam := User{}
d := json.NewDecoder(r.Body) d := json.NewDecoder(r.Body)
d.DisallowUnknownFields() d.DisallowUnknownFields()
if err := d.Decode(&user); err != nil { if err := d.Decode(&userParam); err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil) c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return return
} }
if err := AssertUserRequired(user); err != nil { if err := AssertUserRequired(userParam); err != nil {
c.errorHandler(w, r, err, nil) c.errorHandler(w, r, err, nil)
return return
} }
result, err := c.service.UpdateUser(r.Context(), username, user) result, err := c.service.UpdateUser(r.Context(), usernameParam, userParam)
// If an error occurred, encode the error with the status code // If an error occurred, encode the error with the status code
if err != nil { if err != nil {
c.errorHandler(w, r, err, &result) c.errorHandler(w, r, err, &result)