Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

[go-server] Support min/max/defaults for values #15185

Merged
merged 7 commits into from
May 16, 2023
Merged

[go-server] Support min/max/defaults for values #15185

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
e618103
[go-server] Support min/max/defaults for values
rledisez Apr 11, 2023
a344458
Fix merge conflict
rledisez Apr 25, 2023
9ae50ad
Improve UnmarshalJSON implementation
rledisez Apr 25, 2023
5830df3
Improve default value handling for string
rledisez Apr 25, 2023
f059233
Fix suggested changes
rledisez Apr 25, 2023
30db221
rework option pattern
rledisez Apr 25, 2023
1eeee18
add imports based on types/min max values
rledisez Apr 26, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
66 changes: 59 additions & 7 deletions ...s/openapi-generator/src/main/java/org/openapitools/codegen/languages/GoServerCodegen.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,19 +17,39 @@

package org.openapitools.codegen.languages;

import io.swagger.v3.oas.models.media.ComposedSchema;
import io.swagger.v3.oas.models.media.Schema;
import org.openapitools.codegen.*;
import org.openapitools.codegen.meta.features.*;
import java.io.File;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.openapitools.codegen.CliOption;
import org.openapitools.codegen.CodegenConstants;
import org.openapitools.codegen.CodegenModel;
import org.openapitools.codegen.CodegenOperation;
import org.openapitools.codegen.CodegenParameter;
import org.openapitools.codegen.CodegenProperty;
import org.openapitools.codegen.CodegenType;
import org.openapitools.codegen.SupportingFile;
import org.openapitools.codegen.meta.features.DocumentationFeature;
import org.openapitools.codegen.meta.features.GlobalFeature;
import org.openapitools.codegen.meta.features.ParameterFeature;
import org.openapitools.codegen.meta.features.SchemaSupportFeature;
import org.openapitools.codegen.meta.features.SecurityFeature;
import org.openapitools.codegen.meta.features.WireFormatFeature;
import org.openapitools.codegen.model.ModelMap;
import org.openapitools.codegen.model.ModelsMap;
import org.openapitools.codegen.model.OperationMap;
import org.openapitools.codegen.model.OperationsMap;
import org.openapitools.codegen.utils.ModelUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.util.*;
import com.google.common.collect.Iterables;

import io.swagger.v3.oas.models.media.ComposedSchema;
import io.swagger.v3.oas.models.media.Schema;

public class GoServerCodegen extends AbstractGoCodegen {

Expand Down Expand Up @@ -114,7 +134,7 @@ public GoServerCodegen() {
optAddResponseHeaders.defaultValue(addResponseHeaders.toString());
cliOptions.add(optAddResponseHeaders);


// option to exclude service factories; only interfaces are rendered
CliOption optOnlyInterfaces = new CliOption("onlyInterfaces", "Exclude default service creators from output; only generate interfaces");
optOnlyInterfaces.setType("bool");
Expand Down Expand Up @@ -287,6 +307,38 @@ public void processOpts() {
.doNotOverwrite());
}

@Override
public ModelsMap postProcessModels(ModelsMap objs) {
// The superclass determines the list of required golang imports. The actual list of imports
// depends on which types are used. So super.postProcessModels must be invoked at the beginning
// of this method.
objs = super.postProcessModels(objs);

List<Map<String, String>> imports = objs.getImports();

for (ModelMap m : objs.getModels()) {
imports.add(createMapping("import", "encoding/json"));

CodegenModel model = m.getModel();
if (model.isEnum) {
continue;
}

Boolean importErrors = false;

for (CodegenProperty param : Iterables.concat(model.vars, model.allVars, model.requiredVars, model.optionalVars)) {
if (param.isNumeric && ((param.minimum != null && param.minimum != "") || (param.maximum != null && param.maximum != ""))) {
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@rledisez I've filed #15589 to fix the string comparison.

importErrors = true;
}
}

if (importErrors) {
imports.add(createMapping("import", "errors"));
}
}
return objs;
}

@Override
public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<ModelMap> allModels) {
objs = super.postProcessOperationsWithModels(objs, allModels);
Expand Down
166 changes: 143 additions & 23 deletions modules/openapi-generator/src/main/resources/go-server/controller-api.mustache
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -93,35 +93,70 @@ func (c *{{classname}}Controller) {{nickname}}(w http.ResponseWriter, r *http.Re
{{#allParams}}
{{#isPathParam}}
{{#isNumber}}
{{paramName}}Param, err := parseFloat32Parameter({{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}}, {{required}})
if err != nil {
{{paramName}}Param, err := parseNumericParameter[float32](
{{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}},{{#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)
return
}
{{/isNumber}}
{{#isFloat}}
{{paramName}}Param, err := parseFloat32Parameter({{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}}, {{required}})
{{paramName}}Param, err := parseNumericParameter[float32](
{{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}},{{#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)
return
}
{{/isFloat}}
{{#isDouble}}
{{paramName}}Param, err := parseFloat64Parameter({{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}}, {{required}})
{{paramName}}Param, err := parseNumericParameter[float64](
{{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}},{{#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)
return
}
{{/isDouble}}
{{#isLong}}
{{paramName}}Param, err := parseInt64Parameter({{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}}, {{required}})
{{paramName}}Param, err := parseNumericParameter[int64](
{{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}},{{#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)
return
}
{{/isLong}}
{{#isInteger}}
{{paramName}}Param, err := parseInt32Parameter({{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}}, {{required}})
{{paramName}}Param, err := parseNumericParameter[int32](
{{#routers}}{{#mux}}params["{{baseName}}"]{{/mux}}{{#chi}}chi.URLParam(r, "{{baseName}}"){{/chi}}{{/routers}},{{#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)
return
Expand All @@ -141,78 +176,143 @@ func (c *{{classname}}Controller) {{nickname}}(w http.ResponseWriter, r *http.Re
{{/isPathParam}}
{{#isQueryParam}}
{{#isNumber}}
{{paramName}}Param, err := parseFloat32Parameter(query.Get("{{baseName}}"), {{required}})
{{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)
return
}
{{/isNumber}}
{{#isFloat}}
{{paramName}}Param, err := parseFloat32Parameter(query.Get("{{baseName}}"), {{required}})
{{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)
return
}
{{/isFloat}}
{{#isDouble}}
{{paramName}}Param, err := parseFloat64Parameter(query.Get("{{baseName}}"), {{required}})
{{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)
return
}
{{/isDouble}}
{{#isLong}}
{{paramName}}Param, err := parseInt64Parameter(query.Get("{{baseName}}"), {{required}})
{{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)
return
}
{{/isLong}}
{{#isInteger}}
{{paramName}}Param, err := parseInt32Parameter(query.Get("{{baseName}}"), {{required}})
{{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)
return
}
{{/isInteger}}
{{#isBoolean}}
{{paramName}}Param, err := parseBoolParameter(query.Get("{{baseName}}"), {{required}})
{{paramName}}Param, err := parseBoolParameter(
query.Get("{{baseName}}"),{{#defaultValue}}
WithDefaultOrParse[bool]({{defaultValue}}, parseBool),{{/defaultValue}}{{^defaultValue}}{{#required}}
WithRequire[bool](parseBool),{{/required}}{{/defaultValue}}{{^defaultValue}}{{^required}}
WithParse[float32](parseBool),{{/required}}{{/defaultValue}}
)
if err != nil {
w.WriteHeader(500)
return
}
{{/isBoolean}}
{{#isArray}}
{{#items.isNumber}}
{{paramName}}Param, err := parseFloat32ArrayParameter(query.Get("{{baseName}}"), {{required}})
{{paramName}}Param, err := parseNumericArrayParameter[float32](
query.Get("{{baseName}}"), ",", {{required}},
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
}
{{/items.isNumber}}
{{#items.isFloat}}
{{paramName}}Param, err := parseFloat32ArrayParameter(query.Get("{{baseName}}"), {{required}})
{{paramName}}Param, err := parseNumericArrayParameter[float32](
query.Get("{{baseName}}"), ",", {{required}},
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
}
{{/items.isFloat}}
{{#items.isDouble}}
{{paramName}}Param, err := parseFloat64ArrayParameter(query.Get("{{baseName}}"), {{required}})
{{paramName}}Param, err := parseNumericArrayParameter[float64](
query.Get("{{baseName}}"), ",", {{required}},
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
}
{{/items.isDouble}}
{{#items.isLong}}
{{paramName}}Param, err := parseInt64ArrayParameter(query.Get("{{baseName}}"), ",", {{required}})
{{paramName}}Param, err := parseNumericArrayParameter[int64](
query.Get("{{baseName}}"), ",", {{required}},
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
}
{{/items.isLong}}
{{#items.isInteger}}
{{paramName}}Param, err := parseInt32ArrayParameter(query.Get("{{baseName}}"), ",", {{required}})
{{paramName}}Param, err := parseNumericArrayParameter[int32](
query.Get("{{baseName}}"), ",", {{required}},
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
Expand All @@ -237,7 +337,15 @@ func (c *{{classname}}Controller) {{nickname}}(w http.ResponseWriter, r *http.Re
{{^isInteger}}
{{^isBoolean}}
{{^isArray}}
{{#defaultValue}}
{{paramName}}Param := "{{defaultValue}}"
if query.Has("{{baseName}}") {
{{paramName}}Param = query.Get("{{baseName}}")
}
{{/defaultValue}}
{{^defaultValue}}
{{paramName}}Param := query.Get("{{baseName}}")
{{/defaultValue}}
{{/isArray}}
{{/isBoolean}}
{{/isInteger}}
Expand All @@ -257,21 +365,29 @@ func (c *{{classname}}Controller) {{nickname}}(w http.ResponseWriter, r *http.Re
}
{{/isFile}}
{{#isLong}}{{#isArray}}
{{paramName}}Param, err := parseInt64ArrayParameter(r.FormValue("{{baseName}}"), ",", {{required}}){{/isArray}}{{^isArray}}
{{paramName}}Param, err := parseInt64Parameter(r.FormValue("{{baseName}}"), {{required}}){{/isArray}}
{{paramName}}Param, err := parseNumericArrayParameter[int64](
r.FormValue("{{baseName}}"), ",", {{required}},
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
}
{{/isLong}}
{{/isArray}}{{/isLong}}
{{#isInteger}}{{#isArray}}
{{paramName}}Param, err := parseInt32ArrayParameter(r.FormValue("{{baseName}}"), ",", {{required}}){{/isArray}}{{^isArray}}
{{paramName}}Param, err := parseInt32Parameter(r.FormValue("{{baseName}}"), {{required}}){{/isArray}}
{{paramName}}Param, err := parseNumericArrayParameter[int32](
r.FormValue("{{baseName}}"), ",", {{required}},
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
}
{{/isInteger}}
{{/isArray}}{{/isInteger}}
{{^isFile}}
{{^isLong}}
{{paramName}}Param := r.FormValue("{{baseName}}")
Expand Down Expand Up @@ -306,6 +422,10 @@ func (c *{{classname}}Controller) {{nickname}}(w http.ResponseWriter, r *http.Re
if err := Assert{{baseType}}Required({{paramName}}Param); err != nil {
c.errorHandler(w, r, err, nil)
return
}
if err := Assert{{baseType}}Constraints({{paramName}}Param); err != nil {
c.errorHandler(w, r, err, nil)
return
}
{{/isModel}}
{{/isArray}}
Expand Down
Loading