Merge pull request #59 from hauner/#56

resolves #56, #57

Author: hauner

src/main/groovy/com/github/hauner/openapi/spring/converter/ApiConverter.groovy

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 the original authors
+ * Copyright 2019-2020 the original authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,10 +21,13 @@ import com.github.hauner.openapi.spring.converter.schema.RefResolver
 import com.github.hauner.openapi.spring.converter.schema.ResponseSchemaInfo
 import com.github.hauner.openapi.spring.converter.schema.SchemaInfo
 import com.github.hauner.openapi.spring.model.Api
+import com.github.hauner.openapi.spring.model.DataTypes
 import com.github.hauner.openapi.spring.model.Endpoint
-import com.github.hauner.openapi.spring.model.RequestBody
+import com.github.hauner.openapi.spring.model.RequestBody as ModelRequestBody
+import com.github.hauner.openapi.spring.model.datatypes.ObjectDataType
 import com.github.hauner.openapi.spring.model.parameters.CookieParameter
 import com.github.hauner.openapi.spring.model.parameters.HeaderParameter
+import com.github.hauner.openapi.spring.model.parameters.MultipartParameter
 import com.github.hauner.openapi.spring.model.parameters.Parameter as ModelParameter
 import com.github.hauner.openapi.spring.model.parameters.PathParameter
 import com.github.hauner.openapi.spring.model.parameters.QueryParameter
@@ -36,7 +39,9 @@ import io.swagger.v3.oas.models.OpenAPI
 import io.swagger.v3.oas.models.PathItem
 import io.swagger.v3.oas.models.media.MediaType
 import io.swagger.v3.oas.models.parameters.Parameter
+import io.swagger.v3.oas.models.parameters.RequestBody
 import io.swagger.v3.oas.models.responses.ApiResponse
+import io.swagger.v3.oas.models.responses.ApiResponses
 
 /**
  * Converts the open api model to a new model that is better suited for generating source files
@@ -46,6 +51,7 @@ import io.swagger.v3.oas.models.responses.ApiResponse
  */
 @Slf4j
 class ApiConverter {
+    public static final String MULTIPART = "multipart/form-data"
 
     private DataTypeConverter dataTypeConverter
     private ApiOptions options
@@ -76,7 +82,6 @@ class ApiConverter {
     }
 
     private Map<String, PathItem> addEndpointsToInterfaces (OpenAPI api, Api target) {
-        def resolver = new RefResolver (api.components)
 
         api.paths.each { Map.Entry<String, PathItem> pathEntry ->
             String path = pathEntry.key
@@ -89,47 +94,11 @@ class ApiConverter {
                 Endpoint ep = new Endpoint (path: path, method: httpOperation.httpMethod)
 
                 try {
-                    httpOperation.parameters.each { Parameter parameter ->
-                        ep.parameters.addAll (createParameter(path, parameter, target, resolver))
-                    }
-
-                    if (httpOperation.requestBody != null) {
-                        def required = httpOperation.requestBody.required != null ?: false
-                        httpOperation.requestBody.content.each { Map.Entry<String, MediaType> requestBodyEntry ->
-                            def contentType = requestBodyEntry.key
-                            def requestBody = requestBodyEntry.value
-
-                            def info = new SchemaInfo (path, requestBody.schema, getInlineTypeName (path))
-                            info.resolver = resolver
-
-                            DataType dataType = dataTypeConverter.convert (info, target.models)
-
-                            def body = new RequestBody(
-                                contentType: contentType,
-                                requestBodyType: dataType,
-                                required: required)
-
-                            ep.requestBodies.add (body)
-                        }
-                    }
-
-                    httpOperation.responses.each { Map.Entry<String, ApiResponse> responseEntry ->
-                        def httpStatus = responseEntry.key
-                        def httpResponse = responseEntry.value
-
-                        if (!httpResponse.content) {
-                            ep.responses.add (createEmptyResponse ())
-                        } else {
-                            List<Response> responses = createResponses (
-                                path,
-                                httpResponse,
-                                getInlineResponseName (path, httpStatus),
-                                target,
-                            resolver)
-
-                            ep.responses.addAll (responses)
-                        }
-                    }
+                    def resolver = new RefResolver (api.components)
+
+                    collectParameters (httpOperation.parameters, ep, target.models, resolver)
+                    collectRequestBody (httpOperation.requestBody, ep, target.models, resolver)
+                    collectResponses (httpOperation.responses, ep, target.models, resolver)
 
                     itf.endpoints.add (ep)
 
@@ -140,11 +109,59 @@ class ApiConverter {
         }
     }
 
-    private ModelParameter createParameter (String path, Parameter parameter, Api target, resolver) {
+    private void collectParameters (List<Parameter> parameters, Endpoint ep, DataTypes dataTypes, RefResolver resolver) {
+        parameters.each { Parameter parameter ->
+            ep.parameters.add (createParameter (ep.path, parameter, dataTypes, resolver))
+        }
+    }
+
+    private void collectRequestBody (RequestBody requestBody, Endpoint ep, DataTypes dataTypes, RefResolver resolver) {
+        if (requestBody == null) {
+            return
+        }
+
+        def required = requestBody.required != null ?: false
+
+        requestBody.content.each { Map.Entry<String, MediaType> requestBodyEntry ->
+            def contentType = requestBodyEntry.key
+            def reqBody = requestBodyEntry.value
+
+            def info = new SchemaInfo (ep.path, reqBody.schema, getInlineTypeName (ep.path))
+            info.resolver = resolver
+
+            if (contentType == MULTIPART) {
+                ep.parameters.addAll (createMultipartParameter (info, required))
+            } else {
+                ep.requestBodies.add (createRequestBody (contentType, info, required, dataTypes))
+            }
+        }
+    }
+
+    private collectResponses (ApiResponses responses, Endpoint ep, DataTypes dataTypes, RefResolver resolver) {
+        responses.each { Map.Entry<String, ApiResponse> responseEntry ->
+            def httpStatus = responseEntry.key
+            def httpResponse = responseEntry.value
+
+            if (!httpResponse.content) {
+                ep.responses.add (createEmptyResponse ())
+            } else {
+                List<Response> results = createResponses (
+                    ep.path,
+                    httpResponse,
+                    getInlineResponseName (ep.path, httpStatus),
+                    dataTypes,
+                    resolver)
+
+                ep.responses.addAll (results)
+            }
+        }
+    }
+
+    private ModelParameter createParameter (String path, Parameter parameter, DataTypes dataTypes, resolver) {
         def info = new ParameterSchemaInfo (path, parameter.schema, parameter.name)
         info.resolver = resolver
 
-        DataType dataType = dataTypeConverter.convert (info, target.models)
+        DataType dataType = dataTypeConverter.convert (info, dataTypes)
 
         switch (parameter.in) {
             case 'query':
@@ -161,19 +178,27 @@ class ApiConverter {
         }
     }
 
-    private String getInlineTypeName (String path) {
-        Identifier.toClass (path) + 'RequestBody'
-    }
+    private ModelRequestBody createRequestBody (String contentType, SchemaInfo info, boolean required, DataTypes dataTypes) {
+        DataType dataType = dataTypeConverter.convert (info, dataTypes)
 
-    private String getInlineResponseName (String path, String httpStatus) {
-        Identifier.toClass (path) + 'Response' + httpStatus
+        new ModelRequestBody(
+            contentType: contentType,
+            requestBodyType: dataType,
+            required: required)
     }
 
-    private Response createEmptyResponse () {
-        new Response (responseType: dataTypeConverter.none ())
+    private Collection<ModelParameter> createMultipartParameter (SchemaInfo info, boolean required) {
+        DataType dataType = dataTypeConverter.convert (info, new DataTypes())
+        if (! (dataType instanceof ObjectDataType)) {
+            throw new MultipartResponseBodyException(info.path)
+        }
+
+        dataType.getObjectProperties ().collect {
+            new MultipartParameter (name: it.key, required: required, dataType: it.value)
+        }
     }
 
-    private List<Response> createResponses (String path, ApiResponse apiResponse, String inlineName, Api target, RefResolver resolver) {
+    private List<Response> createResponses (String path, ApiResponse apiResponse, String inlineName, DataTypes dataTypes, RefResolver resolver) {
         def responses = []
 
         apiResponse.content.each { Map.Entry<String, MediaType> contentEntry ->
@@ -188,9 +213,7 @@ class ApiConverter {
                 inlineName)
             info.resolver = resolver
 
-            DataType dataType = dataTypeConverter.convert (
-                info,
-                target.models)
+            DataType dataType = dataTypeConverter.convert (info, dataTypes)
 
             def response = new Response (
                 contentType: contentType,
@@ -202,6 +225,18 @@ class ApiConverter {
         responses
     }
 
+    private String getInlineTypeName (String path) {
+        Identifier.toClass (path) + 'RequestBody'
+    }
+
+    private String getInlineResponseName (String path, String httpStatus) {
+        Identifier.toClass (path) + 'Response' + httpStatus
+    }
+
+    private Response createEmptyResponse () {
+        new Response (responseType: dataTypeConverter.none ())
+    }
+
     private void collectInterfaces (OpenAPI api, Api target) {
         target.interfaces = new InterfaceCollector (options)
             .collect (api.paths)

src/main/groovy/com/github/hauner/openapi/spring/converter/MultipartResponseBodyException.groovy

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2020 the original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.hauner.openapi.spring.converter
+
+/**
+ * thrown when the ApiConverter hits a multipart/form-data response body where
+ * the schema is not an object.
+ *
+ * @author Martin Hauner
+ */
+class MultipartResponseBodyException extends RuntimeException {
+
+    String path
+
+    MultipartResponseBodyException(String path) {
+        super()
+        this.path = path
+    }
+
+    @Override
+    String getMessage () {
+        "the schema of the multipart response body of ${path} should be an object!"
+    }
+
+}

src/main/groovy/com/github/hauner/openapi/spring/model/datatypes/ObjectDataType.groovy

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 the original authors
+ * Copyright 2019-2020 the original authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -61,4 +61,8 @@ class ObjectDataType implements DataType {
         properties.get (name)
     }
 
+    Map<String, DataType> getObjectProperties () {
+        properties
+    }
+
 }

src/main/groovy/com/github/hauner/openapi/spring/model/parameters/MultipartParameter.groovy

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2020 the original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.hauner.openapi.spring.model.parameters
+
+/**
+ * OpenAPI multipart request body is passed as {@code @RequestParam}
+ *
+ * @author Martin Hauner
+ */
+class MultipartParameter extends Parameter {
+
+    String getAnnotationName () {
+        "RequestParam"
+    }
+
+    boolean withAnnotation () {
+        true
+    }
+
+    boolean withParameters () {
+        true
+    }
+
+}