[JaxrsResteasy] Improvements for Resteasy for Jboss EAP 4512

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/AbstractJavaCodegen.java

@@ -358,6 +358,7 @@ public void processOpts() {
         }
 
         if("joda".equals(dateLibrary)) {
+            additionalProperties.put("joda", "true");
             typeMapping.put("date", "LocalDate");
             typeMapping.put("DateTime", "DateTime");
 

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/JavaResteasyEapServerCodegen.java

@@ -0,0 +1,231 @@
+package io.swagger.codegen.languages;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.lang3.BooleanUtils;
+
+import io.swagger.codegen.CliOption;
+import io.swagger.codegen.CodegenModel;
+import io.swagger.codegen.CodegenOperation;
+import io.swagger.codegen.CodegenProperty;
+import io.swagger.codegen.CodegenResponse;
+import io.swagger.codegen.SupportingFile;
+import io.swagger.codegen.languages.features.BeanValidationFeatures;
+import io.swagger.codegen.languages.features.JbossFeature;
+import io.swagger.codegen.languages.features.SwaggerFeatures;
+import io.swagger.models.Operation;
+
+public class JavaResteasyEapServerCodegen extends AbstractJavaJAXRSServerCodegen
+        implements JbossFeature, BeanValidationFeatures, SwaggerFeatures {
+
+    protected boolean useBeanValidation = true;
+    protected boolean generateJbossDeploymentDescriptor = true;
+    protected boolean useSwaggerFeature = false;
+
+    public JavaResteasyEapServerCodegen() {
+
+        super();
+
+        artifactId = "swagger-jaxrs-resteasy-eap-server";
+
+        outputFolder = "generated-code/JavaJaxRS-Resteasy-eap";
+        apiTemplateFiles.put("apiServiceImpl.mustache", ".java");
+        apiTestTemplateFiles.clear(); // TODO: add test template
+
+        // clear model and api doc template as AbstractJavaJAXRSServerCodegen
+        // does not support auto-generated markdown doc at the moment
+        //TODO: add doc templates
+        modelDocTemplateFiles.remove("model_doc.mustache");
+        apiDocTemplateFiles.remove("api_doc.mustache");
+
+        dateLibrary = "legacy";// TODO: change to joda
+
+        embeddedTemplateDir = templateDir = "JavaJaxRS" + File.separator + "resteasy" + File.separator + "eap";
+
+        cliOptions.add(CliOption.newBoolean(USE_BEANVALIDATION, "Use BeanValidation API annotations"));
+        cliOptions.add(CliOption.newBoolean(GENERATE_JBOSS_DEPLOYMENT_DESCRIPTOR, "Generate Jboss Deployment Descriptor"));
+        cliOptions.add(CliOption.newBoolean(USE_SWAGGER_FEATURE, "Use dynamic Swagger generator"));
+
+    }
+
+    @Override
+    public String getName() {
+        return "jaxrs-resteasy-eap";
+    }
+
+    @Override
+    public String getHelp() {
+        return "Generates a Java JAXRS-Resteasy Server application.";
+    }
+
+    @Override
+    public void processOpts() {
+        super.processOpts();
+
+        if (additionalProperties.containsKey(GENERATE_JBOSS_DEPLOYMENT_DESCRIPTOR)) {
+            boolean generateJbossDeploymentDescriptorProp = convertPropertyToBooleanAndWriteBack(GENERATE_JBOSS_DEPLOYMENT_DESCRIPTOR);
+            this.setGenerateJbossDeploymentDescriptor(generateJbossDeploymentDescriptorProp);
+        }
+
+        if (additionalProperties.containsKey(USE_BEANVALIDATION)) {
+            this.setUseBeanValidation(convertPropertyToBoolean(USE_BEANVALIDATION));
+        }
+
+        if (useBeanValidation) {
+            writePropertyBack(USE_BEANVALIDATION, useBeanValidation);
+        }
+
+        if (additionalProperties.containsKey(USE_SWAGGER_FEATURE)) {
+            this.setUseSwaggerFeature(convertPropertyToBoolean(USE_SWAGGER_FEATURE));
+        }
+
+        if (useSwaggerFeature) {
+            writePropertyBack(USE_SWAGGER_FEATURE, useSwaggerFeature);
+        }
+
+        writeOptional(outputFolder, new SupportingFile("pom.mustache", "", "pom.xml"));
+        writeOptional(outputFolder, new SupportingFile("gradle.mustache", "", "build.gradle"));
+        writeOptional(outputFolder, new SupportingFile("settingsGradle.mustache", "", "settings.gradle"));
+        writeOptional(outputFolder, new SupportingFile("README.mustache", "", "README.md"));
+        writeOptional(outputFolder, new SupportingFile("web.mustache", ("src/main/webapp/WEB-INF"), "web.xml"));
+
+        supportingFiles.add(new SupportingFile("JacksonConfig.mustache", (projectFolder + File.separator + "java" + '/' + invokerPackage).replace(".", "/"), "JacksonConfig.java"));
+
+        if (generateJbossDeploymentDescriptor) {
+            writeOptional(outputFolder, new SupportingFile("jboss-web.mustache", ("src/main/webapp/WEB-INF"), "jboss-web.xml"));
+        }
+
+        writeOptional(outputFolder, new SupportingFile("RestApplication.mustache", (projectFolder + File.separator + "java" + '/' + invokerPackage).replace(".", "/"), "RestApplication.java"));
+
+    }
+
+    @Override
+    public void addOperationToGroup(String tag, String resourcePath, Operation operation, CodegenOperation co, Map<String, List<CodegenOperation>> operations) {
+        String basePath = resourcePath;
+        if (basePath.startsWith("/")) {
+            basePath = basePath.substring(1);
+        }
+        int pos = basePath.indexOf("/");
+        if (pos > 0) {
+            basePath = basePath.substring(0, pos);
+        }
+
+        if (basePath == "") {
+            basePath = "default";
+        } else {
+            if (co.path.startsWith("/" + basePath)) {
+                co.path = co.path.substring(("/" + basePath).length());
+        }
+            co.subresourceOperation = !co.path.isEmpty();
+        }
+        List<CodegenOperation> opList = operations.get(basePath);
+        if (opList == null) {
+            opList = new ArrayList<CodegenOperation>();
+            operations.put(basePath, opList);
+        }
+        opList.add(co);
+        co.baseName = basePath;
+    }
+
+    @Override
+    public Map<String, Object> postProcessOperations(Map<String, Object> objs) {
+
+        Map<String, Object> operations = (Map<String, Object>) objs.get("operations");
+        if (operations != null) {
+            List<CodegenOperation> ops = (List<CodegenOperation>) operations.get("operation");
+            for (CodegenOperation operation : ops) {
+                if (operation.hasConsumes == Boolean.TRUE) {
+                    Map<String, String> firstType = operation.consumes.get(0);
+                    if (firstType != null) {
+                        if ("multipart/form-data".equals(firstType.get("mediaType"))) {
+                            operation.isMultipart = Boolean.TRUE;
+                        }
+                    }
+                }
+                List<CodegenResponse> responses = operation.responses;
+                if (responses != null) {
+                    for (CodegenResponse resp : responses) {
+                        if ("0".equals(resp.code)) {
+                            resp.code = "200";
+                        }
+                    }
+                }
+                if (operation.returnType == null) {
+                    operation.returnType = "Void";
+                } else if (operation.returnType.startsWith("List")) {
+                    String rt = operation.returnType;
+                    int end = rt.lastIndexOf(">");
+                    if (end > 0) {
+                        operation.returnType = rt.substring("List<".length(), end).trim();
+                        operation.returnContainer = "List";
+                    }
+                } else if (operation.returnType.startsWith("Map")) {
+                    String rt = operation.returnType;
+                    int end = rt.lastIndexOf(">");
+                    if (end > 0) {
+                        operation.returnType = rt.substring("Map<".length(), end).split(",")[1].trim();
+                        operation.returnContainer = "Map";
+                    }
+                } else if (operation.returnType.startsWith("Set")) {
+                    String rt = operation.returnType;
+                    int end = rt.lastIndexOf(">");
+                    if (end > 0) {
+                        operation.returnType = rt.substring("Set<".length(), end).trim();
+                        operation.returnContainer = "Set";
+            }
+        }
+            }
+        }
+        return objs;
+    }
+
+    @Override
+    public void postProcessModelProperty(CodegenModel model, CodegenProperty property) {
+        // Add imports for Jackson
+        if (!BooleanUtils.toBoolean(model.isEnum)) {
+            model.imports.add("JsonProperty");
+
+            if (BooleanUtils.toBoolean(model.hasEnums)) {
+                model.imports.add("JsonValue");
+        }
+    }
+    }
+
+    @Override
+    public Map<String, Object> postProcessModelsEnum(Map<String, Object> objs) {
+        objs = super.postProcessModelsEnum(objs);
+
+        // Add imports for Jackson
+        List<Map<String, String>> imports = (List<Map<String, String>>) objs.get("imports");
+        List<Object> models = (List<Object>) objs.get("models");
+        for (Object _mo : models) {
+            Map<String, Object> mo = (Map<String, Object>) _mo;
+            CodegenModel cm = (CodegenModel) mo.get("model");
+            // for enum model
+            if (Boolean.TRUE.equals(cm.isEnum) && cm.allowableValues != null) {
+                cm.imports.add(importMapping.get("JsonValue"));
+                Map<String, String> item = new HashMap<String, String>();
+                item.put("import", importMapping.get("JsonValue"));
+                imports.add(item);
+        }
+        }
+
+        return objs;
+    }
+
+    public void setUseBeanValidation(boolean useBeanValidation) {
+        this.useBeanValidation = useBeanValidation;
+    }
+
+    public void setGenerateJbossDeploymentDescriptor(boolean generateJbossDeploymentDescriptor) {
+        this.generateJbossDeploymentDescriptor = generateJbossDeploymentDescriptor;
+    }
+
+    public void setUseSwaggerFeature(boolean useSwaggerFeature) {
+        this.useSwaggerFeature = useSwaggerFeature;
+    }
+}

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/features/BeanValidationFeatures.java

@@ -4,7 +4,7 @@ public interface BeanValidationFeatures {
 
     // Language supports generating BeanValidation-Annotations
     public static final String USE_BEANVALIDATION = "useBeanValidation";
-        
+
     public void setUseBeanValidation(boolean useBeanValidation);
 
 }

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/features/CXFServerFeatures.java

@@ -5,8 +5,7 @@
  *
  */
 public interface CXFServerFeatures
-        extends CXFFeatures, SwaggerFeatures, SpringFeatures, JbossFeature, BeanValidationExtendedFeatures,
-        SwaggerUIFeatures
+        extends CXFFeatures, SwaggerFeatures, SpringFeatures, JbossFeature, BeanValidationExtendedFeatures, SwaggerUIFeatures
 {
 
     public static final String USE_WADL_FEATURE = "useWadlFeature";

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/features/PerformBeanValidationFeatures.java

@@ -4,7 +4,7 @@ public interface PerformBeanValidationFeatures {
 
     // Language supports performing BeanValidation
     public static final String PERFORM_BEANVALIDATION = "performBeanValidation";
-        
+
     public void setPerformBeanValidation(boolean performBeanValidation);
 
 }

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/features/SpringFeatures.java

@@ -14,5 +14,5 @@ public interface SpringFeatures extends BeanValidationFeatures {
 
     public void setUseSpringAnnotationConfig(boolean useSpringAnnotationConfig);
 
-        
+
 }

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/features/SwaggerFeatures.java

@@ -1,6 +1,6 @@
 package io.swagger.codegen.languages.features;
 
-public interface SwaggerFeatures extends CXFFeatures {
+public interface SwaggerFeatures {
 
     public static final String USE_SWAGGER_FEATURE = "useSwaggerFeature";
 

modules/swagger-codegen/src/main/resources/JavaJaxRS/resteasy/eap/JacksonConfig.mustache

@@ -0,0 +1,39 @@
+package io.swagger.api;
+
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.ext.ContextResolver;
+import javax.ws.rs.ext.Provider;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.joda.JodaModule;
+
+@Provider
+@Produces(MediaType.APPLICATION_JSON)
+public class JacksonConfig implements ContextResolver<ObjectMapper> {
+
+    private static final Logger LOG = LoggerFactory.getLogger(JacksonConfig.class);
+
+    private ObjectMapper objectMapper;
+
+    public JacksonConfig() throws Exception {
+        this.objectMapper = new ObjectMapper();
+
+{{#java8}}        
+        this.objectMapper.registerModule(new JavaTimeModule());
+{{/java8}}
+{{#joda}}
+        this.objectMapper.registerModule(new JodaModule());
+{{/joda}}
+
+        // sample to convert any DateTime to readable timestamps
+        //this.objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, true);
+    }
+
+    public ObjectMapper getContext(Class<?> objectType) {
+        return objectMapper;
+    }
+}

modules/swagger-codegen/src/main/resources/JavaJaxRS/resteasy/eap/README.mustache

@@ -0,0 +1,19 @@
+# Swagger generated server
+
+## Overview
+This server was generated by the [swagger-codegen](https://github.com/swagger-api/swagger-codegen) project. By using the 
+[OpenAPI-Spec](https://github.com/swagger-api/swagger-core/wiki) from a remote server, you can easily generate a server stub.  This
+is an example of building a swagger-enabled JAX-RS server.
+
+This example uses the [JAX-RS](https://jax-rs-spec.java.net/) framework for Jboss Resteasy.
+
+You can deploy the WAR file to Jboss EAP or any other JEE server supporting Jboss Resteasy.
+
+You can then view the swagger listing here:
+
+```
+http://localhost:{{serverPort}}{{contextPath}}/swagger.json
+```
+
+Note that if you have configured the `host` to be something other than localhost, the calls through
+swagger-ui will be directed to that host and not localhost!