fixed imports for composed properties models

Author: HugoMario

src/main/java/io/swagger/codegen/v3/generators/DefaultCodegenConfig.java

@@ -2235,11 +2235,7 @@ public CodegenOperation fromOperation(String path, String httpMethod, Operation
             }
         }
 
-        for (String i : imports) {
-            if (needToImport(i)) {
-                codegenOperation.imports.add(i);
-            }
-        }
+        addOperationImports(codegenOperation, imports);
 
         codegenOperation.bodyParam = bodyParam;
         codegenOperation.httpMethod = httpMethod.toUpperCase();
@@ -2293,6 +2289,14 @@ public int compare(CodegenParameter one, CodegenParameter another) {
         return codegenOperation;
     }
 
+    protected void addOperationImports(CodegenOperation codegenOperation, Set<String> operationImports) {
+        for (String operationImport : operationImports) {
+            if (needToImport(operationImport)) {
+                codegenOperation.imports.add(operationImport);
+            }
+        }
+    }
+
     /**
      * Convert Swagger Response object to Codegen Response object
      *

src/main/java/io/swagger/codegen/v3/generators/SchemaHandler.java

@@ -140,6 +140,7 @@ protected CodegenModel processArrayItemSchema(String codegenModelName, CodegenPr
                 return null;
             }
             this.updatePropertyDataType(codegenProperty, composedModel.name, arraySchema);
+            this.updatePropertyDataType(codegenProperty.items, composedModel);
             return composedModel;
         }
         return null;
@@ -208,6 +209,7 @@ protected void updatePropertyDataType(CodegenProperty codegenProperty, String sc
         arraySchema.setItems(refSchema);
         codegenProperty.setDatatype(this.codegenConfig.getTypeDeclaration(arraySchema));
         codegenProperty.setDatatypeWithEnum(codegenProperty.getDatatype());
+        codegenProperty.vendorExtensions.put("x-is-composed", true);
 
         codegenProperty.defaultValue = this.codegenConfig.toDefaultValue(arraySchema);
         codegenProperty.defaultValueWithParam = this.codegenConfig.toDefaultValueWithParam(codegenProperty.baseName, arraySchema);
@@ -235,5 +237,6 @@ private void updatePropertyDataType(CodegenProperty codegenProperty, CodegenMode
         codegenProperty.datatypeWithEnum = composedModel.getClassname();
         codegenProperty.baseType = composedModel.getClassname();
         codegenProperty.complexType = composedModel.getClassname();
+        codegenProperty.vendorExtensions.put("x-is-composed", true);
     }
 }

src/main/java/io/swagger/codegen/v3/generators/python/PythonFlaskConnexionCodegen.java

@@ -22,6 +22,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import io.swagger.v3.core.util.Yaml;
 import io.swagger.v3.oas.models.OpenAPI;
@@ -191,6 +192,7 @@ public void processOpts() {
         supportingFiles.add(new SupportingFile("__main__.mustache", packageName, "__main__.py"));
         supportingFiles.add(new SupportingFile("encoder.mustache", packageName, "encoder.py"));
         supportingFiles.add(new SupportingFile("util.mustache", packageName, "util.py"));
+        supportingFiles.add(new SupportingFile("type_util.mustache", packageName, "type_util.py"));
         supportingFiles.add(new SupportingFile("__init__.mustache", packageName + File.separatorChar + controllerPackage, "__init__.py"));
         supportingFiles.add(new SupportingFile("__init__model.mustache", packageName + File.separatorChar + modelPackage, "__init__.py"));
         supportingFiles.add(new SupportingFile("base_model_.mustache", packageName + File.separatorChar + modelPackage, "base_model_.py"));
@@ -340,6 +342,17 @@ private static List<Map<String, Object>> getOperations(Map<String, Object> objs)
         return result;
     }
 
+    protected void addOperationImports(CodegenOperation codegenOperation, Set<String> operationImports) {
+        for (String operationImport : operationImports) {
+            if ("object".equalsIgnoreCase(operationImport)) {
+                continue;
+            }
+            if (needToImport(operationImport)) {
+                codegenOperation.imports.add(operationImport);
+            }
+        }
+    }
+
     private static List<Map<String, Object>> sortOperationsByPath(List<CodegenOperation> ops) {
         Multimap<String, CodegenOperation> opsByPath = ArrayListMultimap.create();
 
@@ -760,4 +773,41 @@ protected void addSecurityExtensions(Map<String, SecurityScheme> securitySchemes
             }
         }
     }
+
+    public Map<String, Object> postProcessAllModels(Map<String, Object> processedModels) {
+        Map<String, CodegenModel> allModels = new HashMap<>();
+        for (Map.Entry<String, Object> entry : processedModels.entrySet()) {
+            String modelName = toModelName(entry.getKey());
+            Map<String, Object> inner = (Map<String, Object>) entry.getValue();
+            List<Map<String, Object>> models = (List<Map<String, Object>>) inner.get("models");
+            List<Map<String, String>> imports = (List<Map<String, String>>) inner.get("imports");
+            for (Map<String, Object> mo : models) {
+                CodegenModel codegenModel = (CodegenModel) mo.get("model");
+
+                for (CodegenProperty codegenProperty : codegenModel.vars) {
+                    if (Boolean.parseBoolean(String.valueOf(codegenProperty.vendorExtensions.get("x-is-composed")))) {
+                        Map<String, String> item = new HashMap<>();
+                        if (codegenProperty.getIsContainer()) {
+                            item.put("import", toModelImport(codegenProperty.items.datatype));
+                        } else {
+                            item.put("import", toModelImport(codegenProperty.datatype));
+                        }
+                        imports.add(item);
+                    }
+                }
+
+                allModels.put(modelName, codegenModel);
+            }
+        }
+        postProcessAllCodegenModels(allModels);
+        return processedModels;
+    }
+
+    @Override
+    protected void addImport(CodegenModel codegenModel, String type) {
+        if ("object".equalsIgnoreCase(type)) {
+            return;
+        }
+        super.addImport(codegenModel, type);
+    }
 }

src/main/resources/handlebars/pythonFlaskConnexion/type_util.mustache

@@ -0,0 +1,32 @@
+# coding: utf-8
+
+import sys
+
+if sys.version_info < (3, 7):
+    import typing
+
+    def is_generic(klass):
+        """ Determine whether klass is a generic class """
+        return type(klass) == typing.GenericMeta
+
+    def is_dict(klass):
+        """ Determine whether klass is a Dict """
+        return klass.__extra__ == dict
+
+    def is_list(klass):
+        """ Determine whether klass is a List """
+        return klass.__extra__ == list
+
+else:
+
+    def is_generic(klass):
+        """ Determine whether klass is a generic class """
+        return hasattr(klass, '__origin__')
+
+    def is_dict(klass):
+        """ Determine whether klass is a Dict """
+        return klass.__origin__ == dict
+
+    def is_list(klass):
+        """ Determine whether klass is a List """
+        return klass.__origin__ == list

src/main/resources/handlebars/pythonFlaskConnexion/util.mustache

@@ -2,6 +2,7 @@ import datetime
 
 import six
 import typing
+from {{packageName}} import type_util
 
 
 def _deserialize(data, klass):
@@ -15,18 +16,18 @@ def _deserialize(data, klass):
     if data is None:
         return None
 
-    if klass in six.integer_types or klass in (float, str, bool):
+    if klass in six.integer_types or klass in (float, str, bool, bytearray):
         return _deserialize_primitive(data, klass)
     elif klass == object:
         return _deserialize_object(data)
     elif klass == datetime.date:
         return deserialize_date(data)
     elif klass == datetime.datetime:
         return deserialize_datetime(data)
-    elif type(klass) == typing.GenericMeta:
-        if klass.__extra__ == list:
+    elif type_util.is_generic(klass):
+        if type_util.is_list(klass):
             return _deserialize_list(data, klass.__args__[0])
-        if klass.__extra__ == dict:
+        if type_util.is_dict(klass):
             return _deserialize_dict(data, klass.__args__[1])
     else:
         return deserialize_model(data, klass)
@@ -51,7 +52,7 @@ def _deserialize_primitive(data, klass):
 
 
 def _deserialize_object(value):
-    """Return a original value.
+    """Return an original value.
 
     :return: object.
     """