refactored composed schema method generation

Author: HugoMario

modules/swagger-codegen/src/main/java/io/swagger/codegen/v3/CodegenSchema.java

@@ -0,0 +1,22 @@
+package io.swagger.codegen.v3;
+
+import io.swagger.v3.oas.models.media.Schema;
+
+public class CodegenSchema {
+
+    private CodegenModel codegenModel;
+    private Schema schema;
+
+    public CodegenSchema(CodegenModel codegenModel, Schema schema) {
+        this.codegenModel = codegenModel;
+        this.schema = schema;
+    }
+
+    public CodegenModel getCodegenModel() {
+        return codegenModel;
+    }
+
+    public Schema getSchema() {
+        return schema;
+    }
+}

modules/swagger-codegen/src/main/java/io/swagger/codegen/v3/DefaultGenerator.java

@@ -382,28 +382,25 @@ public int compare(String o1, String o2) {
                 if (modelList == null || modelList.isEmpty()) {
                     continue;
                 }
-
-                for (Object object : modelList) {
-                    Map<String, Object> modelMap = (Map<String, Object>) object;
-                    CodegenModel codegenModel = null;
-                    if (modelMap.containsKey("oneOf-model")) {
-                        codegenModel = (CodegenModel) modelMap.get("oneOf-model");
-                    }
-                    if (modelMap.containsKey("anyOf-model")) {
-                        codegenModel = (CodegenModel) modelMap.get("anyOf-model");
-                    }
-                    if (codegenModel != null) {
-                        models = processModel(codegenModel, config, schemas);
-                        models.put("classname", config.toModelName(codegenModel.name));
-                        models.putAll(config.additionalProperties());
-                        allProcessedModels.put(codegenModel.name, models);
-                        break;
-                    }
-                }
             } catch (Exception e) {
                 throw new RuntimeException("Could not process model '" + name + "'" + ".Please make sure that your schema is correct!", e);
             }
         }
+        final List<CodegenModel> composedModels = null;
+        /** todo: uncomment once generator repo is updated
+        final ISchemaHandler schemaHandler = config.getSchemaHandler();
+        schemaHandler.readProcessedModels(allProcessedModels);
+
+        final List<CodegenModel> composedModels = schemaHandler.getModels();
+         */
+         if (composedModels != null && !composedModels.isEmpty()) {
+            for (CodegenModel composedModel : composedModels) {
+                final Map<String, Object> models = processModel(composedModel, config, schemas);
+                models.put("classname", config.toModelName(composedModel.name));
+                models.putAll(config.additionalProperties());
+                allProcessedModels.put(composedModel.name, models);
+            }
+        }
 
         // post process all processed models
         allProcessedModels = config.postProcessAllModels(allProcessedModels);
@@ -1015,7 +1012,9 @@ private Map<String, Object> processModels(CodegenConfig config, Map<String, Sche
             CodegenModel cm = config.fromModel(key, schema, allDefinitions);
             Map<String, Object> mo = new HashMap<>();
             mo.put("model", cm);
+            mo.put("schema", schema);
             mo.put("importPath", config.toModelImport(cm.classname));
+            /**
             if (cm.vendorExtensions.containsKey("oneOf-model")) {
                 CodegenModel oneOfModel = (CodegenModel) cm.vendorExtensions.get("oneOf-model");
                 mo.put("oneOf-model", oneOfModel);
@@ -1024,6 +1023,7 @@ private Map<String, Object> processModels(CodegenConfig config, Map<String, Sche
                 CodegenModel anyOfModel = (CodegenModel) cm.vendorExtensions.get("anyOf-model");
                 mo.put("anyOf-model", anyOfModel);
             }
+            */
             models.add(mo);
 
             allImports.addAll(cm.imports);
@@ -1060,9 +1060,7 @@ private Map<String, Object> processModel(CodegenModel codegenModel, CodegenConfi
         objs.put("package", config.modelPackage());
         List<Object> models = new ArrayList<>();
 
-        if (codegenModel.vendorExtensions.containsKey("x-is-composed-model")) {
-            objs.put("x-is-composed-model", codegenModel.vendorExtensions.get("x-is-composed-model"));
-        }
+        objs.put("x-is-composed-model", codegenModel.isComposedModel);
 
         Map<String, Object> modelObject = new HashMap<>();
         modelObject.put("model", codegenModel);

modules/swagger-codegen/src/main/java/io/swagger/codegen/v3/ISchemaHandler.java

@@ -2,16 +2,41 @@
 
 import io.swagger.v3.oas.models.media.Schema;
 
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 public interface ISchemaHandler {
 
+    default void readProcessedModels(Map<String,Object> allProcessedModels) {
+        final List<CodegenSchema> codegenSchemas = new ArrayList<>();
+        final Map<String, CodegenModel> allModels = new HashMap<>();
+        for (String name : allProcessedModels.keySet()) {
+            final Map<String, Object> modelMap = (Map<String, Object>) allProcessedModels.get(name);
+            final List<Map<String, Object>> models = (List<Map<String, Object>>) modelMap.get("models");
+            for (Map<String, Object> mo : models) {
+                final CodegenModel codegenModel = (CodegenModel) mo.get("model");
+                final Schema schema = (Schema) mo.get("schema");
+
+                codegenSchemas.add(new CodegenSchema(codegenModel, schema));
+                allModels.put(codegenModel.classname, codegenModel);
+            }
+        }
+        if (codegenSchemas.isEmpty()) {
+            return;
+        }
+        for (CodegenSchema codegenSchema : codegenSchemas) {
+            processComposedSchemas(codegenSchema.getCodegenModel(), codegenSchema.getSchema(), allModels);
+        }
+    }
+
     /**
      * check if there is any composed schema in models or properties. And create codegen model objects if it's required.
      * @param codegenModel
      * @param schema
      */
-    void proccessComposedSchemas(CodegenModel codegenModel, Schema schema);
+    void processComposedSchemas(CodegenModel codegenModel, Schema schema, Map<String, CodegenModel> allModels);
 
     /**
      * retrieve a list of codegen models created from composed schemas found.