#1809 adding samples with .sh and .bat scripts

bin/typescript-angular2-petstore.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+SCRIPT="$0"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l typescript-angular2 -o samples/client/petstore/typescript-angular2"
+
+java $JAVA_OPTS -jar $executable $ags

bin/windows/typescript-angular2.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\typescript-angular -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l typescript-angular2 -o samples\client\petstore\typescript-angular
+
+java %JAVA_OPTS% -jar %executable% %ags%

modules/swagger-codegen/src/main/resources/typescript-angular2/model.d.mustache

@@ -9,7 +9,7 @@ export * from './{{{ classname }}}';
 {{#apiInfo}}
 {{#apis}}
 {{#operations}}
-export * from './{{classname}}';
+export * from '../api/{{classname}}';
 {{/operations}}
 {{/apis}}
 {{/apiInfo}}

modules/swagger-codegen/src/main/resources/typescript-angular2/model.mustache

@@ -17,19 +17,21 @@ export interface {{classname}} {{#parent}}extends model.{{{parent}}} {{/parent}}
      */
 {{/description}}
 
-    {{name}}?: {{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{datatype}}}{{/isEnum}};
+    {{name}}?: {{#isEnum}}{{classname}}.{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{datatype}}}{{/isEnum}};
 {{/vars}}
 }
 
 {{#hasEnums}}
+export namespace {{classname}} {
 {{#vars}}
 {{#isEnum}}
 
-export enum {{datatypeWithEnum}} { {{#allowableValues}}{{#values}}
+    export enum {{datatypeWithEnum}} { {{#allowableValues}}{{#values}}
-    {{.}} = <any> '{{.}}',{{/values}}{{/allowableValues}}
+        {{.}} = <any> '{{.}}',{{/values}}{{/allowableValues}}
-}
+    }
 {{/isEnum}}
 {{/vars}}
+}
 {{/hasEnums}}
 {{/model}}
 {{/models}}

samples/client/petstore/typescript-angular2/api/PetApi.ts

@@ -0,0 +1,236 @@
+import {Http, Headers, RequestOptionsArgs, Response, URLSearchParams} from 'angular2/http';
+import {Injectable} from 'angular2/core';
+import {Observable} from 'rxjs/Observable';
+import * as model from "../model/model.d.ts"
+
+/* tslint:disable:no-unused-variable member-ordering */
+
+'use strict';
+
+@Injectable()
+export class PetApi {
+    protected basePath = 'http://petstore.swagger.io/v2';
+    public defaultHeaders : Headers = new Headers();
+
+    constructor(protected http: Http, basePath: string) {
+        if (basePath) {
+            this.basePath = basePath;
+        }
+    }
+
+    /**
+     * Add a new pet to the store
+     * 
+     * @param body Pet object that needs to be added to the store
+     */
+    public addPet (body?: model.Pet, extraHttpRequestParams?: any ) : Observable<{}> {
+        const path = this.basePath + '/pet';
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        let requestOptions: RequestOptionsArgs = {
+            method: 'POST',
+            headers: headerParams,
+            search: queryParameters
+        };
+        requestOptions.body = JSON.stringify(body);
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Deletes a pet
+     * 
+     * @param petId Pet id to delete
+     * @param apiKey 
+     */
+    public deletePet (petId: number, apiKey?: string, extraHttpRequestParams?: any ) : Observable<{}> {
+        const path = this.basePath + '/pet/{petId}'
+            .replace('{' + 'petId' + '}', String(petId));
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        // verify required parameter 'petId' is set
+        if (!petId) {
+            throw new Error('Missing required parameter petId when calling deletePet');
+        }
+            headerParams.set('api_key', apiKey);
+
+        let requestOptions: RequestOptionsArgs = {
+            method: 'DELETE',
+            headers: headerParams,
+            search: queryParameters
+        };
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Finds Pets by status
+     * Multiple status values can be provided with comma seperated strings
+     * @param status Status values that need to be considered for filter
+     */
+    public findPetsByStatus (status?: model.Array<string>, extraHttpRequestParams?: any ) : Observable<Array<model.Pet>> {
+        const path = this.basePath + '/pet/findByStatus';
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        if (status !== undefined) {
+            queryParameters['status'] = status;
+        }
+
+        let requestOptions: RequestOptionsArgs = {
+            method: 'GET',
+            headers: headerParams,
+            search: queryParameters
+        };
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Finds Pets by tags
+     * Muliple tags can be provided with comma seperated strings. Use tag1, tag2, tag3 for testing.
+     * @param tags Tags to filter by
+     */
+    public findPetsByTags (tags?: model.Array<string>, extraHttpRequestParams?: any ) : Observable<Array<model.Pet>> {
+        const path = this.basePath + '/pet/findByTags';
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        if (tags !== undefined) {
+            queryParameters['tags'] = tags;
+        }
+
+        let requestOptions: RequestOptionsArgs = {
+            method: 'GET',
+            headers: headerParams,
+            search: queryParameters
+        };
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Find pet by ID
+     * Returns a pet when ID &lt; 10.  ID &gt; 10 or nonintegers will simulate API error conditions
+     * @param petId ID of pet that needs to be fetched
+     */
+    public getPetById (petId: number, extraHttpRequestParams?: any ) : Observable<model.Pet> {
+        const path = this.basePath + '/pet/{petId}'
+            .replace('{' + 'petId' + '}', String(petId));
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        // verify required parameter 'petId' is set
+        if (!petId) {
+            throw new Error('Missing required parameter petId when calling getPetById');
+        }
+        let requestOptions: RequestOptionsArgs = {
+            method: 'GET',
+            headers: headerParams,
+            search: queryParameters
+        };
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Update an existing pet
+     * 
+     * @param body Pet object that needs to be added to the store
+     */
+    public updatePet (body?: model.Pet, extraHttpRequestParams?: any ) : Observable<{}> {
+        const path = this.basePath + '/pet';
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        let requestOptions: RequestOptionsArgs = {
+            method: 'PUT',
+            headers: headerParams,
+            search: queryParameters
+        };
+        requestOptions.body = JSON.stringify(body);
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Updates a pet in the store with form data
+     * 
+     * @param petId ID of pet that needs to be updated
+     * @param name Updated name of the pet
+     * @param status Updated status of the pet
+     */
+    public updatePetWithForm (petId: string, name?: string, status?: string, extraHttpRequestParams?: any ) : Observable<{}> {
+        const path = this.basePath + '/pet/{petId}'
+            .replace('{' + 'petId' + '}', String(petId));
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        let formParams = new URLSearchParams();
+
+        // verify required parameter 'petId' is set
+        if (!petId) {
+            throw new Error('Missing required parameter petId when calling updatePetWithForm');
+        }
+        headerParams.set('Content-Type', 'application/x-www-form-urlencoded');
+
+        formParams['name'] = name;
+
+        formParams['status'] = status;
+
+        let requestOptions: RequestOptionsArgs = {
+            method: 'POST',
+            headers: headerParams,
+            search: queryParameters
+        };
+        requestOptions.body = formParams.toString();
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * uploads an image
+     * 
+     * @param petId ID of pet to update
+     * @param additionalMetadata Additional data to pass to server
+     * @param file file to upload
+     */
+    public uploadFile (petId: number, additionalMetadata?: string, file?: model.any, extraHttpRequestParams?: any ) : Observable<{}> {
+        const path = this.basePath + '/pet/{petId}/uploadImage'
+            .replace('{' + 'petId' + '}', String(petId));
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        let formParams = new URLSearchParams();
+
+        // verify required parameter 'petId' is set
+        if (!petId) {
+            throw new Error('Missing required parameter petId when calling uploadFile');
+        }
+        headerParams.set('Content-Type', 'application/x-www-form-urlencoded');
+
+        formParams['additionalMetadata'] = additionalMetadata;
+
+        formParams['file'] = file;
+
+        let requestOptions: RequestOptionsArgs = {
+            method: 'POST',
+            headers: headerParams,
+            search: queryParameters
+        };
+        requestOptions.body = formParams.toString();
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+}

samples/client/petstore/typescript-angular2/api/StoreApi.ts

@@ -0,0 +1,111 @@
+import {Http, Headers, RequestOptionsArgs, Response, URLSearchParams} from 'angular2/http';
+import {Injectable} from 'angular2/core';
+import {Observable} from 'rxjs/Observable';
+import * as model from "../model/model.d.ts"
+
+/* tslint:disable:no-unused-variable member-ordering */
+
+'use strict';
+
+@Injectable()
+export class StoreApi {
+    protected basePath = 'http://petstore.swagger.io/v2';
+    public defaultHeaders : Headers = new Headers();
+
+    constructor(protected http: Http, basePath: string) {
+        if (basePath) {
+            this.basePath = basePath;
+        }
+    }
+
+    /**
+     * Delete purchase order by ID
+     * For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
+     * @param orderId ID of the order that needs to be deleted
+     */
+    public deleteOrder (orderId: string, extraHttpRequestParams?: any ) : Observable<{}> {
+        const path = this.basePath + '/store/order/{orderId}'
+            .replace('{' + 'orderId' + '}', String(orderId));
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        // verify required parameter 'orderId' is set
+        if (!orderId) {
+            throw new Error('Missing required parameter orderId when calling deleteOrder');
+        }
+        let requestOptions: RequestOptionsArgs = {
+            method: 'DELETE',
+            headers: headerParams,
+            search: queryParameters
+        };
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Returns pet inventories by status
+     * Returns a map of status codes to quantities
+     */
+    public getInventory (extraHttpRequestParams?: any ) : Observable<{ [key: string]: number; }> {
+        const path = this.basePath + '/store/inventory';
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        let requestOptions: RequestOptionsArgs = {
+            method: 'GET',
+            headers: headerParams,
+            search: queryParameters
+        };
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Find purchase order by ID
+     * For valid response try integer IDs with value &lt;&#x3D; 5 or &gt; 10. Other values will generated exceptions
+     * @param orderId ID of pet that needs to be fetched
+     */
+    public getOrderById (orderId: string, extraHttpRequestParams?: any ) : Observable<model.Order> {
+        const path = this.basePath + '/store/order/{orderId}'
+            .replace('{' + 'orderId' + '}', String(orderId));
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        // verify required parameter 'orderId' is set
+        if (!orderId) {
+            throw new Error('Missing required parameter orderId when calling getOrderById');
+        }
+        let requestOptions: RequestOptionsArgs = {
+            method: 'GET',
+            headers: headerParams,
+            search: queryParameters
+        };
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Place an order for a pet
+     * 
+     * @param body order placed for purchasing the pet
+     */
+    public placeOrder (body?: model.Order, extraHttpRequestParams?: any ) : Observable<model.Order> {
+        const path = this.basePath + '/store/order';
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        let requestOptions: RequestOptionsArgs = {
+            method: 'POST',
+            headers: headerParams,
+            search: queryParameters
+        };
+        requestOptions.body = JSON.stringify(body);
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+}

samples/client/petstore/typescript-angular2/api/UserApi.ts

@@ -0,0 +1,209 @@
+import {Http, Headers, RequestOptionsArgs, Response, URLSearchParams} from 'angular2/http';
+import {Injectable} from 'angular2/core';
+import {Observable} from 'rxjs/Observable';
+import * as model from "../model/model.d.ts"
+
+/* tslint:disable:no-unused-variable member-ordering */
+
+'use strict';
+
+@Injectable()
+export class UserApi {
+    protected basePath = 'http://petstore.swagger.io/v2';
+    public defaultHeaders : Headers = new Headers();
+
+    constructor(protected http: Http, basePath: string) {
+        if (basePath) {
+            this.basePath = basePath;
+        }
+    }
+
+    /**
+     * Create user
+     * This can only be done by the logged in user.
+     * @param body Created user object
+     */
+    public createUser (body?: model.User, extraHttpRequestParams?: any ) : Observable<{}> {
+        const path = this.basePath + '/user';
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        let requestOptions: RequestOptionsArgs = {
+            method: 'POST',
+            headers: headerParams,
+            search: queryParameters
+        };
+        requestOptions.body = JSON.stringify(body);
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Creates list of users with given input array
+     * 
+     * @param body List of user object
+     */
+    public createUsersWithArrayInput (body?: model.Array<model.User>, extraHttpRequestParams?: any ) : Observable<{}> {
+        const path = this.basePath + '/user/createWithArray';
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        let requestOptions: RequestOptionsArgs = {
+            method: 'POST',
+            headers: headerParams,
+            search: queryParameters
+        };
+        requestOptions.body = JSON.stringify(body);
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Creates list of users with given input array
+     * 
+     * @param body List of user object
+     */
+    public createUsersWithListInput (body?: model.Array<model.User>, extraHttpRequestParams?: any ) : Observable<{}> {
+        const path = this.basePath + '/user/createWithList';
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        let requestOptions: RequestOptionsArgs = {
+            method: 'POST',
+            headers: headerParams,
+            search: queryParameters
+        };
+        requestOptions.body = JSON.stringify(body);
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Delete user
+     * This can only be done by the logged in user.
+     * @param username The name that needs to be deleted
+     */
+    public deleteUser (username: string, extraHttpRequestParams?: any ) : Observable<{}> {
+        const path = this.basePath + '/user/{username}'
+            .replace('{' + 'username' + '}', String(username));
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        // verify required parameter 'username' is set
+        if (!username) {
+            throw new Error('Missing required parameter username when calling deleteUser');
+        }
+        let requestOptions: RequestOptionsArgs = {
+            method: 'DELETE',
+            headers: headerParams,
+            search: queryParameters
+        };
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Get user by user name
+     * 
+     * @param username The name that needs to be fetched. Use user1 for testing. 
+     */
+    public getUserByName (username: string, extraHttpRequestParams?: any ) : Observable<model.User> {
+        const path = this.basePath + '/user/{username}'
+            .replace('{' + 'username' + '}', String(username));
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        // verify required parameter 'username' is set
+        if (!username) {
+            throw new Error('Missing required parameter username when calling getUserByName');
+        }
+        let requestOptions: RequestOptionsArgs = {
+            method: 'GET',
+            headers: headerParams,
+            search: queryParameters
+        };
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Logs user into the system
+     * 
+     * @param username The user name for login
+     * @param password The password for login in clear text
+     */
+    public loginUser (username?: string, password?: string, extraHttpRequestParams?: any ) : Observable<string> {
+        const path = this.basePath + '/user/login';
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        if (username !== undefined) {
+            queryParameters['username'] = username;
+        }
+
+        if (password !== undefined) {
+            queryParameters['password'] = password;
+        }
+
+        let requestOptions: RequestOptionsArgs = {
+            method: 'GET',
+            headers: headerParams,
+            search: queryParameters
+        };
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Logs out current logged in user session
+     * 
+     */
+    public logoutUser (extraHttpRequestParams?: any ) : Observable<{}> {
+        const path = this.basePath + '/user/logout';
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        let requestOptions: RequestOptionsArgs = {
+            method: 'GET',
+            headers: headerParams,
+            search: queryParameters
+        };
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+    /**
+     * Updated user
+     * This can only be done by the logged in user.
+     * @param username name that need to be deleted
+     * @param body Updated user object
+     */
+    public updateUser (username: string, body?: model.User, extraHttpRequestParams?: any ) : Observable<{}> {
+        const path = this.basePath + '/user/{username}'
+            .replace('{' + 'username' + '}', String(username));
+
+        let queryParameters: any = ""; // This should probably be an object in the future
+        let headerParams = this.defaultHeaders;
+        // verify required parameter 'username' is set
+        if (!username) {
+            throw new Error('Missing required parameter username when calling updateUser');
+        }
+        let requestOptions: RequestOptionsArgs = {
+            method: 'PUT',
+            headers: headerParams,
+            search: queryParameters
+        };
+        requestOptions.body = JSON.stringify(body);
+
+        return this.http.request(path, requestOptions)
+            .map(response => response.json());
+    }
+
+}

samples/client/petstore/typescript-angular2/model/Category.ts

@@ -0,0 +1,12 @@
+'use strict';
+import * as model from "./model.d.ts"
+
+export interface Category {
+
+
+    id?: number;
+
+
+    name?: string;
+}
+

samples/client/petstore/typescript-angular2/model/Order.ts

@@ -0,0 +1,35 @@
+'use strict';
+import * as model from "./model.d.ts"
+
+export interface Order {
+
+
+    id?: number;
+
+
+    petId?: number;
+
+
+    quantity?: number;
+
+
+    shipDate?: Date;
+
+    /**
+     * Order Status
+     */
+
+    status?: Order.StatusEnum;
+
+
+    complete?: boolean;
+}
+
+export namespace Order {
+
+    export enum StatusEnum { 
+        placed = <any> 'placed',
+        approved = <any> 'approved',
+        delivered = <any> 'delivered',
+    }
+}

samples/client/petstore/typescript-angular2/model/Pet.ts

@@ -0,0 +1,35 @@
+'use strict';
+import * as model from "./model.d.ts"
+
+export interface Pet {
+
+
+    id?: number;
+
+
+    category?: model.Category;
+
+
+    name?: string;
+
+
+    photoUrls?: Array<string>;
+
+
+    tags?: Array<model.Tag>;
+
+    /**
+     * pet status in the store
+     */
+
+    status?: Pet.StatusEnum;
+}
+
+export namespace Pet {
+
+    export enum StatusEnum { 
+        available = <any> 'available',
+        pending = <any> 'pending',
+        sold = <any> 'sold',
+    }
+}

samples/client/petstore/typescript-angular2/model/Tag.ts

@@ -0,0 +1,12 @@
+'use strict';
+import * as model from "./model.d.ts"
+
+export interface Tag {
+
+
+    id?: number;
+
+
+    name?: string;
+}
+

samples/client/petstore/typescript-angular2/model/User.ts

@@ -0,0 +1,33 @@
+'use strict';
+import * as model from "./model.d.ts"
+
+export interface User {
+
+
+    id?: number;
+
+
+    username?: string;
+
+
+    firstName?: string;
+
+
+    lastName?: string;
+
+
+    email?: string;
+
+
+    password?: string;
+
+
+    phone?: string;
+
+    /**
+     * User Status
+     */
+
+    userStatus?: number;
+}
+

samples/client/petstore/typescript-angular2/model/model.d.ts

@@ -0,0 +1,13 @@
+export * from './Category';
+export * from './Order';
+export * from './Pet';
+export * from './Tag';
+export * from './User';
+
+
+
+export * from '../api/PetApi';
+export * from '../api/StoreApi';
+export * from '../api/UserApi';
+
+