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

[go-server] Add ability to handle nullable query param (#17321)

Browse Source 
* Update

* Regen
This commit is contained in:
Ween Jiann
2023-12-21 19:13:05 +08:00
committed by GitHub
parent 864c0db5e9
commit bf4c98a82a
21 changed files with 1131 additions and 300 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GoServerCodegen.java
+55 -10
View File
@@ -31,6 +31,8 @@ import org.slf4j.LoggerFactory;
import java.io.File;
import java.util.*;
import static org.openapitools.codegen.utils.StringUtils.camelize;
public class GoServerCodegen extends AbstractGoCodegen {
/**
@@ -322,34 +324,77 @@ public class GoServerCodegen extends AbstractGoCodegen {
@Override
public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<ModelMap> allModels) {
objs = super.postProcessOperationsWithModels(objs, allModels);
// TODO: refactor abstractGoCodegen, decouple go client only code and remove this
OperationMap objectMap = objs.getOperations();
List<CodegenOperation> operations = objectMap.getOperation();
for (CodegenOperation operation : operations) {
// http method verb conversion (e.g. PUT => Put)
operation.httpMethod = camelize(operation.httpMethod.toLowerCase(Locale.ROOT));
}
// remove model imports to avoid error
List<Map<String, String>> imports = objs.getImports();
if (imports == null)
return objs;
// override imports to only include packages for interface parameters
imports.clear();
Iterator<Map<String, String>> iterator = imports.iterator();
while (iterator.hasNext()) {
String _import = iterator.next().get("import");
if (_import.startsWith(apiPackage))
iterator.remove();
}
boolean addedTimeImport = false;
boolean addedOSImport = false;
boolean addedReflectImport = false;
for (CodegenOperation operation : operations) {
for (CodegenParameter param : operation.allParams) {
// import "os" if the operation uses files
if (!addedOSImport && ("*os.File".equals(param.dataType) || ("[]*os.File".equals(param.dataType)))) {
if (!addedOSImport && ("*os.File".equals(param.dataType) || "[]*os.File".equals(param.dataType))) {
imports.add(createMapping("import", "os"));
addedOSImport = true;
}
// import "time" if the operation has a required time parameter
if (param.required) {
if (!addedTimeImport && "time.Time".equals(param.dataType)) {
imports.add(createMapping("import", "time"));
addedTimeImport = true;
}
// import "time" if the operation has a time parameter.
if (!addedTimeImport && "time.Time".equals(param.dataType)) {
imports.add(createMapping("import", "time"));
addedTimeImport = true;
}
// import "reflect" package if the parameter is collectionFormat=multi
if (!addedReflectImport && param.isCollectionFormatMulti) {
imports.add(createMapping("import", "reflect"));
addedReflectImport = true;
}
// set x-exportParamName
char nameFirstChar = param.paramName.charAt(0);
if (Character.isUpperCase(nameFirstChar)) {
// First char is already uppercase, just use paramName.
param.vendorExtensions.put("x-export-param-name", param.paramName);
} else {
// It's a lowercase first char, let's convert it to uppercase
StringBuilder sb = new StringBuilder(param.paramName);
sb.setCharAt(0, Character.toUpperCase(nameFirstChar));
param.vendorExtensions.put("x-export-param-name", sb.toString());
}
}
}
// recursively add import for mapping one type to multiple imports
List<Map<String, String>> recursiveImports = objs.getImports();
if (recursiveImports == null)
return objs;
ListIterator<Map<String, String>> listIterator = imports.listIterator();
while (listIterator.hasNext()) {
String _import = listIterator.next().get("import");
// if the import package happens to be found in the importMapping (key)
// add the corresponding import package to the list
if (importMapping.containsKey(_import)) {
listIterator.add(createMapping("import", importMapping.get(_import)));
}
}
modules/openapi-generator/src/main/resources/go-server/api.mustache
Vendored
+1 -1
View File
@@ -28,5 +28,5 @@ type {{classname}}Servicer interface { {{#operations}}{{#operation}}
{{#isDeprecated}}
// Deprecated
{{/isDeprecated}}
{{operationId}}(context.Context{{#allParams}}, {{dataType}}{{/allParams}}) (ImplResponse, error){{/operation}}{{/operations}}
{{operationId}}(context.Context{{#allParams}}, {{#isNullable}}*{{/isNullable}}{{dataType}}{{/allParams}}) (ImplResponse, error){{/operation}}{{/operations}}
}{{/apis}}{{/apiInfo}}
modules/openapi-generator/src/main/resources/go-server/controller-api.mustache
Vendored
+187 -118
View File
@@ -1,6 +1,7 @@
{{>partial_header}}
package {{packageName}}
{{#operations}}
import (
"encoding/json"
{{#isBodyParam}}
@@ -11,6 +12,8 @@ import (
{{/isBodyParam}}
"net/http"
"strings"
{{#imports}} "{{import}}"
{{/imports}}
{{#routers}}
{{#mux}}
@@ -21,6 +24,7 @@ import (
{{/chi}}
{{/routers}}
)
{{/operations}}
// {{classname}}Controller binds http requests to an api service and writes the service results to the http response
type {{classname}}Controller struct {
@@ -204,105 +208,188 @@ func (c *{{classname}}Controller) {{nickname}}(w http.ResponseWriter, r *http.Re
{{/isPathParam}}
{{#isQueryParam}}
{{#isDateTime}}
{{#required}}
if !query.Has("{{baseName}}"){
c.errorHandler(w, r, &RequiredError{"{{baseName}}"}, nil)
return
}
{{paramName}}Param, err := parseTime(query.Get("{{baseName}}"))
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
{{/required}}
{{^required}}
{{paramName}}Param, err := parseTime(query.Get("{{baseName}}"))
if err != nil {
var {{paramName}}Param {{#isNullable}}*{{/isNullable}}time.Time
if query.Has("{{baseName}}"){
param, err := parseTime(query.Get("{{baseName}}"))
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
{{paramName}}Param = {{#isNullable}}&{{/isNullable}}param
} else {
{{#required}}
c.errorHandler(w, r, &RequiredError{"{{baseName}}"}, nil)
return
{{/required}}
}
{{/required}}
{{/isDateTime}}
{{#isNumber}}
{{paramName}}Param, err := parseNumericParameter[float32](
query.Get("{{baseName}}"),{{#defaultValue}}
WithDefaultOrParse[float32]({{defaultValue}}, parseFloat32),{{/defaultValue}}{{^defaultValue}}{{#required}}
WithRequire[float32](parseFloat32),{{/required}}{{/defaultValue}}{{^defaultValue}}{{^required}}
WithParse[float32](parseFloat32),{{/required}}{{/defaultValue}}{{#minimum}}
WithMinimum[float32]({{minimum}}),{{/minimum}}{{#maximum}}
WithMaximum[float32]({{maximum}}),{{/maximum}}
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
var {{paramName}}Param {{#isNullable}}*{{/isNullable}}float32
if query.Has("{{baseName}}") {
param, err := parseNumericParameter[float32](
query.Get("{{baseName}}"),
WithParse[float32](parseFloat32),{{#minimum}}
WithMinimum[float32]({{minimum}}),{{/minimum}}{{#maximum}}
WithMaximum[float32]({{maximum}}),{{/maximum}}
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
{{paramName}}Param = {{#isNullable}}&{{/isNullable}}param
} else {
{{#required}}
c.errorHandler(w, r, &RequiredError{Field: "{{baseName}}"}, nil)
return
{{/required}}
{{^required}}
{{#defaultValue}}
var param float32 = {{defaultValue}}
{{paramName}}Param = {{#isNullable}}&{{/isNullable}}param
{{/defaultValue}}
{{/required}}
}
{{/isNumber}}
{{#isFloat}}
{{paramName}}Param, err := parseNumericParameter[float32](
query.Get("{{baseName}}"),{{#defaultValue}}
WithDefaultOrParse[float32]({{defaultValue}}, parseFloat32),{{/defaultValue}}{{^defaultValue}}{{#required}}
WithRequire[float32](parseFloat32),{{/required}}{{/defaultValue}}{{^defaultValue}}{{^required}}
WithParse[float32](parseFloat32),{{/required}}{{/defaultValue}}{{#minimum}}
WithMinimum[float32]({{minimum}}),{{/minimum}}{{#maximum}}
WithMaximum[float32]({{maximum}}),{{/maximum}}
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
var {{paramName}}Param {{#isNullable}}*{{/isNullable}}float32
if query.Has("{{baseName}}") {
param, err := parseNumericParameter[float32](
query.Get("{{baseName}}"),
WithParse[float32](parseFloat32),{{#minimum}}
WithMinimum[float32]({{minimum}}),{{/minimum}}{{#maximum}}
WithMaximum[float32]({{maximum}}),{{/maximum}}
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
{{paramName}}Param = {{#isNullable}}&{{/isNullable}}param
} else {
{{#required}}
c.errorHandler(w, r, &RequiredError{Field: "{{baseName}}"}, nil)
return
{{/required}}
{{^required}}
{{#defaultValue}}
var param float32 = {{defaultValue}}
{{paramName}}Param = {{#isNullable}}&{{/isNullable}}param
{{/defaultValue}}
{{/required}}
}
{{/isFloat}}
{{#isDouble}}
{{paramName}}Param, err := parseNumericParameter[float64](
query.Get("{{baseName}}"),{{#defaultValue}}
WithDefaultOrParse[float64]({{defaultValue}}, parseFloat64),{{/defaultValue}}{{^defaultValue}}{{#required}}
WithRequire[float64](parseFloat64),{{/required}}{{/defaultValue}}{{^defaultValue}}{{^required}}
WithParse[float64](parseFloat64),{{/required}}{{/defaultValue}}{{#minimum}}
WithMinimum[float64]({{minimum}}),{{/minimum}}{{#maximum}}
WithMaximum[float64]({{maximum}}),{{/maximum}}
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
var {{paramName}}Param {{#isNullable}}*{{/isNullable}}float64
if query.Has("{{baseName}}") {
param, err := parseNumericParameter[float64](
query.Get("{{baseName}}"),
WithParse[float64](parseFloat64),{{#minimum}}
WithMinimum[float64]({{minimum}}),{{/minimum}}{{#maximum}}
WithMaximum[float64]({{maximum}}),{{/maximum}}
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
{{paramName}}Param = {{#isNullable}}&{{/isNullable}}param
} else {
{{#required}}
c.errorHandler(w, r, &RequiredError{Field: "{{baseName}}"}, nil)
return
{{/required}}
{{^required}}
{{#defaultValue}}
var param float64 = {{defaultValue}}
{{paramName}}Param = {{#isNullable}}&{{/isNullable}}param
{{/defaultValue}}
{{/required}}
}
{{/isDouble}}
{{#isLong}}
{{paramName}}Param, err := parseNumericParameter[int64](
query.Get("{{baseName}}"),{{#defaultValue}}
WithDefaultOrParse[int64]({{defaultValue}}, parseInt64),{{/defaultValue}}{{^defaultValue}}{{#required}}
WithRequire[int64](parseInt64),{{/required}}{{/defaultValue}}{{^defaultValue}}{{^required}}
WithParse[int64](parseInt64),{{/required}}{{/defaultValue}}{{#minimum}}
WithMinimum[int64]({{minimum}}),{{/minimum}}{{#maximum}}
WithMaximum[int64]({{maximum}}),{{/maximum}}
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
var {{paramName}}Param {{#isNullable}}*{{/isNullable}}int64
if query.Has("{{baseName}}") {
param, err := parseNumericParameter[int64](
query.Get("{{baseName}}"),
WithParse[int64](parseInt64),{{#minimum}}
WithMinimum[int64]({{minimum}}),{{/minimum}}{{#maximum}}
WithMaximum[int64]({{maximum}}),{{/maximum}}
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
{{paramName}}Param = {{#isNullable}}&{{/isNullable}}param
} else {
{{#required}}
c.errorHandler(w, r, &RequiredError{Field: "{{baseName}}"}, nil)
return
{{/required}}
{{^required}}
{{#defaultValue}}
var param int64 = {{defaultValue}}
{{paramName}}Param = {{#isNullable}}&{{/isNullable}}param
{{/defaultValue}}
{{/required}}
}
{{/isLong}}
{{#isInteger}}
{{paramName}}Param, err := parseNumericParameter[int32](
query.Get("{{baseName}}"),{{#defaultValue}}
WithDefaultOrParse[int32]({{defaultValue}}, parseInt32),{{/defaultValue}}{{^defaultValue}}{{#required}}
WithRequire[int32](parseInt32),{{/required}}{{/defaultValue}}{{^defaultValue}}{{^required}}
WithParse[int32](parseInt32),{{/required}}{{/defaultValue}}{{#minimum}}
WithMinimum[int32]({{minimum}}),{{/minimum}}{{#maximum}}
WithMaximum[int32]({{maximum}}),{{/maximum}}
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
var {{paramName}}Param {{#isNullable}}*{{/isNullable}}int32
if query.Has("{{baseName}}") {
param, err := parseNumericParameter[int32](
query.Get("{{baseName}}"),
WithParse[int32](parseInt32),{{#minimum}}
WithMinimum[int32]({{minimum}}),{{/minimum}}{{#maximum}}
WithMaximum[int32]({{maximum}}),{{/maximum}}
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
{{paramName}}Param = {{#isNullable}}&{{/isNullable}}param
} else {
{{#required}}
c.errorHandler(w, r, &RequiredError{Field: "{{baseName}}"}, nil)
return
{{/required}}
{{^required}}
{{#defaultValue}}
var param int32 = {{defaultValue}}
{{paramName}}Param = {{#isNullable}}&{{/isNullable}}param
{{/defaultValue}}
{{/required}}
}
{{/isInteger}}
{{#isBoolean}}
{{paramName}}Param, err := parseBoolParameter(
query.Get("{{baseName}}"),{{#defaultValue}}
WithDefaultOrParse[bool]({{defaultValue}}, parseBool),{{/defaultValue}}{{^defaultValue}}{{#required}}
WithRequire[bool](parseBool),{{/required}}{{/defaultValue}}{{^defaultValue}}{{^required}}
WithParse[bool](parseBool),{{/required}}{{/defaultValue}}
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
var {{paramName}}Param {{#isNullable}}*{{/isNullable}}bool
if query.Has("{{baseName}}") {
param, err := parseBoolParameter(
query.Get("{{baseName}}"),
WithParse[bool](parseBool),{{#minimum}}
WithMinimum[bool]({{minimum}}),{{/minimum}}{{#maximum}}
WithMaximum[bool]({{maximum}}),{{/maximum}}
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
{{paramName}}Param = {{#isNullable}}&{{/isNullable}}param
} else {
{{#required}}
c.errorHandler(w, r, &RequiredError{Field: "{{baseName}}"}, nil)
return
{{/required}}
{{^required}}
{{#defaultValue}}
var param bool = {{defaultValue}}
{{paramName}}Param = {{#isNullable}}&{{/isNullable}}param
{{/defaultValue}}
{{/required}}
}
{{/isBoolean}}
{{#isArray}}
@@ -413,46 +500,23 @@ func (c *{{classname}}Controller) {{nickname}}(w http.ResponseWriter, r *http.Re
{{^isBoolean}}
{{^isArray}}
{{^isDateTime}}
{{#defaultValue}}
{{paramName}}Param := "{{defaultValue}}"
var {{paramName}}Param {{#isNullable}}*{{/isNullable}}{{dataType}}
if query.Has("{{baseName}}") {
{{paramName}}Param = {{^isString}}{{dataType}}( {{/isString}}query.Get("{{baseName}}"){{^isString}} ){{/isString}}
}
{{/defaultValue}}
{{^defaultValue}}
{{^required}}
var {{paramName}}Param {{dataType}}
if query.Has("{{baseName}}") {
{{^isEnumRef}}
{{paramName}}Param = query.Get("{{baseName}}")
{{/isEnumRef}}
{{#isEnumRef}}
var err error
{{paramName}}Param, err = New{{dataType}}FromValue(query.Get("{{baseName}}"))
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
{{/isEnumRef}}
}
{{/required}}
{{#required}}
{{^isEnumRef}}
{{paramName}}Param := query.Get("{{baseName}}")
{{/isEnumRef}}
{{#isEnumRef}}
if !query.Has("{{baseName}}"){
c.errorHandler(w, r, &RequiredError{"{{baseName}}"}, nil)
param := {{^isString}}{{dataType}}({{/isString}}query.Get("{{baseName}}"){{^isString}}){{/isString}}
{{paramName}}Param = {{#isNullable}}&{{/isNullable}}param
} else {
{{#required}}
c.errorHandler(w, r, &RequiredError{Field: "{{baseName}}"}, nil)
return
{{/required}}
{{^required}}
{{#defaultValue}}
param := {{^isString}}{{dataType}}({{/isString}}{{defaultValue}}{{^isString}}){{/isString}}
{{paramName}}Param = {{#isNullable}}&{{/isNullable}}param
{{/defaultValue}}
{{/required}}
}
{{paramName}}Param, err := New{{dataType}}FromValue(query.Get("{{baseName}}"))
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
{{/isEnumRef}}
{{/required}}
{{/defaultValue}}
{{/isDateTime}}
{{/isArray}}
{{/isBoolean}}
@@ -464,15 +528,20 @@ func (c *{{classname}}Controller) {{nickname}}(w http.ResponseWriter, r *http.Re
{{/isQueryParam}}
{{#isFormParam}}
{{#isFile}}
var {{paramName}}Param {{#isArray}}[]*os.File{{/isArray}}{{^isArray}}*os.File{{/isArray}}
{
{{#isArray}}
{{paramName}}Param, err := ReadFormFilesToTempFiles(r, "{{baseName}}")
{{/isArray}}
{{^isArray}}
{{paramName}}Param, err := ReadFormFileToTempFile(r, "{{baseName}}")
{{/isArray}}
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
param, err := ReadFormFilesToTempFiles(r, "{{baseName}}")
{{/isArray}}
{{^isArray}}
param, err := ReadFormFileToTempFile(r, "{{baseName}}")
{{/isArray}}
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
{{paramName}}Param = param
}
{{/isFile}}
{{#isLong}}{{#isArray}}
modules/openapi-generator/src/main/resources/go-server/service.mustache
Vendored
+1 -1
View File
@@ -23,7 +23,7 @@ func New{{classname}}Service() {{classname}}Servicer {
{{#isDeprecated}}
// Deprecated
{{/isDeprecated}}
func (s *{{classname}}Service) {{nickname}}(ctx context.Context{{#allParams}}, {{paramName}} {{dataType}}{{/allParams}}) (ImplResponse, error) {
func (s *{{classname}}Service) {{nickname}}(ctx context.Context{{#allParams}}, {{paramName}} {{#isNullable}}*{{/isNullable}}{{dataType}}{{/allParams}}) (ImplResponse, error) {
// TODO - update {{nickname}} with the required logic for this service method.
// Add {{classFilename}}_service.go to the .openapi-generator-ignore to avoid overwriting this service implementation when updating open api generation.
modules/openapi-generator/src/test/resources/3_0/go-server/petstore.yaml
+57
View File
@@ -135,6 +135,53 @@ paths:
security:
- petstore_auth:
- 'read:pets'
/pet/searchPetWithManyFilters:
get:
tags:
- pet
summary: Search Pets by filters
description: >-
Search endpoint
operationId: searchPet
parameters:
- name: age
in: query
description: age of the pet
schema:
type: integer
format: int64
nullable: true
- name: price
in: query
description: Price of the pet
schema:
type: number
nullable: true
- name: bornAfter
in: query
description: Find pets born after this date
style: form
explode: false
schema:
type: string
format: date-time
nullable: true
- description: Is the pet classified as old
in: query
name: old
schema:
type: boolean
nullable: true
style: form
responses:
'200':
description: successful operation
content:
application/xml:
schema:
type: array
items:
$ref: '#/components/schemas/Pet'
/pet/findByTags:
get:
tags:
@@ -173,6 +220,10 @@ paths:
schema:
type: string
format: date-time
- name: colour
in: query
schema:
$ref: '#/components/schemas/Colour'
responses:
'200':
description: successful operation
@@ -1028,6 +1079,12 @@ components:
enum:
- male
- female
Colour:
type: string
nullable: true
enum:
- Blue
- White
ApiResponse:
title: An uploaded response
description: Describes the result of uploading an image resource
samples/openapi3/server/petstore/go/go-petstore/go/api_pet.go
+10 -4
View File
@@ -13,6 +13,7 @@ import (
"encoding/json"
"net/http"
"strings"
"os"
"github.com/go-chi/chi/v5"
)
@@ -270,10 +271,15 @@ func (c *PetAPIController) UploadFile(w http.ResponseWriter, r *http.Request) {
additionalMetadataParam := r.FormValue("additionalMetadata")
fileParam, err := ReadFormFileToTempFile(r, "file")
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
var fileParam *os.File
{
param, err := ReadFormFileToTempFile(r, "file")
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
fileParam = param
}
samples/openapi3/server/petstore/go/go-petstore/go/api_user.go
+94 -42
View File
@@ -178,13 +178,19 @@ func (c *UserAPIController) DeleteUser(w http.ResponseWriter, r *http.Request) {
c.errorHandler(w, r, &RequiredError{"username"}, nil)
return
}
booleanTestParam, err := parseBoolParameter(
query.Get("boolean_test"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
var booleanTestParam bool
if query.Has("boolean_test") {
param, err := parseBoolParameter(
query.Get("boolean_test"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
booleanTestParam = param
} else {
}
result, err := c.service.DeleteUser(r.Context(), usernameParam, booleanTestParam)
// If an error occurred, encode the error with the status code
@@ -216,47 +222,93 @@ func (c *UserAPIController) GetUserByName(w http.ResponseWriter, r *http.Request
// LoginUser - Logs user into the system
func (c *UserAPIController) LoginUser(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query()
usernameParam := query.Get("username")
passwordParam := query.Get("password")
int32TestParam, err := parseNumericParameter[int32](
query.Get("int32_test"),
WithParse[int32](parseInt32),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
var usernameParam string
if query.Has("username") {
param := query.Get("username")
usernameParam = param
} else {
c.errorHandler(w, r, &RequiredError{Field: "username"}, nil)
return
}
int64TestParam, err := parseNumericParameter[int64](
query.Get("int64_test"),
WithParse[int64](parseInt64),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
var passwordParam string
if query.Has("password") {
param := query.Get("password")
passwordParam = param
} else {
c.errorHandler(w, r, &RequiredError{Field: "password"}, nil)
return
}
float32TestParam, err := parseNumericParameter[float32](
query.Get("float32_test"),
WithParse[float32](parseFloat32),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
var int32TestParam int32
if query.Has("int32_test") {
param, err := parseNumericParameter[int32](
query.Get("int32_test"),
WithParse[int32](parseInt32),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
int32TestParam = param
} else {
}
float64TestParam, err := parseNumericParameter[float64](
query.Get("float64_test"),
WithParse[float64](parseFloat64),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
var int64TestParam int64
if query.Has("int64_test") {
param, err := parseNumericParameter[int64](
query.Get("int64_test"),
WithParse[int64](parseInt64),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
int64TestParam = param
} else {
}
booleanTestParam, err := parseBoolParameter(
query.Get("boolean_test"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
var float32TestParam float32
if query.Has("float32_test") {
param, err := parseNumericParameter[float32](
query.Get("float32_test"),
WithParse[float32](parseFloat32),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
float32TestParam = param
} else {
}
var float64TestParam float64
if query.Has("float64_test") {
param, err := parseNumericParameter[float64](
query.Get("float64_test"),
WithParse[float64](parseFloat64),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
float64TestParam = param
} else {
}
var booleanTestParam bool
if query.Has("boolean_test") {
param, err := parseBoolParameter(
query.Get("boolean_test"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
booleanTestParam = param
} else {
}
result, err := c.service.LoginUser(r.Context(), usernameParam, passwordParam, int32TestParam, int64TestParam, float32TestParam, float64TestParam, booleanTestParam)
// If an error occurred, encode the error with the status code
samples/server/petstore/go-api-server/.openapi-generator/FILES
+1
View File
@@ -16,6 +16,7 @@ go/logger.go
go/model_an_object.go
go/model_api_response.go
go/model_category.go
go/model_colour.go
go/model_gender.go
go/model_order.go
go/model_order_info.go
samples/server/petstore/go-api-server/api/openapi.yaml
+68
View File
@@ -143,6 +143,61 @@ paths:
summary: Finds Pets by status
tags:
- pet
/pet/searchPetWithManyFilters:
get:
description: Search endpoint
operationId: searchPet
parameters:
- description: age of the pet
explode: true
in: query
name: age
required: false
schema:
format: int64
nullable: true
type: integer
style: form
- description: Price of the pet
explode: true
in: query
name: price
required: false
schema:
nullable: true
type: number
style: form
- description: Find pets born after this date
explode: false
in: query
name: bornAfter
required: false
schema:
format: date-time
nullable: true
type: string
style: form
- description: Is the pet classified as old
explode: true
in: query
name: old
required: false
schema:
nullable: true
type: boolean
style: form
responses:
"200":
content:
application/xml:
schema:
items:
$ref: '#/components/schemas/Pet'
type: array
description: successful operation
summary: Search Pets by filters
tags:
- pet
/pet/findByTags:
get:
deprecated: true
@@ -178,6 +233,13 @@ paths:
format: date-time
type: string
style: form
- explode: true
in: query
name: colour
required: false
schema:
$ref: '#/components/schemas/Colour'
style: form
responses:
"200":
content:
@@ -1210,6 +1272,12 @@ components:
- male
- female
type: string
Colour:
enum:
- Blue
- White
nullable: true
type: string
ApiResponse:
description: Describes the result of uploading an image resource
example:
samples/server/petstore/go-api-server/go/api.go
+3 -1
View File
@@ -32,6 +32,7 @@ type PetAPIRouter interface {
GetPetImageById(http.ResponseWriter, *http.Request)
GetPetsByTime(http.ResponseWriter, *http.Request)
GetPetsUsingBooleanQueryParameters(http.ResponseWriter, *http.Request)
SearchPet(http.ResponseWriter, *http.Request)
UpdatePet(http.ResponseWriter, *http.Request)
UpdatePetWithForm(http.ResponseWriter, *http.Request)
UploadFile(http.ResponseWriter, *http.Request)
@@ -71,11 +72,12 @@ type PetAPIServicer interface {
FilterPetsByCategory(context.Context, Gender, Species, []Species) (ImplResponse, error)
FindPetsByStatus(context.Context, []string, string, string) (ImplResponse, error)
// Deprecated
FindPetsByTags(context.Context, []string, time.Time, time.Time) (ImplResponse, error)
FindPetsByTags(context.Context, []string, time.Time, time.Time, Colour) (ImplResponse, error)
GetPetById(context.Context, int64) (ImplResponse, error)
GetPetImageById(context.Context, int64) (ImplResponse, error)
GetPetsByTime(context.Context, time.Time) (ImplResponse, error)
GetPetsUsingBooleanQueryParameters(context.Context, bool, bool, bool) (ImplResponse, error)
SearchPet(context.Context, *int64, *float32, *time.Time, *bool) (ImplResponse, error)
UpdatePet(context.Context, Pet) (ImplResponse, error)
UpdatePetWithForm(context.Context, int64, string, string) (ImplResponse, error)
UploadFile(context.Context, int64, string, []string, *os.File) (ImplResponse, error)
samples/server/petstore/go-api-server/go/api_pet.go
+170 -45
View File
@@ -13,6 +13,8 @@ import (
"encoding/json"
"net/http"
"strings"
"time"
"os"
"github.com/gorilla/mux"
)
@@ -95,6 +97,11 @@ func (c *PetAPIController) Routes() Routes {
"/v2/pets/boolean/parsing",
c.GetPetsUsingBooleanQueryParameters,
},
"SearchPet": Route{
strings.ToUpper("Get"),
"/v2/pet/searchPetWithManyFilters",
c.SearchPet,
},
"UpdatePet": Route{
strings.ToUpper("Put"),
"/v2/pet",
@@ -176,13 +183,13 @@ func (c *PetAPIController) FilterPetsByCategory(w http.ResponseWriter, r *http.R
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
if !query.Has("species"){
c.errorHandler(w, r, &RequiredError{"species"}, nil)
return
}
speciesParam, err := NewSpeciesFromValue(query.Get("species"))
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
var speciesParam Species
if query.Has("species") {
param := Species(query.Get("species"))
speciesParam = param
} else {
c.errorHandler(w, r, &RequiredError{Field: "species"}, nil)
return
}
var notSpeciesParam []Species
@@ -223,7 +230,10 @@ func (c *PetAPIController) FindPetsByStatus(w http.ResponseWriter, r *http.Reque
}
var inlineEnumParam string
if query.Has("inlineEnum") {
inlineEnumParam = query.Get("inlineEnum")
param := query.Get("inlineEnum")
inlineEnumParam = param
} else {
}
result, err := c.service.FindPetsByStatus(r.Context(), statusParam, inlineEnumPathParam, inlineEnumParam)
// If an error occurred, encode the error with the status code
@@ -243,21 +253,38 @@ func (c *PetAPIController) FindPetsByTags(w http.ResponseWriter, r *http.Request
if query.Has("tags") {
tagsParam = strings.Split(query.Get("tags"), ",")
}
if !query.Has("bornAfter"){
var bornAfterParam time.Time
if query.Has("bornAfter"){
param, err := parseTime(query.Get("bornAfter"))
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
bornAfterParam = param
} else {
c.errorHandler(w, r, &RequiredError{"bornAfter"}, nil)
return
}
bornAfterParam, err := parseTime(query.Get("bornAfter"))
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
bornBeforeParam, err := parseTime(query.Get("bornBefore"))
if err != nil {
var bornBeforeParam time.Time
if query.Has("bornBefore"){
param, err := parseTime(query.Get("bornBefore"))
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
bornBeforeParam = param
} else {
}
result, err := c.service.FindPetsByTags(r.Context(), tagsParam, bornAfterParam, bornBeforeParam)
var colourParam Colour
if query.Has("colour") {
param := Colour(query.Get("colour"))
colourParam = param
} else {
}
result, err := c.service.FindPetsByTags(r.Context(), tagsParam, bornAfterParam, bornBeforeParam, colourParam)
// If an error occurred, encode the error with the status code
if err != nil {
c.errorHandler(w, r, err, &result)
@@ -330,29 +357,51 @@ func (c *PetAPIController) GetPetsByTime(w http.ResponseWriter, r *http.Request)
// GetPetsUsingBooleanQueryParameters - Get the pets by only using boolean query parameters
func (c *PetAPIController) GetPetsUsingBooleanQueryParameters(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query()
exprParam, err := parseBoolParameter(
query.Get("expr"),
WithRequire[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
var exprParam bool
if query.Has("expr") {
param, err := parseBoolParameter(
query.Get("expr"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
exprParam = param
} else {
c.errorHandler(w, r, &RequiredError{Field: "expr"}, nil)
return
}
groupingParam, err := parseBoolParameter(
query.Get("grouping"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
var groupingParam bool
if query.Has("grouping") {
param, err := parseBoolParameter(
query.Get("grouping"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
groupingParam = param
} else {
}
inactiveParam, err := parseBoolParameter(
query.Get("inactive"),
WithDefaultOrParse[bool](false, parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
var inactiveParam bool
if query.Has("inactive") {
param, err := parseBoolParameter(
query.Get("inactive"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
inactiveParam = param
} else {
var param bool = false
inactiveParam = param
}
result, err := c.service.GetPetsUsingBooleanQueryParameters(r.Context(), exprParam, groupingParam, inactiveParam)
// If an error occurred, encode the error with the status code
@@ -364,6 +413,72 @@ func (c *PetAPIController) GetPetsUsingBooleanQueryParameters(w http.ResponseWri
EncodeJSONResponse(result.Body, &result.Code, result.Headers, w)
}
// SearchPet - Search Pets by filters
func (c *PetAPIController) SearchPet(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query()
var ageParam *int64
if query.Has("age") {
param, err := parseNumericParameter[int64](
query.Get("age"),
WithParse[int64](parseInt64),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
ageParam = &param
} else {
}
var priceParam *float32
if query.Has("price") {
param, err := parseNumericParameter[float32](
query.Get("price"),
WithParse[float32](parseFloat32),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
priceParam = &param
} else {
}
var bornAfterParam *time.Time
if query.Has("bornAfter"){
param, err := parseTime(query.Get("bornAfter"))
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
bornAfterParam = &param
} else {
}
var oldParam *bool
if query.Has("old") {
param, err := parseBoolParameter(
query.Get("old"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
oldParam = &param
} else {
}
result, err := c.service.SearchPet(r.Context(), ageParam, priceParam, bornAfterParam, oldParam)
// If an error occurred, encode the error with the status code
if err != nil {
c.errorHandler(w, r, err, &result)
return
}
// If no error, encode the body and the result code
EncodeJSONResponse(result.Body, &result.Code, result.Headers, w)
}
// UpdatePet - Update an existing pet
func (c *PetAPIController) UpdatePet(w http.ResponseWriter, r *http.Request) {
petParam := Pet{}
@@ -443,10 +558,15 @@ func (c *PetAPIController) UploadFile(w http.ResponseWriter, r *http.Request) {
extraOptionalMetadataParam := strings.Split(r.FormValue("extraOptionalMetadata"), ",")
fileParam, err := ReadFormFileToTempFile(r, "file")
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
var fileParam *os.File
{
param, err := ReadFormFileToTempFile(r, "file")
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
fileParam = param
}
@@ -478,10 +598,15 @@ func (c *PetAPIController) UploadFileArrayOfFiles(w http.ResponseWriter, r *http
additionalMetadataParam := r.FormValue("additionalMetadata")
filesParam, err := ReadFormFilesToTempFiles(r, "files")
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
var filesParam []*os.File
{
param, err := ReadFormFilesToTempFiles(r, "files")
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
filesParam = param
}
samples/server/petstore/go-api-server/go/api_pet_service.go
+12 -1
View File
@@ -83,7 +83,7 @@ func (s *PetAPIService) FindPetsByStatus(ctx context.Context, status []string, i
// FindPetsByTags - Finds Pets by tags
// Deprecated
func (s *PetAPIService) FindPetsByTags(ctx context.Context, tags []string, bornAfter time.Time, bornBefore time.Time) (ImplResponse, error) {
func (s *PetAPIService) FindPetsByTags(ctx context.Context, tags []string, bornAfter time.Time, bornBefore time.Time, colour Colour) (ImplResponse, error) {
// TODO - update FindPetsByTags with the required logic for this service method.
// Add api_pet_service.go to the .openapi-generator-ignore to avoid overwriting this service implementation when updating open api generation.
@@ -152,6 +152,17 @@ func (s *PetAPIService) GetPetsUsingBooleanQueryParameters(ctx context.Context,
return Response(http.StatusNotImplemented, nil), errors.New("GetPetsUsingBooleanQueryParameters method not implemented")
}
// SearchPet - Search Pets by filters
func (s *PetAPIService) SearchPet(ctx context.Context, age *int64, price *float32, bornAfter *time.Time, old *bool) (ImplResponse, error) {
// TODO - update SearchPet with the required logic for this service method.
// Add api_pet_service.go to the .openapi-generator-ignore to avoid overwriting this service implementation when updating open api generation.
// TODO: Uncomment the next line to return response Response(200, []Pet{}) or use other options such as http.Ok ...
// return Response(200, []Pet{}), nil
return Response(http.StatusNotImplemented, nil), errors.New("SearchPet method not implemented")
}
// UpdatePet - Update an existing pet
func (s *PetAPIService) UpdatePet(ctx context.Context, pet Pet) (ImplResponse, error) {
// TODO - update UpdatePet with the required logic for this service method.
samples/server/petstore/go-api-server/go/api_user.go
+43 -15
View File
@@ -179,13 +179,19 @@ func (c *UserAPIController) DeleteUser(w http.ResponseWriter, r *http.Request) {
c.errorHandler(w, r, &RequiredError{"username"}, nil)
return
}
booleanTestParam, err := parseBoolParameter(
query.Get("boolean_test"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
var booleanTestParam bool
if query.Has("boolean_test") {
param, err := parseBoolParameter(
query.Get("boolean_test"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
booleanTestParam = param
} else {
}
result, err := c.service.DeleteUser(r.Context(), usernameParam, booleanTestParam)
// If an error occurred, encode the error with the status code
@@ -218,16 +224,38 @@ func (c *UserAPIController) GetUserByName(w http.ResponseWriter, r *http.Request
// LoginUser - Logs user into the system
func (c *UserAPIController) LoginUser(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query()
usernameParam := query.Get("username")
passwordParam := query.Get("password")
booleanTestParam, err := parseBoolParameter(
query.Get("boolean_test"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
var usernameParam string
if query.Has("username") {
param := query.Get("username")
usernameParam = param
} else {
c.errorHandler(w, r, &RequiredError{Field: "username"}, nil)
return
}
var passwordParam string
if query.Has("password") {
param := query.Get("password")
passwordParam = param
} else {
c.errorHandler(w, r, &RequiredError{Field: "password"}, nil)
return
}
var booleanTestParam bool
if query.Has("boolean_test") {
param, err := parseBoolParameter(
query.Get("boolean_test"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
booleanTestParam = param
} else {
}
result, err := c.service.LoginUser(r.Context(), usernameParam, passwordParam, booleanTestParam)
// If an error occurred, encode the error with the status code
if err != nil {
samples/server/petstore/go-api-server/go/model_colour.go
+66
View File
@@ -0,0 +1,66 @@
/*
* OpenAPI Petstore
*
* This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
*
* API version: 1.0.0
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
*/
package petstoreserver
import (
"fmt"
)
type Colour string
// List of Colour
const (
BLUE Colour = "Blue"
WHITE Colour = "White"
)
// AllowedColourEnumValues is all the allowed values of Colour enum
var AllowedColourEnumValues = []Colour{
"Blue",
"White",
}
// validColourEnumValue provides a map of Colours for fast verification of use input
var validColourEnumValues = map[Colour]struct{}{
"Blue": {},
"White": {},
}
// IsValid return true if the value is valid for the enum, false otherwise
func (v Colour) IsValid() bool {
_, ok := validColourEnumValues[v]
return ok
}
// NewColourFromValue returns a pointer to a valid Colour
// for the value passed as argument, or an error if the value passed is not allowed by the enum
func NewColourFromValue(v string) (Colour, error) {
ev := Colour(v)
if ev.IsValid() {
return ev, nil
} else {
return "", fmt.Errorf("invalid value '%v' for Colour: valid values are %v", v, AllowedColourEnumValues)
}
}
// AssertColourRequired checks if the required fields are not zero-ed
func AssertColourRequired(obj Colour) error {
return nil
}
// AssertColourConstraints checks if the values respects the defined constraints
func AssertColourConstraints(obj Colour) error {
return nil
}
samples/server/petstore/go-chi-server/.openapi-generator/FILES
+1
View File
@@ -16,6 +16,7 @@ go/logger.go
go/model_an_object.go
go/model_api_response.go
go/model_category.go
go/model_colour.go
go/model_gender.go
go/model_order.go
go/model_order_info.go
samples/server/petstore/go-chi-server/api/openapi.yaml
+68
View File
@@ -143,6 +143,61 @@ paths:
summary: Finds Pets by status
tags:
- pet
/pet/searchPetWithManyFilters:
get:
description: Search endpoint
operationId: searchPet
parameters:
- description: age of the pet
explode: true
in: query
name: age
required: false
schema:
format: int64
nullable: true
type: integer
style: form
- description: Price of the pet
explode: true
in: query
name: price
required: false
schema:
nullable: true
type: number
style: form
- description: Find pets born after this date
explode: false
in: query
name: bornAfter
required: false
schema:
format: date-time
nullable: true
type: string
style: form
- description: Is the pet classified as old
explode: true
in: query
name: old
required: false
schema:
nullable: true
type: boolean
style: form
responses:
"200":
content:
application/xml:
schema:
items:
$ref: '#/components/schemas/Pet'
type: array
description: successful operation
summary: Search Pets by filters
tags:
- pet
/pet/findByTags:
get:
deprecated: true
@@ -178,6 +233,13 @@ paths:
format: date-time
type: string
style: form
- explode: true
in: query
name: colour
required: false
schema:
$ref: '#/components/schemas/Colour'
style: form
responses:
"200":
content:
@@ -1210,6 +1272,12 @@ components:
- male
- female
type: string
Colour:
enum:
- Blue
- White
nullable: true
type: string
ApiResponse:
description: Describes the result of uploading an image resource
example:
samples/server/petstore/go-chi-server/go/api.go
+3 -1
View File
@@ -32,6 +32,7 @@ type PetAPIRouter interface {
GetPetImageById(http.ResponseWriter, *http.Request)
GetPetsByTime(http.ResponseWriter, *http.Request)
GetPetsUsingBooleanQueryParameters(http.ResponseWriter, *http.Request)
SearchPet(http.ResponseWriter, *http.Request)
UpdatePet(http.ResponseWriter, *http.Request)
UpdatePetWithForm(http.ResponseWriter, *http.Request)
UploadFile(http.ResponseWriter, *http.Request)
@@ -71,11 +72,12 @@ type PetAPIServicer interface {
FilterPetsByCategory(context.Context, Gender, Species, []Species) (ImplResponse, error)
FindPetsByStatus(context.Context, []string, string, string) (ImplResponse, error)
// Deprecated
FindPetsByTags(context.Context, []string, time.Time, time.Time) (ImplResponse, error)
FindPetsByTags(context.Context, []string, time.Time, time.Time, Colour) (ImplResponse, error)
GetPetById(context.Context, int64) (ImplResponse, error)
GetPetImageById(context.Context, int64) (ImplResponse, error)
GetPetsByTime(context.Context, time.Time) (ImplResponse, error)
GetPetsUsingBooleanQueryParameters(context.Context, bool, bool, bool) (ImplResponse, error)
SearchPet(context.Context, *int64, *float32, *time.Time, *bool) (ImplResponse, error)
UpdatePet(context.Context, Pet) (ImplResponse, error)
UpdatePetWithForm(context.Context, int64, string, string) (ImplResponse, error)
UploadFile(context.Context, int64, string, []string, *os.File) (ImplResponse, error)
samples/server/petstore/go-chi-server/go/api_pet.go
+170 -45
View File
@@ -13,6 +13,8 @@ import (
"encoding/json"
"net/http"
"strings"
"time"
"os"
"github.com/go-chi/chi/v5"
)
@@ -95,6 +97,11 @@ func (c *PetAPIController) Routes() Routes {
"/v2/pets/boolean/parsing",
c.GetPetsUsingBooleanQueryParameters,
},
"SearchPet": Route{
strings.ToUpper("Get"),
"/v2/pet/searchPetWithManyFilters",
c.SearchPet,
},
"UpdatePet": Route{
strings.ToUpper("Put"),
"/v2/pet",
@@ -174,13 +181,13 @@ func (c *PetAPIController) FilterPetsByCategory(w http.ResponseWriter, r *http.R
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
if !query.Has("species"){
c.errorHandler(w, r, &RequiredError{"species"}, nil)
return
}
speciesParam, err := NewSpeciesFromValue(query.Get("species"))
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
var speciesParam Species
if query.Has("species") {
param := Species(query.Get("species"))
speciesParam = param
} else {
c.errorHandler(w, r, &RequiredError{Field: "species"}, nil)
return
}
var notSpeciesParam []Species
@@ -220,7 +227,10 @@ func (c *PetAPIController) FindPetsByStatus(w http.ResponseWriter, r *http.Reque
}
var inlineEnumParam string
if query.Has("inlineEnum") {
inlineEnumParam = query.Get("inlineEnum")
param := query.Get("inlineEnum")
inlineEnumParam = param
} else {
}
result, err := c.service.FindPetsByStatus(r.Context(), statusParam, inlineEnumPathParam, inlineEnumParam)
// If an error occurred, encode the error with the status code
@@ -240,21 +250,38 @@ func (c *PetAPIController) FindPetsByTags(w http.ResponseWriter, r *http.Request
if query.Has("tags") {
tagsParam = strings.Split(query.Get("tags"), ",")
}
if !query.Has("bornAfter"){
var bornAfterParam time.Time
if query.Has("bornAfter"){
param, err := parseTime(query.Get("bornAfter"))
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
bornAfterParam = param
} else {
c.errorHandler(w, r, &RequiredError{"bornAfter"}, nil)
return
}
bornAfterParam, err := parseTime(query.Get("bornAfter"))
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
bornBeforeParam, err := parseTime(query.Get("bornBefore"))
if err != nil {
var bornBeforeParam time.Time
if query.Has("bornBefore"){
param, err := parseTime(query.Get("bornBefore"))
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
bornBeforeParam = param
} else {
}
result, err := c.service.FindPetsByTags(r.Context(), tagsParam, bornAfterParam, bornBeforeParam)
var colourParam Colour
if query.Has("colour") {
param := Colour(query.Get("colour"))
colourParam = param
} else {
}
result, err := c.service.FindPetsByTags(r.Context(), tagsParam, bornAfterParam, bornBeforeParam, colourParam)
// If an error occurred, encode the error with the status code
if err != nil {
c.errorHandler(w, r, err, &result)
@@ -324,29 +351,51 @@ func (c *PetAPIController) GetPetsByTime(w http.ResponseWriter, r *http.Request)
// GetPetsUsingBooleanQueryParameters - Get the pets by only using boolean query parameters
func (c *PetAPIController) GetPetsUsingBooleanQueryParameters(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query()
exprParam, err := parseBoolParameter(
query.Get("expr"),
WithRequire[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
var exprParam bool
if query.Has("expr") {
param, err := parseBoolParameter(
query.Get("expr"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
exprParam = param
} else {
c.errorHandler(w, r, &RequiredError{Field: "expr"}, nil)
return
}
groupingParam, err := parseBoolParameter(
query.Get("grouping"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
var groupingParam bool
if query.Has("grouping") {
param, err := parseBoolParameter(
query.Get("grouping"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
groupingParam = param
} else {
}
inactiveParam, err := parseBoolParameter(
query.Get("inactive"),
WithDefaultOrParse[bool](false, parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
var inactiveParam bool
if query.Has("inactive") {
param, err := parseBoolParameter(
query.Get("inactive"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
inactiveParam = param
} else {
var param bool = false
inactiveParam = param
}
result, err := c.service.GetPetsUsingBooleanQueryParameters(r.Context(), exprParam, groupingParam, inactiveParam)
// If an error occurred, encode the error with the status code
@@ -358,6 +407,72 @@ func (c *PetAPIController) GetPetsUsingBooleanQueryParameters(w http.ResponseWri
EncodeJSONResponse(result.Body, &result.Code, result.Headers, w)
}
// SearchPet - Search Pets by filters
func (c *PetAPIController) SearchPet(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query()
var ageParam *int64
if query.Has("age") {
param, err := parseNumericParameter[int64](
query.Get("age"),
WithParse[int64](parseInt64),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
ageParam = &param
} else {
}
var priceParam *float32
if query.Has("price") {
param, err := parseNumericParameter[float32](
query.Get("price"),
WithParse[float32](parseFloat32),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
priceParam = &param
} else {
}
var bornAfterParam *time.Time
if query.Has("bornAfter"){
param, err := parseTime(query.Get("bornAfter"))
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
bornAfterParam = &param
} else {
}
var oldParam *bool
if query.Has("old") {
param, err := parseBoolParameter(
query.Get("old"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
oldParam = &param
} else {
}
result, err := c.service.SearchPet(r.Context(), ageParam, priceParam, bornAfterParam, oldParam)
// If an error occurred, encode the error with the status code
if err != nil {
c.errorHandler(w, r, err, &result)
return
}
// If no error, encode the body and the result code
EncodeJSONResponse(result.Body, &result.Code, result.Headers, w)
}
// UpdatePet - Update an existing pet
func (c *PetAPIController) UpdatePet(w http.ResponseWriter, r *http.Request) {
petParam := Pet{}
@@ -435,10 +550,15 @@ func (c *PetAPIController) UploadFile(w http.ResponseWriter, r *http.Request) {
extraOptionalMetadataParam := strings.Split(r.FormValue("extraOptionalMetadata"), ",")
fileParam, err := ReadFormFileToTempFile(r, "file")
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
var fileParam *os.File
{
param, err := ReadFormFileToTempFile(r, "file")
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
fileParam = param
}
@@ -469,10 +589,15 @@ func (c *PetAPIController) UploadFileArrayOfFiles(w http.ResponseWriter, r *http
additionalMetadataParam := r.FormValue("additionalMetadata")
filesParam, err := ReadFormFilesToTempFiles(r, "files")
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
var filesParam []*os.File
{
param, err := ReadFormFilesToTempFiles(r, "files")
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
filesParam = param
}
samples/server/petstore/go-chi-server/go/api_pet_service.go
+12 -1
View File
@@ -83,7 +83,7 @@ func (s *PetAPIService) FindPetsByStatus(ctx context.Context, status []string, i
// FindPetsByTags - Finds Pets by tags
// Deprecated
func (s *PetAPIService) FindPetsByTags(ctx context.Context, tags []string, bornAfter time.Time, bornBefore time.Time) (ImplResponse, error) {
func (s *PetAPIService) FindPetsByTags(ctx context.Context, tags []string, bornAfter time.Time, bornBefore time.Time, colour Colour) (ImplResponse, error) {
// TODO - update FindPetsByTags with the required logic for this service method.
// Add api_pet_service.go to the .openapi-generator-ignore to avoid overwriting this service implementation when updating open api generation.
@@ -152,6 +152,17 @@ func (s *PetAPIService) GetPetsUsingBooleanQueryParameters(ctx context.Context,
return Response(http.StatusNotImplemented, nil), errors.New("GetPetsUsingBooleanQueryParameters method not implemented")
}
// SearchPet - Search Pets by filters
func (s *PetAPIService) SearchPet(ctx context.Context, age *int64, price *float32, bornAfter *time.Time, old *bool) (ImplResponse, error) {
// TODO - update SearchPet with the required logic for this service method.
// Add api_pet_service.go to the .openapi-generator-ignore to avoid overwriting this service implementation when updating open api generation.
// TODO: Uncomment the next line to return response Response(200, []Pet{}) or use other options such as http.Ok ...
// return Response(200, []Pet{}), nil
return Response(http.StatusNotImplemented, nil), errors.New("SearchPet method not implemented")
}
// UpdatePet - Update an existing pet
func (s *PetAPIService) UpdatePet(ctx context.Context, pet Pet) (ImplResponse, error) {
// TODO - update UpdatePet with the required logic for this service method.
samples/server/petstore/go-chi-server/go/api_user.go
+43 -15
View File
@@ -178,13 +178,19 @@ func (c *UserAPIController) DeleteUser(w http.ResponseWriter, r *http.Request) {
c.errorHandler(w, r, &RequiredError{"username"}, nil)
return
}
booleanTestParam, err := parseBoolParameter(
query.Get("boolean_test"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
var booleanTestParam bool
if query.Has("boolean_test") {
param, err := parseBoolParameter(
query.Get("boolean_test"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
booleanTestParam = param
} else {
}
result, err := c.service.DeleteUser(r.Context(), usernameParam, booleanTestParam)
// If an error occurred, encode the error with the status code
@@ -216,16 +222,38 @@ func (c *UserAPIController) GetUserByName(w http.ResponseWriter, r *http.Request
// LoginUser - Logs user into the system
func (c *UserAPIController) LoginUser(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query()
usernameParam := query.Get("username")
passwordParam := query.Get("password")
booleanTestParam, err := parseBoolParameter(
query.Get("boolean_test"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
var usernameParam string
if query.Has("username") {
param := query.Get("username")
usernameParam = param
} else {
c.errorHandler(w, r, &RequiredError{Field: "username"}, nil)
return
}
var passwordParam string
if query.Has("password") {
param := query.Get("password")
passwordParam = param
} else {
c.errorHandler(w, r, &RequiredError{Field: "password"}, nil)
return
}
var booleanTestParam bool
if query.Has("boolean_test") {
param, err := parseBoolParameter(
query.Get("boolean_test"),
WithParse[bool](parseBool),
)
if err != nil {
c.errorHandler(w, r, &ParsingError{Err: err}, nil)
return
}
booleanTestParam = param
} else {
}
result, err := c.service.LoginUser(r.Context(), usernameParam, passwordParam, booleanTestParam)
// If an error occurred, encode the error with the status code
if err != nil {
samples/server/petstore/go-chi-server/go/model_colour.go
+66
View File
@@ -0,0 +1,66 @@
/*
* OpenAPI Petstore
*
* This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
*
* API version: 1.0.0
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
*/
package petstoreserver
import (
"fmt"
)
type Colour string
// List of Colour
const (
BLUE Colour = "Blue"
WHITE Colour = "White"
)
// AllowedColourEnumValues is all the allowed values of Colour enum
var AllowedColourEnumValues = []Colour{
"Blue",
"White",
}
// validColourEnumValue provides a map of Colours for fast verification of use input
var validColourEnumValues = map[Colour]struct{}{
"Blue": {},
"White": {},
}
// IsValid return true if the value is valid for the enum, false otherwise
func (v Colour) IsValid() bool {
_, ok := validColourEnumValues[v]
return ok
}
// NewColourFromValue returns a pointer to a valid Colour
// for the value passed as argument, or an error if the value passed is not allowed by the enum
func NewColourFromValue(v string) (Colour, error) {
ev := Colour(v)
if ev.IsValid() {
return ev, nil
} else {
return "", fmt.Errorf("invalid value '%v' for Colour: valid values are %v", v, AllowedColourEnumValues)
}
}
// AssertColourRequired checks if the required fields are not zero-ed
func AssertColourRequired(obj Colour) error {
return nil
}
// AssertColourConstraints checks if the values respects the defined constraints
func AssertColourConstraints(obj Colour) error {
return nil
}