Fix OpenAPITools#5381

added x-is-one-of-interface extension for oneOf interface in mustache
template

Author: alexsuperdev

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/SpringCodegen.java

@@ -21,6 +21,10 @@
 import io.swagger.v3.oas.models.OpenAPI;
 import io.swagger.v3.oas.models.Operation;
 import io.swagger.v3.oas.models.PathItem;
+import io.swagger.v3.oas.models.media.ComposedSchema;
+import io.swagger.v3.oas.models.media.Schema;
+import io.swagger.v3.oas.models.parameters.RequestBody;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.Pair;
 import org.openapitools.codegen.*;
 import org.openapitools.codegen.languages.features.BeanValidationFeatures;
@@ -29,6 +33,8 @@
 import org.openapitools.codegen.meta.features.*;
 import org.openapitools.codegen.templating.mustache.SplitStringLambda;
 import org.openapitools.codegen.templating.mustache.TrimWhitespaceLambda;
+import org.openapitools.codegen.utils.ModelUtils;
+import org.openapitools.codegen.utils.OneOfImplementorAdditionalData;
 import org.openapitools.codegen.utils.URLPathUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -233,7 +239,7 @@ public void processOpts() {
         }
 
         super.processOpts();
-
+        useOneOfInterfaces = true;
         // clear model and api doc template as this codegen
         // does not support auto-generated markdown doc at the moment
         //TODO: add doc templates
@@ -523,6 +529,58 @@ public void addOperationToGroup(String tag, String resourcePath, Operation opera
         }
     }
 
+    @Override
+    public void addOneOfInterfaceModel(ComposedSchema cs, String name) {
+        CodegenModel codegenModel = new CodegenModel();
+
+        for (Schema o : cs.getOneOf()) {
+            codegenModel.oneOf.add(toModelName(ModelUtils.getSimpleRef(o.get$ref())));
+        }
+        codegenModel.name = name;
+        codegenModel.classname = name;
+        codegenModel.vendorExtensions.put("isOneOfInterface", true);
+        codegenModel.discriminator = createDiscriminator("", (Schema) cs);
+        codegenModel.interfaceModels = new ArrayList<CodegenModel>();
+
+        for(Schema schema : cs.getOneOf()){
+            String[] split = schema.get$ref().split("/");
+            String singleSchemaType = split[split.length-1];
+            CodegenProperty codegenProperty = fromProperty(singleSchemaType, schema);
+            codegenProperty.setBaseName(singleSchemaType.toLowerCase(Locale.getDefault()));
+            codegenModel.vars.add(codegenProperty);
+        }
+        addOneOfInterfaces.add(codegenModel);
+    }
+
+    @Override
+    public CodegenParameter fromRequestBody(RequestBody body, Set<String> imports, String bodyParameterName) {
+        CodegenParameter codegenParameter = super.fromRequestBody(body, imports, bodyParameterName);
+        Schema schema = ModelUtils.getSchemaFromRequestBody(body);
+        CodegenProperty codegenProperty = fromProperty("property", schema);
+
+        List<String> oneOfClassNames = new ArrayList<>();
+        if (codegenProperty != null && codegenProperty.getComplexType() != null && schema instanceof ComposedSchema) {
+            // will be set with imports.add(codegenParameter.baseType); in defaultcodegen
+            imports.clear();
+            ComposedSchema composedSchema = (ComposedSchema) schema;
+            for(Schema oneOfSchema: composedSchema.getOneOf()){
+                String[] split = oneOfSchema.get$ref().split("/");
+                oneOfClassNames.add(split[split.length - 1]);
+            }
+            String codegenModelName = createOneOfClassName(oneOfClassNames);
+            imports.add(codegenModelName);
+            codegenParameter.baseName = codegenModelName;
+            codegenParameter.paramName = toParamName(codegenParameter.baseName);
+            codegenParameter.baseType = codegenParameter.baseName;
+            codegenParameter.dataType = getTypeDeclaration(codegenModelName);
+            codegenParameter.description = codegenProperty.getDescription();
+            codegenProperty.setComplexType(codegenModelName);
+            codegenProperty.setBaseName(codegenModelName);
+            codegenProperty.setDatatype(codegenModelName);
+        }
+        return codegenParameter;
+    }
+
     @Override
     public void preprocessOpenAPI(OpenAPI openAPI) {
         super.preprocessOpenAPI(openAPI);
@@ -629,6 +687,57 @@ public void setReturnContainer(final String returnContainer) {
         return objs;
     }
 
+    @Override
+    public Map<String, Object> postProcessAllModels(Map<String, Object> objs) {
+        super.postProcessAllModels(objs);
+        Map<String, OneOfImplementorAdditionalData> additionalDataMap = new HashMap<>();
+        for (Map.Entry modelsEntry : objs.entrySet()) {
+            Map<String, Object> modelsAttrs = (Map<String, Object>) modelsEntry.getValue();
+            List<Object> models = (List<Object>) modelsAttrs.get("models");
+            List<Map<String, String>> modelsImports = (List<Map<String, String>>) modelsAttrs
+                .getOrDefault("imports", new ArrayList<Map<String, String>>());
+            for (Object _mo : models) {
+                Map<String, Object> mo = (Map<String, Object>) _mo;
+                CodegenModel cm = (CodegenModel) mo.get("model");
+                if (cm.oneOf.size() > 0) {
+                    cm.vendorExtensions.put("isOneOfInterface", true);
+                    // if this is oneOf interface, make sure we include the necessary jackson imports for it
+                    for (String classToImport : Arrays
+                        .asList("JsonTypeInfo", "JsonSubTypes", "JsonProperty",
+                            "ApiModelProperty")) {
+                        Map<String, String> i = new HashMap<String, String>() {{
+                            put("import", importMapping.get(classToImport));
+                        }};
+                        if (!modelsImports.contains(i)) {
+                            modelsImports.add(i);
+                        }
+                    }
+                    List<String> oneOfClassNames = new ArrayList<>();
+
+                    for (String one : cm.oneOf) {
+                        if (!additionalDataMap.containsKey(one)) {
+                            additionalDataMap.put(one, new OneOfImplementorAdditionalData(one));
+                            additionalDataMap.get(one).addFromInterfaceModel(cm, modelsImports);
+                        }
+                        oneOfClassNames.add(one);
+                    }
+                    String codegenModelName = createOneOfClassName(oneOfClassNames);
+                    cm.name = codegenModelName;
+                    cm.classname = codegenModelName;
+                    Object value = modelsEntry.getValue();
+                    objs.remove(modelsEntry.getKey());
+                    objs.put(codegenModelName, value);
+                }
+            }
+        }
+        return objs;
+    }
+
+    private String createOneOfClassName(List<String> oneOfClassNames) {
+        oneOfClassNames.sort(String::compareToIgnoreCase);
+        return "OneOf" + StringUtils.join(oneOfClassNames, "");
+    }
+
     private interface DataTypeAssigner {
         void setReturnType(String returnType);
 
@@ -898,4 +1007,16 @@ public void postProcessParameter(CodegenParameter p) {
         }
     }
 
-}
+    @Override
+    public void addImportsToOneOfInterface(List<Map<String, String>> imports) {
+        for (String i : Arrays.asList("JsonSubTypes", "JsonTypeInfo")) {
+            Map<String, String> oneImport = new HashMap<String, String>() {{
+                put("import", importMapping.get(i));
+            }};
+            if (!imports.contains(oneImport)) {
+                imports.add(oneImport);
+            }
+        }
+    }
+
+}

modules/openapi-generator/src/main/resources/JavaSpring/model.mustache

@@ -35,7 +35,7 @@ import org.springframework.hateoas.RepresentationModel;
 {{>enumOuterClass}}
 {{/isEnum}}
 {{^isEnum}}
-{{>pojo}}
+  {{#vendorExtensions.x-is-one-of-interface}}{{>oneof_interface}}{{/vendorExtensions.x-is-one-of-interface}}{{^vendorExtensions.x-is-one-of-interface}}{{>pojo}}{{/vendorExtensions.x-is-one-of-interface}}
 {{/isEnum}}
 {{/model}}
 {{/models}}

modules/openapi-generator/src/main/resources/JavaSpring/oneof_interface.mustache

@@ -0,0 +1,6 @@
+{{>additionalModelTypeAnnotations}}{{>generatedAnnotation}}{{>typeInfoAnnotation}}{{>xmlAnnotation}}
+public interface {{classname}} {{#vendorExtensions.x-implements}}{{#-first}}extends {{{.}}}{{/-first}}{{^-first}}, {{{.}}}{{/-first}}{{/vendorExtensions.x-implements}} {
+    {{#discriminator}}
+    public {{propertyType}} {{propertyGetter}}();
+    {{/discriminator}}
+}