moved to modules per #411

modules/swagger-codegen/src/main/resources/android-java/api.mustache

@@ -0,0 +1,88 @@
+package {{package}};
+
+import {{invokerPackage}}.ApiException;
+import {{invokerPackage}}.ApiInvoker;
+
+import {{modelPackage}}.*;
+
+import java.util.*;
+
+{{#imports}}import {{import}};
+{{/imports}}
+
+import java.util.Map;
+import java.util.HashMap;
+import java.io.File;
+
+{{#operations}}
+public class {{classname}} {
+  String basePath = "{{basePath}}";
+  ApiInvoker apiInvoker = ApiInvoker.getInstance();
+
+  public void addHeader(String key, String value) {
+    getInvoker().addDefaultHeader(key, value);
+  }
+
+  public ApiInvoker getInvoker() {
+    return apiInvoker;
+  }
+
+  public void setBasePath(String basePath) {
+    this.basePath = basePath;
+  }
+
+  public String getBasePath() {
+    return basePath;
+  }
+
+  {{#operation}}
+  {{#errorList}} //error info- code: {{code}} reason: "{{reason}}" model: {{#responseModel}}{{responseModel}}
+  {{/responseModel}}{{^responseModel}}<none>
+  {{/responseModel}}
+  {{/errorList}}
+  public {{#returnType}}{{{returnType}}} {{/returnType}}{{^returnType}}void {{/returnType}} {{nickname}} ({{#allParams}}{{{dataType}}} {{paramName}}{{#hasMore}}, {{/hasMore}}{{/allParams}}) throws ApiException {
+    Object postBody = {{#bodyParam}}{{paramName}}{{/bodyParam}}{{^bodyParam}}null{{/bodyParam}};
+
+    {{#requiredParamCount}}
+    // verify required params are set
+    if({{/requiredParamCount}}{{#requiredParams}} {{paramName}} == null {{#hasMore}}|| {{/hasMore}}{{/requiredParams}}{{#requiredParamCount}}) {
+       throw new ApiException(400, "missing required params");
+    }
+    {{/requiredParamCount}}
+
+    // create path and map variables
+    String path = "{{path}}".replaceAll("\\{format\\}","json"){{#pathParams}}.replaceAll("\\{" + "{{paramName}}" + "\\}", apiInvoker.escapeString({{{paramName}}}.toString())){{/pathParams}};
+
+    // query params
+    Map<String, String> queryParams = new HashMap<String, String>();
+    Map<String, String> headerParams = new HashMap<String, String>();
+
+    {{#queryParams}}if(!"null".equals(String.valueOf({{paramName}})))
+      queryParams.put("{{baseName}}", String.valueOf({{paramName}}));
+    {{/queryParams}}
+
+    {{#headerParams}}headerParams.put("{{baseName}}", {{paramName}});
+    {{/headerParams}}
+
+    String contentType = "application/json";
+
+    try {
+      String response = apiInvoker.invokeAPI(basePath, path, "{{httpMethod}}", queryParams, postBody, headerParams, contentType);
+      if(response != null){
+        return {{#returnType}}({{{returnType}}}) ApiInvoker.deserialize(response, "{{returnContainer}}", {{returnBaseType}}.class){{/returnType}};
+      }
+      else {
+        return {{#returnType}}null{{/returnType}};
+      }
+    } catch (ApiException ex) {
+      if(ex.getCode() == 404) {
+        return {{#returnType}} null{{/returnType}};
+      }
+      else {
+        throw ex;
+      }
+    }
+  }
+  {{/operation}}
+}
+{{/operations}}

modules/swagger-codegen/src/main/resources/android-java/apiException.mustache

@@ -0,0 +1,29 @@
+package {{invokerPackage}};
+
+public class ApiException extends Exception {
+  int code = 0;
+  String message = null;
+
+  public ApiException() {}
+
+  public ApiException(int code, String message) {
+    this.code = code;
+    this.message = message;
+  }
+
+  public int getCode() {
+    return code;
+  }
+  
+  public void setCode(int code) {
+    this.code = code;
+  }
+  
+  public String getMessage() {
+    return message;
+  }
+  
+  public void setMessage(String message) {
+    this.message = message;
+  }
+}

modules/swagger-codegen/src/main/resources/android-java/apiInvoker.mustache

@@ -0,0 +1,283 @@
+package {{invokerPackage}};
+
+
+import com.fasterxml.jackson.core.JsonGenerator.Feature;
+import com.fasterxml.jackson.databind.*;
+import com.fasterxml.jackson.annotation.*;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+
+import org.apache.http.*;
+import org.apache.http.client.*;
+import org.apache.http.client.methods.*;
+import org.apache.http.conn.*;
+import org.apache.http.conn.scheme.*;
+import org.apache.http.conn.ssl.*;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.*;
+import org.apache.http.impl.conn.*;
+import org.apache.http.params.*;
+import org.apache.http.util.EntityUtils;
+
+import java.io.File;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import java.net.URLEncoder;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.List;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+
+import java.security.GeneralSecurityException;
+import java.security.KeyManagementException;
+import java.security.KeyStore;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.cert.*;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+
+import java.util.Date;
+import java.util.Random;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509TrustManager;
+
+public class ApiInvoker {
+  private static ApiInvoker INSTANCE = new ApiInvoker();
+  private Map<String, String> defaultHeaderMap = new HashMap<String, String>();
+
+  private HttpClient client = null;
+
+  private boolean ignoreSSLCertificates = false;
+
+  private ClientConnectionManager ignoreSSLConnectionManager;
+
+  public ApiInvoker() {
+    initConnectionManager();
+  }
+
+  public static ApiInvoker getInstance() {
+    return INSTANCE;
+  }
+
+  public void ignoreSSLCertificates(boolean ignoreSSLCertificates) {
+    this.ignoreSSLCertificates = ignoreSSLCertificates;
+  }
+
+  public void addDefaultHeader(String key, String value) {
+    defaultHeaderMap.put(key, value);
+  }
+
+  public String escapeString(String str) {
+    return str;
+  }
+
+  public static Object deserialize(String json, String containerType, Class cls) throws ApiException {
+    try{
+      if("List".equals(containerType)) {
+        JavaType typeInfo = JsonUtil.getJsonMapper().getTypeFactory().constructCollectionType(List.class, cls);
+        List response = (List<?>) JsonUtil.getJsonMapper().readValue(json, typeInfo);
+        return response;
+      }
+      else if(String.class.equals(cls)) {
+        if(json != null && json.startsWith("\"") && json.endsWith("\"") && json.length() > 1)
+          return json.substring(1, json.length() - 2);
+        else 
+          return json;
+      }
+      else {
+        return JsonUtil.getJsonMapper().readValue(json, cls);
+      }
+    }
+    catch (IOException e) {
+      throw new ApiException(500, e.getMessage());
+    }
+  }
+
+  public static String serialize(Object obj) throws ApiException {
+    try {
+      if (obj != null) 
+        return JsonUtil.getJsonMapper().writeValueAsString(obj);
+      else 
+        return null;
+    }
+    catch (Exception e) {
+      throw new ApiException(500, e.getMessage());
+    }
+  }
+
+  public String invokeAPI(String host, String path, String method, Map<String, String> queryParams, Object body, Map<String, String> headerParams, String contentType) throws ApiException {
+    HttpClient client = getClient(host);
+
+    StringBuilder b = new StringBuilder();
+    for(String key : queryParams.keySet()) {
+      String value = queryParams.get(key);
+      if (value != null){
+        if(b.toString().length() == 0)
+          b.append("?");
+        else
+          b.append("&");
+        b.append(escapeString(key)).append("=").append(escapeString(value));
+      }
+    }
+    String url = host + path + b.toString();
+
+    HashMap<String, String> headers = new HashMap<String, String>();
+
+    for(String key : headerParams.keySet()) {
+      headers.put(key, headerParams.get(key));
+    }
+    
+    for(String key : defaultHeaderMap.keySet()) {
+      if(!headerParams.containsKey(key)) {
+        headers.put(key, defaultHeaderMap.get(key));
+      }
+    }
+    headers.put("Accept", "application/json");
+
+    HttpResponse response = null;
+    try{
+      if("GET".equals(method)) {
+        HttpGet get = new HttpGet(url);
+        get.addHeader("Accept", "application/json");
+        for(String key : headers.keySet()) {
+          get.setHeader(key, headers.get(key));
+        }
+        response = client.execute(get);
+      }
+      else if ("POST".equals(method)) {
+        HttpPost post = new HttpPost(url);
+
+        if (body != null) {
+          post.setHeader("Content-Type", contentType);
+          post.setEntity(new StringEntity(serialize(body), "UTF-8"));
+        }
+        for(String key : headers.keySet()) {
+          post.setHeader(key, headers.get(key));
+        }
+        response = client.execute(post);
+      }
+      else if ("PUT".equals(method)) {
+        HttpPut put = new HttpPut(url);
+        if(body != null) {
+          put.setHeader("Content-Type", contentType);
+          put.setEntity(new StringEntity(serialize(body), "UTF-8"));
+        }
+        for(String key : headers.keySet()) {
+          put.setHeader(key, headers.get(key));
+        }
+        response = client.execute(put);
+      }
+      else if ("DELETE".equals(method)) {
+        HttpDelete delete = new HttpDelete(url);
+        for(String key : headers.keySet()) {
+          delete.setHeader(key, headers.get(key));
+        }
+        response = client.execute(delete);
+      }
+      else if ("PATCH".equals(method)) {
+        HttpPatch patch = new HttpPatch(url);
+
+        if (body != null) {
+          patch.setHeader("Content-Type", contentType);
+          patch.setEntity(new StringEntity(serialize(body), "UTF-8"));
+        }
+        for(String key : headers.keySet()) {
+          patch.setHeader(key, headers.get(key));
+        }
+        response = client.execute(patch);
+      }
+
+      int code = response.getStatusLine().getStatusCode();
+      String responseString = null;
+      if(code == 204) 
+        responseString = "";
+      else if(code >= 200 && code < 300) {
+        if(response.getEntity() != null) {
+          HttpEntity resEntity = response.getEntity();
+          responseString = EntityUtils.toString(resEntity);
+        }
+      }
+      else {
+        if(response.getEntity() != null) {
+          HttpEntity resEntity = response.getEntity();
+          responseString = EntityUtils.toString(resEntity);
+        }
+        else
+          responseString = "no data";
+        throw new ApiException(code, responseString);
+      }
+      return responseString;
+    }
+    catch(IOException e) {
+      throw new ApiException(500, e.getMessage());
+    }
+  }
+
+  private HttpClient getClient(String host) {
+    if (client == null) {
+      if (ignoreSSLCertificates && ignoreSSLConnectionManager != null) {
+        // Trust self signed certificates
+        client = new DefaultHttpClient(ignoreSSLConnectionManager, new BasicHttpParams());
+      } else {
+        client = new DefaultHttpClient();
+      }
+    }
+    return client;
+  }
+
+  private void initConnectionManager() {
+    try {
+      final SSLContext sslContext = SSLContext.getInstance("SSL");
+
+      // set up a TrustManager that trusts everything
+      TrustManager[] trustManagers = new TrustManager[] {
+        new X509TrustManager() {
+          public X509Certificate[] getAcceptedIssuers() {
+            return null;
+          }
+          public void checkClientTrusted(X509Certificate[] certs, String authType) {}
+          public void checkServerTrusted(X509Certificate[] certs, String authType) {}
+      }};
+
+      sslContext.init(null, trustManagers, new SecureRandom());
+
+      SSLSocketFactory sf = new SSLSocketFactory((KeyStore)null) {
+        private javax.net.ssl.SSLSocketFactory sslFactory = sslContext.getSocketFactory();
+
+        public Socket createSocket(Socket socket, String host, int port, boolean autoClose)
+          throws IOException, UnknownHostException {
+          return sslFactory.createSocket(socket, host, port, autoClose);
+        }
+
+        public Socket createSocket() throws IOException {
+          return sslFactory.createSocket();
+        }
+      };
+
+      sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
+      Scheme httpsScheme = new Scheme("https", sf, 443);
+      SchemeRegistry schemeRegistry = new SchemeRegistry();
+      schemeRegistry.register(httpsScheme);
+      schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
+
+      ignoreSSLConnectionManager = new SingleClientConnManager(new BasicHttpParams(), schemeRegistry);
+    } catch (NoSuchAlgorithmException e) {
+      // This will only be thrown if SSL isn't available for some reason.
+    } catch (KeyManagementException e) {
+      // This might be thrown when passing a key into init(), but no key is being passed.
+    } catch (GeneralSecurityException e) {
+      // This catches anything else that might go wrong.
+      // If anything goes wrong we default to the standard connection manager.
+    }
+  }
+}

modules/swagger-codegen/src/main/resources/android-java/httpPatch.mustache

@@ -0,0 +1,16 @@
+package {{invokerPackage}};
+
+import org.apache.http.client.methods.*;
+
+public class HttpPatch extends HttpPost {
+    public static final String METHOD_PATCH = "PATCH";
+
+    public HttpPatch(final String url) {
+        super(url);
+    }
+
+    @Override
+    public String getMethod() {
+        return METHOD_PATCH;
+    }
+}

modules/swagger-codegen/src/main/resources/android-java/jsonUtil.mustache

@@ -0,0 +1,20 @@
+package {{invokerPackage}};
+
+import com.fasterxml.jackson.annotation.*;
+import com.fasterxml.jackson.databind.*;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.fasterxml.jackson.core.JsonGenerator.Feature;
+
+public class JsonUtil {
+  public static ObjectMapper mapper;
+
+  static {
+    mapper = new ObjectMapper();
+    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+    mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
+  }
+
+  public static ObjectMapper getJsonMapper() {
+    return mapper;
+  }
+}

modules/swagger-codegen/src/main/resources/android-java/model.mustache

@@ -0,0 +1,47 @@
+package {{package}};
+
+{{#imports}}import {{import}};
+{{/imports}}
+
+import com.wordnik.swagger.annotations.*;
+{{#models}}
+
+{{#model}}{{#description}}
+/**
+ * {{description}}
+ **/{{/description}}
+@ApiModel(description = "{{{description}}}")
+public class {{classname}} {{#parent}}extends {{{parent}}}{{/parent}} { {{#vars}}
+  private {{{datatype}}} {{name}} = {{{defaultValue}}};{{#allowableValues}}
+  
+  //{{^min}}public enum {{name}}Enum { {{#values}} {{.}}, {{/values}} }; 
+  {{/min}}{{/allowableValues}}{{/vars}}
+  
+  {{#vars}}
+  /**{{#description}}
+   * {{{description}}}{{/description}}{{#minimum}}
+   * minimum: {{minimum}}{{/minimum}}{{#maximum}}
+   * maximum: {{maximum}}{{/maximum}}
+   **/
+  @ApiModelProperty(required = {{required}}, value = "{{{description}}}")
+  public {{{datatype}}} {{getter}}() {
+    return {{name}};
+  }
+  public void {{setter}}({{{datatype}}} {{name}}) {
+    this.{{name}} = {{name}};
+  }
+
+  {{/vars}}
+
+  @Override
+  public String toString()  {
+    StringBuilder sb = new StringBuilder();
+    sb.append("class {{classname}} {\n");
+    {{#parent}}sb.append("  " + super.toString()).append("\n");{{/parent}}
+    {{#vars}}sb.append("  {{name}}: ").append({{name}}).append("\n");
+    {{/vars}}sb.append("}\n");
+    return sb.toString();
+  }
+}
+{{/model}}
+{{/models}}

modules/swagger-codegen/src/main/resources/android-java/pom.mustache

@@ -0,0 +1,162 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>{{groupId}}</groupId>
+  <artifactId>{{artifactId}}</artifactId>
+  <packaging>jar</packaging>
+  <name>{{artifactId}}</name>
+  <version>{{artifactVersion}}</version>
+  <scm>
+    <connection>scm:git:git@github.com:wordnik/swagger-mustache.git</connection>
+    <developerConnection>scm:git:git@github.com:wordnik/swagger-codegen.git</developerConnection>
+    <url>https://github.com/wordnik/swagger-codegen</url>
+  </scm>
+  <prerequisites>
+    <maven>2.2.0</maven>
+  </prerequisites>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <version>2.12</version>
+        <configuration>
+          <systemProperties>
+            <property>
+              <name>loggerPath</name>
+              <value>conf/log4j.properties</value>
+            </property>
+          </systemProperties>
+          <argLine>-Xms512m -Xmx1500m</argLine>
+          <parallel>methods</parallel>
+          <forkMode>pertest</forkMode>
+        </configuration>
+      </plugin>
+      <plugin>
+        <artifactId>maven-dependency-plugin</artifactId>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>copy-dependencies</goal>
+            </goals>
+            <configuration>
+              <outputDirectory>${project.build.directory}/lib</outputDirectory>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+
+      <!-- attach test jar -->
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>2.2</version>
+        <executions>
+          <execution>
+            <goals>
+              <goal>jar</goal>
+              <goal>test-jar</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+        </configuration>
+      </plugin>
+
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>build-helper-maven-plugin</artifactId>
+        <executions>
+          <execution>
+            <id>add_sources</id>
+            <phase>generate-sources</phase>
+            <goals>
+              <goal>add-source</goal>
+            </goals>
+            <configuration>
+              <sources>
+                <source>src/main/java</source>
+              </sources>
+            </configuration>
+          </execution>
+          <execution>
+            <id>add_test_sources</id>
+            <phase>generate-test-sources</phase>
+            <goals>
+              <goal>add-test-source</goal>
+            </goals>
+            <configuration>
+              <sources>
+                <source>src/test/java</source>
+              </sources>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>2.3.2</version>
+        <configuration>
+          <source>1.6</source>
+          <target>1.6</target>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+  <dependencies>
+    <dependency>
+      <groupId>com.wordnik</groupId>
+      <artifactId>swagger-annotations</artifactId>
+      <version>${swagger-annotations-version}</version>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-core</artifactId>
+      <version>${jackson-version}</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-annotations</artifactId>
+      <version>${jackson-version}</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>${jackson-version}</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.httpcomponents</groupId>
+      <artifactId>httpclient</artifactId>
+      <version>${httpclient-version}</version>
+      <scope>compile</scope>
+    </dependency>
+
+    <!-- test dependencies -->
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>${junit-version}</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+  <repositories>
+    <repository>
+      <id>sonatype-snapshots</id>
+      <url>https://oss.sonatype.org/content/repositories/snapshots</url>
+    </repository>
+  </repositories>
+  <properties>
+    <swagger-annotations-version>1.5.0-SNAPSHOT</swagger-annotations-version>
+    <jackson-version>2.1.4</jackson-version>
+    <junit-version>4.8.1</junit-version>
+    <maven-plugin-version>1.0.0</maven-plugin-version>
+    <junit-version>4.8.1</junit-version>
+    <httpclient-version>4.0</httpclient-version>
+  </properties>
+</project>