loafle/openapi-generator-original
3
0
Fork 1
mirror of https://github.com/OpenAPITools/openapi-generator.git synced 2025-07-03 06:00:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1012 from tandrup/combine-ts-node

Browse Source 
Combine TypeScript Node output and beautify Angular output
This commit is contained in:
wing328 2015-07-27 17:24:34 +08:00
commit fe0e43f963
37 changed files with 2005 additions and 1525 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultCodegen.java
View File

@ -600,7 +600,7 @@ public class DefaultCodegen {
public CodegenProperty fromProperty(String name, Property p) {
if (p == null) {
LOGGER.error("unexpected missing property for name " + null);
LOGGER.error("unexpected missing property for name " + name);
return null;
}
CodegenProperty property = CodegenModelFactory.newInstance(CodegenModelType.PROPERTY);

143
modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/AbstractTypeScriptClientCodegen.java Normal file
View File

@ -0,0 +1,143 @@
package io.swagger.codegen.languages;
import io.swagger.codegen.*;
import io.swagger.models.properties.*;
import java.util.*;
import java.io.File;
public abstract class AbstractTypeScriptClientCodegen extends DefaultCodegen implements CodegenConfig {
@Override
public CodegenType getTag() {
return CodegenType.CLIENT;
}
public AbstractTypeScriptClientCodegen() {
super();
reservedWords = new HashSet<String>(Arrays.asList("abstract",
"continue", "for", "new", "switch", "assert", "default", "if",
"package", "synchronized", "do", "goto", "private",
"this", "break", "double", "implements", "protected", "throw",
"byte", "else", "import", "public", "throws", "case", "enum",
"instanceof", "return", "transient", "catch", "extends", "int",
"short", "try", "char", "final", "interface", "static", "void",
"class", "finally", "const", "super", "while"));
languageSpecificPrimitives = new HashSet<String>(Arrays.asList(
"String",
"boolean",
"Boolean",
"Double",
"Integer",
"Long",
"Float",
"Object"));
instantiationTypes.put("array", "Array");
typeMapping = new HashMap<String, String>();
typeMapping.put("Array", "Array");
typeMapping.put("array", "Array");
typeMapping.put("List", "Array");
typeMapping.put("boolean", "boolean");
typeMapping.put("string", "string");
typeMapping.put("int", "number");
typeMapping.put("float", "number");
typeMapping.put("number", "number");
typeMapping.put("long", "number");
typeMapping.put("short", "number");
typeMapping.put("char", "string");
typeMapping.put("double", "number");
typeMapping.put("object", "any");
typeMapping.put("integer", "number");
typeMapping.put("Map", "any");
typeMapping.put("DateTime", "Date");
}
@Override
public String escapeReservedWord(String name) {
return "_" + name;
}
@Override
public String apiFileFolder() {
return outputFolder + "/" + apiPackage().replace('.', File.separatorChar);
}
public String modelFileFolder() {
return outputFolder + "/" + modelPackage().replace('.', File.separatorChar);
}
@Override
public String toVarName(String name) {
// replace - with _ e.g. created-at => created_at
name = name.replaceAll("-", "_");
// if it's all uppper case, do nothing
if (name.matches("^[A-Z_]*$"))
return name;
// camelize the variable name
// pet_id => PetId
name = camelize(name, true);
// for reserved word or word starting with number, append _
if (reservedWords.contains(name) || name.matches("^\\d.*"))
name = escapeReservedWord(name);
return name;
}
@Override
public String toParamName(String name) {
// should be the same as variable name
return toVarName(name);
}
@Override
public String toModelName(String name) {
// model name cannot use reserved keyword, e.g. return
if (reservedWords.contains(name))
throw new RuntimeException(name
+ " (reserved word) cannot be used as a model name");
// camelize the model name
// phone_number => PhoneNumber
return camelize(name);
}
@Override
public String toModelFilename(String name) {
// should be the same as the model name
return toModelName(name);
}
@Override
public String getTypeDeclaration(Property p) {
if (p instanceof ArrayProperty) {
ArrayProperty ap = (ArrayProperty) p;
Property inner = ap.getItems();
return getSwaggerType(p) + "<" + getTypeDeclaration(inner) + ">";
} else if (p instanceof MapProperty) {
MapProperty mp = (MapProperty) p;
Property inner = mp.getAdditionalProperties();
return "{ [key: string]: "+ getTypeDeclaration(inner) + "; }";
} else if (p instanceof FileProperty) {
return "any";
}
return super.getTypeDeclaration(p);
}
@Override
public String getSwaggerType(Property p) {
String swaggerType = super.getSwaggerType(p);
String type = null;
if (typeMapping.containsKey(swaggerType)) {
type = typeMapping.get(swaggerType);
if (languageSpecificPrimitives.contains(type))
return type;
} else
type = swaggerType;
return type;
}
}

19
modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/TypeScriptAngularClientCodegen.java
View File

@ -1,25 +1,28 @@
package io.swagger.codegen.languages;
import java.io.File;
import io.swagger.codegen.SupportingFile;
public class TypeScriptAngularClientCodegen extends TypeScriptNodeClientCodegen {
import java.io.File;
public class TypeScriptAngularClientCodegen extends AbstractTypeScriptClientCodegen {
@Override
public String getName() {
return "typescript-angular";
}
public String getHelp() {
return "Generates a TypeScript AngurlarJS client library.";
}
public TypeScriptAngularClientCodegen() {
super();
outputFolder = "generated-code/typescript-angular";
modelTemplateFiles.put("model.mustache", ".ts");
apiTemplateFiles.put("api.mustache", ".ts");
templateDir = "TypeScript-Angular";
apiPackage = "api";
modelPackage = "model";
supportingFiles.add(new SupportingFile("api.d.mustache", apiPackage + File.separator, "api.d.ts"));
apiPackage = "API.Client";
modelPackage = "API.Client";
supportingFiles.add(new SupportingFile("api.d.mustache", apiPackage().replace('.', File.separatorChar), "api.d.ts"));
}
}

179
modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/TypeScriptNodeClientCodegen.java
View File

@ -1,171 +1,24 @@
package io.swagger.codegen.languages;
import io.swagger.codegen.*;
import io.swagger.models.properties.*;
import io.swagger.codegen.SupportingFile;
import java.util.*;
import java.io.File;
public class TypeScriptNodeClientCodegen extends AbstractTypeScriptClientCodegen {
public class TypeScriptNodeClientCodegen extends DefaultCodegen implements CodegenConfig {
protected String invokerPackage = "io.swagger.client";
protected String groupId = "io.swagger";
protected String artifactId = "swagger-typescript-node-client";
protected String artifactVersion = "1.0.0";
protected String sourceFolder = "src/main/typescript";
@Override
public String getName() {
return "typescript-node";
}
@Override
public CodegenType getTag() {
return CodegenType.CLIENT;
}
@Override
public String getHelp() {
return "Generates a TypeScript nodejs client library.";
}
@Override
public String getName() {
return "typescript-node";
}
public TypeScriptNodeClientCodegen() {
super();
outputFolder = "generated-code/typescript-node";
templateDir = "TypeScript-node";
supportingFiles.add(new SupportingFile("api.mustache", null, "api.ts"));
}
@Override
public String getHelp() {
return "Generates a TypeScript nodejs client library.";
}
public TypeScriptNodeClientCodegen() {
super();
outputFolder = "generated-code/typescript-node";
modelTemplateFiles.put("model.mustache", ".ts");
apiTemplateFiles.put("api.mustache", ".ts");
templateDir = "TypeScript-node";
apiPackage = "api";
modelPackage = "model";
reservedWords = new HashSet<String>(Arrays.asList("abstract",
"continue", "for", "new", "switch", "assert", "default", "if",
"package", "synchronized", "do", "goto", "private",
"this", "break", "double", "implements", "protected", "throw",
"byte", "else", "import", "public", "throws", "case", "enum",
"instanceof", "return", "transient", "catch", "extends", "int",
"short", "try", "char", "final", "interface", "static", "void",
"class", "finally", "const", "super", "while"));
additionalProperties.put("invokerPackage", invokerPackage);
additionalProperties.put("groupId", groupId);
additionalProperties.put("artifactId", artifactId);
additionalProperties.put("artifactVersion", artifactVersion);
languageSpecificPrimitives = new HashSet<String>(Arrays.asList(
"String",
"boolean",
"Boolean",
"Double",
"Integer",
"Long",
"Float",
"Object"));
instantiationTypes.put("array", "Array");
typeMapping = new HashMap<String, String>();
typeMapping.put("Array", "Array");
typeMapping.put("array", "Array");
typeMapping.put("List", "Array");
typeMapping.put("boolean", "boolean");
typeMapping.put("string", "string");
typeMapping.put("int", "number");
typeMapping.put("float", "number");
typeMapping.put("number", "number");
typeMapping.put("long", "number");
typeMapping.put("short", "number");
typeMapping.put("char", "string");
typeMapping.put("double", "number");
typeMapping.put("object", "any");
typeMapping.put("integer", "number");
typeMapping.put("Map", "any");
typeMapping.put("DateTime", "Date");
}
@Override
public String escapeReservedWord(String name) {
return "_" + name;
}
@Override
public String apiFileFolder() {
return outputFolder + "/" + apiPackage().replace('.', File.separatorChar);
}
public String modelFileFolder() {
return outputFolder + "/" + modelPackage().replace('.', File.separatorChar);
}
@Override
public String toVarName(String name) {
// replace - with _ e.g. created-at => created_at
name = name.replaceAll("-", "_");
// if it's all uppper case, do nothing
if (name.matches("^[A-Z_]*$"))
return name;
// camelize the variable name
// pet_id => PetId
name = camelize(name, true);
// for reserved word or word starting with number, append _
if (reservedWords.contains(name) || name.matches("^\\d.*"))
name = escapeReservedWord(name);
return name;
}
@Override
public String toParamName(String name) {
// should be the same as variable name
return toVarName(name);
}
@Override
public String toModelName(String name) {
// model name cannot use reserved keyword, e.g. return
if (reservedWords.contains(name))
throw new RuntimeException(name
+ " (reserved word) cannot be used as a model name");
// camelize the model name
// phone_number => PhoneNumber
return camelize(name);
}
@Override
public String toModelFilename(String name) {
// should be the same as the model name
return toModelName(name);
}
@Override
public String getTypeDeclaration(Property p) {
if (p instanceof ArrayProperty) {
ArrayProperty ap = (ArrayProperty) p;
Property inner = ap.getItems();
return getSwaggerType(p) + "<" + getTypeDeclaration(inner) + ">";
} else if (p instanceof MapProperty) {
MapProperty mp = (MapProperty) p;
Property inner = mp.getAdditionalProperties();
return getSwaggerType(p) + "<String, " + getTypeDeclaration(inner)
+ ">";
}
return super.getTypeDeclaration(p);
}
@Override
public String getSwaggerType(Property p) {
String swaggerType = super.getSwaggerType(p);
String type = null;
if (typeMapping.containsKey(swaggerType)) {
type = typeMapping.get(swaggerType);
if (languageSpecificPrimitives.contains(type))
return type;
} else
type = swaggerType;
return type;
}
}

35
modules/swagger-codegen/src/main/resources/TypeScript-Angular/api.mustache
View File

@ -6,11 +6,11 @@
module {{package}} {
'use strict';
{{#description}}
{{#description}}
/**
* {{&description}}
*/
{{/description}}
{{/description}}
export class {{classname}} {
private basePath = '{{contextPath}}';
@ -21,24 +21,37 @@ module {{package}} {
this.basePath = basePath;
}
}
{{#operation}}
{{#operation}}
public {{nickname}} ({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}extraHttpRequestParams?: any ) : ng.IHttpPromise<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}{}{{/returnType}}> {
var path = this.basePath + '{{path}}';
{{#pathParams}}
{{#pathParams}}
path = path.replace('{' + '{{paramName}}' + '}', String({{paramName}}));
{{/pathParams}}
{{/pathParams}}
var queryParameters: any = {};
var headerParams: any = {};
{{#allParams}}{{#required}}
{{#allParams}}
{{#required}}
// verify required parameter '{{paramName}}' is set
if (!{{paramName}}) {
throw new Error('Missing required parameter {{paramName}} when calling {{nickname}}');
}
{{/required}}{{/allParams}}
{{#queryParams}}if ({{paramName}} !== undefined) {
{{/required}}
{{/allParams}}
{{#queryParams}}
if ({{paramName}} !== undefined) {
queryParameters['{{paramName}}'] = {{paramName}};
}{{/queryParams}}
{{#headerParams}}headerParams['{{paramName}}'] = {{paramName}};{{/headerParams}}
}
{{/queryParams}}
{{#headerParams}}
headerParams['{{paramName}}'] = {{paramName}};
{{/headerParams}}
var httpRequestParams: any = {
method: '{{httpMethod}}',
url: path,
@ -59,7 +72,7 @@ module {{package}} {
return this.$http(httpRequestParams);
}
{{/operation}}
{{/operation}}
}
}
{{/operations}}

286
modules/swagger-codegen/src/main/resources/TypeScript-node/api.mustache
View File

@ -1,73 +1,245 @@
import request = require('request');
import promise = require('bluebird');
import http = require('http');
// ===============================================
// This file is autogenerated - Please do not edit
// ===============================================
/* tslint:disable:no-unused-variable */
{{#operations}}
{{#models}}
{{#model}}
{{#description}}
/**
* {{{description}}}
*/
{{/description}}
export class {{classname}} {{#parent}}extends {{{parent}}} {{/parent}}{
{{#vars}}
{{#description}}
/**
* {{&description}}
* {{{description}}}
*/
{{/description}}
{{name}}: {{#isEnum}}{{classname}}.{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{datatype}}}{{/isEnum}};
{{/vars}}
}
{{#hasEnums}}
export module {{classname}} {
{{#vars}}
{{#isEnum}}
export enum {{datatypeWithEnum}} { {{#allowableValues}}{{#values}}
{{.}} = <any> '{{.}}',{{/values}}{{/allowableValues}}
}
{{/isEnum}}
{{/vars}}
}
{{/hasEnums}}
{{/model}}
{{/models}}
interface Authentication {
/**
* Apply authentication settings to header and query params.
*/
applyToRequest(requestOptions: request.Options): void;
}
class HttpBasicAuth implements Authentication {
public username: string;
public password: string;
applyToRequest(requestOptions: request.Options): void {
requestOptions.auth = {
username: this.username, password: this.password
}
}
}
class ApiKeyAuth implements Authentication {
public apiKey: string;
constructor(private location: string, private paramName: string) {
}
applyToRequest(requestOptions: request.Options): void {
if (this.location == "query") {
(<any>requestOptions.qs)[this.paramName] = this.apiKey;
} else if (this.location == "header") {
requestOptions.headers[this.paramName] = this.apiKey;
}
}
}
class OAuth implements Authentication {
applyToRequest(requestOptions: request.Options): void {
// TODO: support oauth
}
}
class VoidAuth implements Authentication {
public username: string;
public password: string;
applyToRequest(requestOptions: request.Options): void {
// Do nothing
}
}
{{#apiInfo}}
{{#apis}}
{{#operations}}
{{#description}}
/**
* {{&description}}
*/
{{/description}}
export class {{classname}} {
private basePath = '{{contextPath}}';
constructor(private url: string, private username: string, private password: string, basePath?: string) {
if (basePath) {
this.basePath = basePath;
}
public authentications = {
'default': <Authentication>new VoidAuth(),
{{#authMethods}}
{{#isBasic}}
'{{name}}': new HttpBasicAuth(),
{{/isBasic}}
{{#isApiKey}}
'{{name}}': new ApiKeyAuth({{#isKeyInHeader}}'header'{{/isKeyInHeader}}{{^isKeyInHeader}}'query'{{/isKeyInHeader}}, '{{keyParamName}}'),
{{/isApiKey}}
{{#isOAuth}}
'{{name}}': new OAuth(),
{{/isOAuth}}
{{/authMethods}}
}
{{#operation}}
public {{nickname}} ({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}{{#hasMore}}, {{/hasMore}}{{/allParams}}) : Promise<{ response: http.ClientResponse; {{#returnType}}body: {{{returnType}}}; {{/returnType}} }> {
var path = this.url + this.basePath + '{{path}}';
{{#pathParams}}
path = path.replace('{' + '{{paramName}}' + '}', String({{paramName}}));
{{/pathParams}}
var queryParameters: any = {};
var headerParams: any = {};
{{#allParams}}{{#required}}
// verify required parameter '{{paramName}}' is set
if (!{{paramName}}) {
throw new Error('Missing required parameter {{paramName}} when calling {{nickname}}');
}
{{/required}}{{/allParams}}
{{#queryParams}}if ({{paramName}} !== undefined) {
queryParameters['{{paramName}}'] = {{paramName}};
}
{{/queryParams}}
{{#headerParams}}headerParams['{{paramName}}'] = {{paramName}};
{{/headerParams}}
var deferred = promise.defer<{ response: http.ClientResponse; {{#returnType}}body: {{{returnType}}}; {{/returnType}} }>();
request({
method: '{{httpMethod}}',
qs: queryParameters,
uri: path,
json: true,
{{#bodyParam}}body: {{paramName}},
{{/bodyParam}}
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
constructor(url: string, basePath?: string);
{{#authMethods}}
{{#isBasic}}
constructor(url: string, username: string, password: string, basePath?: string);
{{/isBasic}}
{{/authMethods}}
constructor(private url: string, basePathOrUsername: string, password?: string, basePath?: string) {
if (password) {
{{#authMethods}}
{{#isBasic}}
this.username = basePathOrUsername;
this.password = password
{{/isBasic}}
{{/authMethods}}
if (basePath) {
this.basePath = basePath;
}
} else {
deferred.reject({ response: response, body: body });
if (basePathOrUsername) {
this.basePath = basePathOrUsername
}
}
}
});
}
{{#authMethods}}
{{#isBasic}}
return deferred.promise;
}
set username(username: string) {
this.authentications.{{name}}.username = username;
}
{{/operation}}
set password(password: string) {
this.authentications.{{name}}.password = password;
}
{{/isBasic}}
{{#isApiKey}}
set apiKey(key: string) {
this.authentications.{{name}}.apiKey = key;
}
{{/isApiKey}}
{{#isOAuth}}
{{/isOAuth}}
{{/authMethods}}
{{#operation}}
public {{nickname}} ({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}{{#hasMore}}, {{/hasMore}}{{/allParams}}) : Promise<{ response: http.ClientResponse; {{#returnType}}body: {{{returnType}}}; {{/returnType}} }> {
var path = this.url + this.basePath + '{{path}}';
{{#pathParams}}
path = path.replace('{' + '{{paramName}}' + '}', String({{paramName}}));
{{/pathParams}}
var queryParameters: any = {};
var headerParams: any = {};
var formParams: any = {};
{{#allParams}}
{{#required}}
// verify required parameter '{{paramName}}' is set
if (!{{paramName}}) {
throw new Error('Missing required parameter {{paramName}} when calling {{nickname}}');
}
{{/required}}
{{/allParams}}
{{#queryParams}}
if ({{paramName}} !== undefined) {
queryParameters['{{paramName}}'] = {{paramName}};
}
{{/queryParams}}
{{#headerParams}}
headerParams['{{paramName}}'] = {{paramName}};
{{/headerParams}}
var useFormData = false;
{{#formParams}}
if ({{paramName}} !== undefined) {
formParams['{{paramName}}'] = {{paramName}};
}
{{#isFile}}
useFormData = true;
{{/isFile}}
{{/formParams}}
var deferred = promise.defer<{ response: http.ClientResponse; {{#returnType}}body: {{{returnType}}}; {{/returnType}} }>();
var requestOptions: request.Options = {
method: '{{httpMethod}}',
qs: queryParameters,
headers: headerParams,
uri: path,
json: true,
{{#bodyParam}}
body: {{paramName}},
{{/bodyParam}}
}
{{#authMethods}}
this.authentications.{{name}}.applyToRequest(requestOptions);
{{/authMethods}}
this.authentications.default.applyToRequest(requestOptions);
if (Object.keys(formParams).length) {
if (useFormData) {
(<any>requestOptions).formData = formParams;
} else {
requestOptions.form = formParams;
}
}
request(requestOptions, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
{{/operation}}
}
{{/operations}}
{{/apis}}
{{/apiInfo}}

33
modules/swagger-codegen/src/main/resources/TypeScript-node/model.mustache
View File

@ -1,33 +0,0 @@
{{#models}}
{{#model}}
{{#description}}
/**
* {{{description}}}
*/
{{/description}}
export class {{classname}} {{#parent}}extends {{{parent}}} {{/parent}}{
{{#vars}}
{{#description}}
/**
* {{{description}}}
*/
{{/description}}
{{name}}: {{#isEnum}}{{classname}}.{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{datatype}}}{{/isEnum}};
{{/vars}}
}
{{#hasEnums}}
export module {{classname}} {
{{#vars}}
{{#isEnum}}
export enum {{datatypeWithEnum}} { {{#allowableValues}}{{#values}}
{{.}} = <any> '{{.}}',{{/values}}{{/allowableValues}}
}
{{/isEnum}}
{{/vars}}
}
{{/hasEnums}}
{{/model}}
{{/models}}

3
samples/client/petstore/typescript-angular/.gitignore vendored Normal file
View File

@ -0,0 +1,3 @@
/node_modules
/typings
/client.js

2
samples/client/petstore/typescript-angular/api/Category.ts → samples/client/petstore/typescript-angular/API/Client/Category.ts
View File

@ -1,6 +1,6 @@
/// <reference path="api.d.ts" />
module api {
module API.Client {
'use strict';
export class Category {

4
samples/client/petstore/typescript-angular/api/Order.ts → samples/client/petstore/typescript-angular/API/Client/Order.ts
View File

@ -1,6 +1,6 @@
/// <reference path="api.d.ts" />
module api {
module API.Client {
'use strict';
export class Order {
@ -11,7 +11,7 @@ module api {
quantity: number;
shipDate: DateTime;
shipDate: Date;
/**
* Order Status

2
samples/client/petstore/typescript-angular/api/Pet.ts → samples/client/petstore/typescript-angular/API/Client/Pet.ts
View File

@ -1,6 +1,6 @@
/// <reference path="api.d.ts" />
module api {
module API.Client {
'use strict';
export class Pet {

153
samples/client/petstore/typescript-angular/api/PetApi.ts → samples/client/petstore/typescript-angular/API/Client/PetApi.ts
View File

@ -2,12 +2,11 @@
/* tslint:disable:no-unused-variable member-ordering */
module api {
module API.Client {
'use strict';
export class PetApi {
private basePath = 'http://petstore.swagger.io/v2';
private basePath = '/v2';
static $inject: string[] = ['$http'];
@ -16,15 +15,13 @@ module api {
this.basePath = basePath;
}
}
public updatePet (body: Pet, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
public updatePet (body?: Pet, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
var path = this.basePath + '/pet';
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
var httpRequestParams: any = {
method: 'PUT',
url: path,
@ -32,11 +29,11 @@ module api {
data: body,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -45,15 +42,13 @@ module api {
return this.$http(httpRequestParams);
}
public addPet (body: Pet, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
public addPet (body?: Pet, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
var path = this.basePath + '/pet';
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
var httpRequestParams: any = {
method: 'POST',
url: path,
@ -61,11 +56,11 @@ module api {
data: body,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -74,28 +69,28 @@ module api {
return this.$http(httpRequestParams);
}
public findPetsByStatus (status: Array<string>, extraHttpRequestParams?: any ) : ng.IHttpPromise<Array<Pet>> {
public findPetsByStatus (status?: Array<string>, extraHttpRequestParams?: any ) : ng.IHttpPromise<Array<Pet>> {
var path = this.basePath + '/pet/findByStatus';
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
if (status !== undefined) {
queryParameters['status'] = status;
}
var httpRequestParams: any = {
method: 'GET',
url: path,
json: true,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -104,28 +99,28 @@ module api {
return this.$http(httpRequestParams);
}
public findPetsByTags (tags: Array<string>, extraHttpRequestParams?: any ) : ng.IHttpPromise<Array<Pet>> {
public findPetsByTags (tags?: Array<string>, extraHttpRequestParams?: any ) : ng.IHttpPromise<Array<Pet>> {
var path = this.basePath + '/pet/findByTags';
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
if (tags !== undefined) {
queryParameters['tags'] = tags;
}
var httpRequestParams: any = {
method: 'GET',
url: path,
json: true,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -134,33 +129,31 @@ module api {
return this.$http(httpRequestParams);
}
public getPetById (petId: number, extraHttpRequestParams?: any ) : ng.IHttpPromise<Pet> {
public getPetById (petId: number, extraHttpRequestParams?: any ) : ng.IHttpPromise<Pet> {
var path = this.basePath + '/pet/{petId}';
path = path.replace('{' + 'petId' + '}', String(petId));
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
// verify required parameter 'petId' is set
if (!petId) {
throw new Error('Missing required parameter petId when calling getPetById');
}
var httpRequestParams: any = {
method: 'GET',
url: path,
json: true,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -169,33 +162,31 @@ module api {
return this.$http(httpRequestParams);
}
public updatePetWithForm (petId: string, name: string, status: string, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
public updatePetWithForm (petId: string, name?: string, status?: string, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
var path = this.basePath + '/pet/{petId}';
path = path.replace('{' + 'petId' + '}', String(petId));
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
// verify required parameter 'petId' is set
if (!petId) {
throw new Error('Missing required parameter petId when calling updatePetWithForm');
}
var httpRequestParams: any = {
method: 'POST',
url: path,
json: true,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -204,33 +195,33 @@ module api {
return this.$http(httpRequestParams);
}
public deletePet (apiKey: string, petId: number, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
public deletePet (petId: number, apiKey?: string, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
var path = this.basePath + '/pet/{petId}';
path = path.replace('{' + 'petId' + '}', String(petId));
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
// verify required parameter 'petId' is set
if (!petId) {
throw new Error('Missing required parameter petId when calling deletePet');
}
headerParams['apiKey'] = apiKey;
var httpRequestParams: any = {
method: 'DELETE',
url: path,
json: true,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -239,33 +230,31 @@ module api {
return this.$http(httpRequestParams);
}
public uploadFile (petId: number, additionalMetadata: string, file: file, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
public uploadFile (petId: number, additionalMetadata?: string, file?: any, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
var path = this.basePath + '/pet/{petId}/uploadImage';
path = path.replace('{' + 'petId' + '}', String(petId));
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
// verify required parameter 'petId' is set
if (!petId) {
throw new Error('Missing required parameter petId when calling uploadFile');
}
var httpRequestParams: any = {
method: 'POST',
url: path,
json: true,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -274,9 +263,5 @@ module api {
return this.$http(httpRequestParams);
}
}
angular.module('api_PetApi', ['$http'])
.service('PetApi', PetApi);
}

81
samples/client/petstore/typescript-angular/api/StoreApi.ts → samples/client/petstore/typescript-angular/API/Client/StoreApi.ts
View File

@ -2,12 +2,11 @@
/* tslint:disable:no-unused-variable member-ordering */
module api {
module API.Client {
'use strict';
export class StoreApi {
private basePath = 'http://petstore.swagger.io/v2';
private basePath = '/v2';
static $inject: string[] = ['$http'];
@ -16,26 +15,24 @@ module api {
this.basePath = basePath;
}
}
public getInventory ( extraHttpRequestParams?: any ) : ng.IHttpPromise<map<String, number>> {
public getInventory (extraHttpRequestParams?: any ) : ng.IHttpPromise<{ [key: string]: number; }> {
var path = this.basePath + '/store/inventory';
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
var httpRequestParams: any = {
method: 'GET',
url: path,
json: true,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -44,15 +41,13 @@ module api {
return this.$http(httpRequestParams);
}
public placeOrder (body: Order, extraHttpRequestParams?: any ) : ng.IHttpPromise<Order> {
public placeOrder (body?: Order, extraHttpRequestParams?: any ) : ng.IHttpPromise<Order> {
var path = this.basePath + '/store/order';
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
var httpRequestParams: any = {
method: 'POST',
url: path,
@ -60,11 +55,11 @@ module api {
data: body,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -73,33 +68,31 @@ module api {
return this.$http(httpRequestParams);
}
public getOrderById (orderId: string, extraHttpRequestParams?: any ) : ng.IHttpPromise<Order> {
public getOrderById (orderId: string, extraHttpRequestParams?: any ) : ng.IHttpPromise<Order> {
var path = this.basePath + '/store/order/{orderId}';
path = path.replace('{' + 'orderId' + '}', String(orderId));
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
// verify required parameter 'orderId' is set
if (!orderId) {
throw new Error('Missing required parameter orderId when calling getOrderById');
}
var httpRequestParams: any = {
method: 'GET',
url: path,
json: true,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -108,33 +101,31 @@ module api {
return this.$http(httpRequestParams);
}
public deleteOrder (orderId: string, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
public deleteOrder (orderId: string, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
var path = this.basePath + '/store/order/{orderId}';
path = path.replace('{' + 'orderId' + '}', String(orderId));
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
// verify required parameter 'orderId' is set
if (!orderId) {
throw new Error('Missing required parameter orderId when calling deleteOrder');
}
var httpRequestParams: any = {
method: 'DELETE',
url: path,
json: true,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -143,9 +134,5 @@ module api {
return this.$http(httpRequestParams);
}
}
angular.module('api_StoreApi', ['$http'])
.service('StoreApi', StoreApi);
}

2
samples/client/petstore/typescript-angular/api/Tag.ts → samples/client/petstore/typescript-angular/API/Client/Tag.ts
View File

@ -1,6 +1,6 @@
/// <reference path="api.d.ts" />
module api {
module API.Client {
'use strict';
export class Tag {

2
samples/client/petstore/typescript-angular/api/User.ts → samples/client/petstore/typescript-angular/API/Client/User.ts
View File

@ -1,6 +1,6 @@
/// <reference path="api.d.ts" />
module api {
module API.Client {
'use strict';
export class User {

153
samples/client/petstore/typescript-angular/api/UserApi.ts → samples/client/petstore/typescript-angular/API/Client/UserApi.ts
View File

@ -2,12 +2,11 @@
/* tslint:disable:no-unused-variable member-ordering */
module api {
module API.Client {
'use strict';
export class UserApi {
private basePath = 'http://petstore.swagger.io/v2';
private basePath = '/v2';
static $inject: string[] = ['$http'];
@ -16,15 +15,13 @@ module api {
this.basePath = basePath;
}
}
public createUser (body: User, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
public createUser (body?: User, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
var path = this.basePath + '/user';
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
var httpRequestParams: any = {
method: 'POST',
url: path,
@ -32,11 +29,11 @@ module api {
data: body,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -45,15 +42,13 @@ module api {
return this.$http(httpRequestParams);
}
public createUsersWithArrayInput (body: Array<User>, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
public createUsersWithArrayInput (body?: Array<User>, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
var path = this.basePath + '/user/createWithArray';
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
var httpRequestParams: any = {
method: 'POST',
url: path,
@ -61,11 +56,11 @@ module api {
data: body,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -74,15 +69,13 @@ module api {
return this.$http(httpRequestParams);
}
public createUsersWithListInput (body: Array<User>, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
public createUsersWithListInput (body?: Array<User>, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
var path = this.basePath + '/user/createWithList';
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
var httpRequestParams: any = {
method: 'POST',
url: path,
@ -90,11 +83,11 @@ module api {
data: body,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -103,30 +96,32 @@ module api {
return this.$http(httpRequestParams);
}
public loginUser (username: string, password: string, extraHttpRequestParams?: any ) : ng.IHttpPromise<string> {
public loginUser (username?: string, password?: string, extraHttpRequestParams?: any ) : ng.IHttpPromise<string> {
var path = this.basePath + '/user/login';
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
if (username !== undefined) {
queryParameters['username'] = username;
}if (password !== undefined) {
}
if (password !== undefined) {
queryParameters['password'] = password;
}
var httpRequestParams: any = {
method: 'GET',
url: path,
json: true,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -135,26 +130,24 @@ module api {
return this.$http(httpRequestParams);
}
public logoutUser ( extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
public logoutUser (extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
var path = this.basePath + '/user/logout';
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
var httpRequestParams: any = {
method: 'GET',
url: path,
json: true,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -163,33 +156,31 @@ module api {
return this.$http(httpRequestParams);
}
public getUserByName (username: string, extraHttpRequestParams?: any ) : ng.IHttpPromise<User> {
public getUserByName (username: string, extraHttpRequestParams?: any ) : ng.IHttpPromise<User> {
var path = this.basePath + '/user/{username}';
path = path.replace('{' + 'username' + '}', String(username));
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
// verify required parameter 'username' is set
if (!username) {
throw new Error('Missing required parameter username when calling getUserByName');
}
var httpRequestParams: any = {
method: 'GET',
url: path,
json: true,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -198,22 +189,20 @@ module api {
return this.$http(httpRequestParams);
}
public updateUser (username: string, body: User, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
public updateUser (username: string, body?: User, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
var path = this.basePath + '/user/{username}';
path = path.replace('{' + 'username' + '}', String(username));
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
// verify required parameter 'username' is set
if (!username) {
throw new Error('Missing required parameter username when calling updateUser');
}
var httpRequestParams: any = {
method: 'PUT',
url: path,
@ -221,11 +210,11 @@ module api {
data: body,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -234,33 +223,31 @@ module api {
return this.$http(httpRequestParams);
}
public deleteUser (username: string, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
public deleteUser (username: string, extraHttpRequestParams?: any ) : ng.IHttpPromise<{}> {
var path = this.basePath + '/user/{username}';
path = path.replace('{' + 'username' + '}', String(username));
var queryParameters: any = {};
var headers: any = {};
var headerParams: any = {};
// verify required parameter 'username' is set
if (!username) {
throw new Error('Missing required parameter username when calling deleteUser');
}
var httpRequestParams: any = {
method: 'DELETE',
url: path,
json: true,
params: queryParameters,
headers: headers
headers: headerParams
};
if (extraHttpRequestParams) {
for (var k in extraHttpRequestParams){
for (var k in extraHttpRequestParams) {
if (extraHttpRequestParams.hasOwnProperty(k)) {
httpRequestParams[k] = extraHttpRequestParams[k];
}
@ -269,9 +256,5 @@ module api {
return this.$http(httpRequestParams);
}
}
angular.module('api_UserApi', ['$http'])
.service('UserApi', UserApi);
}

0
samples/client/petstore/typescript-angular/api/api.d.ts → samples/client/petstore/typescript-angular/API/Client/api.d.ts vendored
View File

19
samples/client/petstore/typescript-angular/README.md Normal file
View File

@ -0,0 +1,19 @@
# SwaggerClient
Sample of TypeScript AngularJS petstore client
## Testing the generated code
```
npm install
npm test
```
To clean the workspace run:
```
npm run clean
```
## Author
mads@maetzke-tandrup.dk

20
samples/client/petstore/typescript-angular/package.json Normal file
View File

@ -0,0 +1,20 @@
{
"name": "petstore-typescript-node-sample",
"version": "1.0.0",
"description": "Sample of generated TypeScript petstore client",
"main": "api.js",
"scripts": {
"postinstall": "tsd reinstall --overwrite",
"test": "tsc",
"clean": "rm -Rf node_modules/ typings/ *.js"
},
"author": "Mads M. Tandrup",
"license": "Apache 2.0",
"dependencies": {
"angular": "^1.4.3"
},
"devDependencies": {
"tsd": "^0.6.3",
"typescript": "^1.5.3"
}
}

18
samples/client/petstore/typescript-angular/tsconfig.json Normal file
View File

@ -0,0 +1,18 @@
{
"compilerOptions": {
"noImplicitAny": true,
"out": "client.js"
},
"files": [
"API/Client/Category.ts",
"API/Client/Pet.ts",
"API/Client/StoreApi.ts",
"API/Client/User.ts",
"API/Client/api.d.ts",
"API/Client/Order.ts",
"API/Client/PetApi.ts",
"API/Client/Tag.ts",
"API/Client/UserApi.ts",
"typings/tsd.d.ts"
]
}

15
samples/client/petstore/typescript-angular/tsd.json Normal file
View File

@ -0,0 +1,15 @@
{
"version": "v4",
"repo": "borisyankov/DefinitelyTyped",
"ref": "master",
"path": "typings",
"bundle": "typings/tsd.d.ts",
"installed": {
"angularjs/angular.d.ts": {
"commit": "f6c8ca47193fb67947944a3170912672ac3e908e"
},
"jquery/jquery.d.ts": {
"commit": "f6c8ca47193fb67947944a3170912672ac3e908e"
}
}
}

3
samples/client/petstore/typescript-node/.gitignore vendored Normal file
View File

@ -0,0 +1,3 @@
/node_modules
/typings
/*.js

22
samples/client/petstore/typescript-node/README.md Normal file
View File

@ -0,0 +1,22 @@
# SwaggerClient
Sample of TypeScript Node.js petstore client
## Testing the generated code
```
npm install
npm test
```
This will compile the code and run a small test application that will do some simple test calls to the Swagger Petstore API.
To clean the workspace run:
```
npm run clean
```
## Author
mads@maetzke-tandrup.dk

1199
samples/client/petstore/typescript-node/api.ts Normal file
View File

File diff suppressed because it is too large Load Diff

378
samples/client/petstore/typescript-node/api/PetApi.ts
View File

@ -1,378 +0,0 @@
/* tslint:disable:no-unused-variable */
export class PetApi {
private basePath = 'http://petstore.swagger.io/v2';
constructor(private url: string, private username: string, private password: string, basePath?: string) {
if (basePath) {
this.basePath = basePath;
}
}
public updatePet (body: Pet ) : Promise<{ response: http.ClientResponse; }> {
var path = this.url + this.basePath + '/pet';
var queryParameters: any = {};
var headers: any = {};
var deferred = promise.defer<{ response: http.ClientResponse; }>();
request({
method: 'PUT',
qs: queryParameters,
uri: path,
json: true,
body: body,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public addPet (body: Pet ) : Promise<{ response: http.ClientResponse; }> {
var path = this.url + this.basePath + '/pet';
var queryParameters: any = {};
var headers: any = {};
var deferred = promise.defer<{ response: http.ClientResponse; }>();
request({
method: 'POST',
qs: queryParameters,
uri: path,
json: true,
body: body,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public findPetsByStatus (status: Array<string> ) : Promise<{ response: http.ClientResponse; body: Array<Pet>; }> {
var path = this.url + this.basePath + '/pet/findByStatus';
var queryParameters: any = {};
var headers: any = {};
if (status !== undefined) {
queryParameters['status'] = status;
}
var deferred = promise.defer<{ response: http.ClientResponse; body: Array<Pet>; }>();
request({
method: 'GET',
qs: queryParameters,
uri: path,
json: true,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public findPetsByTags (tags: Array<string> ) : Promise<{ response: http.ClientResponse; body: Array<Pet>; }> {
var path = this.url + this.basePath + '/pet/findByTags';
var queryParameters: any = {};
var headers: any = {};
if (tags !== undefined) {
queryParameters['tags'] = tags;
}
var deferred = promise.defer<{ response: http.ClientResponse; body: Array<Pet>; }>();
request({
method: 'GET',
qs: queryParameters,
uri: path,
json: true,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public getPetById (petId: number ) : Promise<{ response: http.ClientResponse; body: Pet; }> {
var path = this.url + this.basePath + '/pet/{petId}';
path = path.replace('{' + 'petId' + '}', String(petId));
var queryParameters: any = {};
var headers: any = {};
// verify required parameter 'petId' is set
if (!petId) {
throw new Error('Missing required parameter petId when calling getPetById');
}
var deferred = promise.defer<{ response: http.ClientResponse; body: Pet; }>();
request({
method: 'GET',
qs: queryParameters,
uri: path,
json: true,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public updatePetWithForm (petId: string, name: string, status: string ) : Promise<{ response: http.ClientResponse; }> {
var path = this.url + this.basePath + '/pet/{petId}';
path = path.replace('{' + 'petId' + '}', String(petId));
var queryParameters: any = {};
var headers: any = {};
// verify required parameter 'petId' is set
if (!petId) {
throw new Error('Missing required parameter petId when calling updatePetWithForm');
}
var deferred = promise.defer<{ response: http.ClientResponse; }>();
request({
method: 'POST',
qs: queryParameters,
uri: path,
json: true,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public deletePet (apiKey: string, petId: number ) : Promise<{ response: http.ClientResponse; }> {
var path = this.url + this.basePath + '/pet/{petId}';
path = path.replace('{' + 'petId' + '}', String(petId));
var queryParameters: any = {};
var headers: any = {};
// verify required parameter 'petId' is set
if (!petId) {
throw new Error('Missing required parameter petId when calling deletePet');
}
headerParams['apiKey'] = apiKey;
var deferred = promise.defer<{ response: http.ClientResponse; }>();
request({
method: 'DELETE',
qs: queryParameters,
uri: path,
json: true,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public uploadFile (petId: number, additionalMetadata: string, file: file ) : Promise<{ response: http.ClientResponse; }> {
var path = this.url + this.basePath + '/pet/{petId}/uploadImage';
path = path.replace('{' + 'petId' + '}', String(petId));
var queryParameters: any = {};
var headers: any = {};
// verify required parameter 'petId' is set
if (!petId) {
throw new Error('Missing required parameter petId when calling uploadFile');
}
var deferred = promise.defer<{ response: http.ClientResponse; }>();
request({
method: 'POST',
qs: queryParameters,
uri: path,
json: true,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
}

192
samples/client/petstore/typescript-node/api/StoreApi.ts
View File

@ -1,192 +0,0 @@
/* tslint:disable:no-unused-variable */
export class StoreApi {
private basePath = 'http://petstore.swagger.io/v2';
constructor(private url: string, private username: string, private password: string, basePath?: string) {
if (basePath) {
this.basePath = basePath;
}
}
public getInventory ( ) : Promise<{ response: http.ClientResponse; body: map<String, number>; }> {
var path = this.url + this.basePath + '/store/inventory';
var queryParameters: any = {};
var headers: any = {};
var deferred = promise.defer<{ response: http.ClientResponse; body: map<String, number>; }>();
request({
method: 'GET',
qs: queryParameters,
uri: path,
json: true,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public placeOrder (body: Order ) : Promise<{ response: http.ClientResponse; body: Order; }> {
var path = this.url + this.basePath + '/store/order';
var queryParameters: any = {};
var headers: any = {};
var deferred = promise.defer<{ response: http.ClientResponse; body: Order; }>();
request({
method: 'POST',
qs: queryParameters,
uri: path,
json: true,
body: body,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public getOrderById (orderId: string ) : Promise<{ response: http.ClientResponse; body: Order; }> {
var path = this.url + this.basePath + '/store/order/{orderId}';
path = path.replace('{' + 'orderId' + '}', String(orderId));
var queryParameters: any = {};
var headers: any = {};
// verify required parameter 'orderId' is set
if (!orderId) {
throw new Error('Missing required parameter orderId when calling getOrderById');
}
var deferred = promise.defer<{ response: http.ClientResponse; body: Order; }>();
request({
method: 'GET',
qs: queryParameters,
uri: path,
json: true,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public deleteOrder (orderId: string ) : Promise<{ response: http.ClientResponse; }> {
var path = this.url + this.basePath + '/store/order/{orderId}';
path = path.replace('{' + 'orderId' + '}', String(orderId));
var queryParameters: any = {};
var headers: any = {};
// verify required parameter 'orderId' is set
if (!orderId) {
throw new Error('Missing required parameter orderId when calling deleteOrder');
}
var deferred = promise.defer<{ response: http.ClientResponse; }>();
request({
method: 'DELETE',
qs: queryParameters,
uri: path,
json: true,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
}

372
samples/client/petstore/typescript-node/api/UserApi.ts
View File

@ -1,372 +0,0 @@
/* tslint:disable:no-unused-variable */
export class UserApi {
private basePath = 'http://petstore.swagger.io/v2';
constructor(private url: string, private username: string, private password: string, basePath?: string) {
if (basePath) {
this.basePath = basePath;
}
}
public createUser (body: User ) : Promise<{ response: http.ClientResponse; }> {
var path = this.url + this.basePath + '/user';
var queryParameters: any = {};
var headers: any = {};
var deferred = promise.defer<{ response: http.ClientResponse; }>();
request({
method: 'POST',
qs: queryParameters,
uri: path,
json: true,
body: body,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public createUsersWithArrayInput (body: Array<User> ) : Promise<{ response: http.ClientResponse; }> {
var path = this.url + this.basePath + '/user/createWithArray';
var queryParameters: any = {};
var headers: any = {};
var deferred = promise.defer<{ response: http.ClientResponse; }>();
request({
method: 'POST',
qs: queryParameters,
uri: path,
json: true,
body: body,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public createUsersWithListInput (body: Array<User> ) : Promise<{ response: http.ClientResponse; }> {
var path = this.url + this.basePath + '/user/createWithList';
var queryParameters: any = {};
var headers: any = {};
var deferred = promise.defer<{ response: http.ClientResponse; }>();
request({
method: 'POST',
qs: queryParameters,
uri: path,
json: true,
body: body,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public loginUser (username: string, password: string ) : Promise<{ response: http.ClientResponse; body: string; }> {
var path = this.url + this.basePath + '/user/login';
var queryParameters: any = {};
var headers: any = {};
if (username !== undefined) {
queryParameters['username'] = username;
}
if (password !== undefined) {
queryParameters['password'] = password;
}
var deferred = promise.defer<{ response: http.ClientResponse; body: string; }>();
request({
method: 'GET',
qs: queryParameters,
uri: path,
json: true,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public logoutUser ( ) : Promise<{ response: http.ClientResponse; }> {
var path = this.url + this.basePath + '/user/logout';
var queryParameters: any = {};
var headers: any = {};
var deferred = promise.defer<{ response: http.ClientResponse; }>();
request({
method: 'GET',
qs: queryParameters,
uri: path,
json: true,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public getUserByName (username: string ) : Promise<{ response: http.ClientResponse; body: User; }> {
var path = this.url + this.basePath + '/user/{username}';
path = path.replace('{' + 'username' + '}', String(username));
var queryParameters: any = {};
var headers: any = {};
// verify required parameter 'username' is set
if (!username) {
throw new Error('Missing required parameter username when calling getUserByName');
}
var deferred = promise.defer<{ response: http.ClientResponse; body: User; }>();
request({
method: 'GET',
qs: queryParameters,
uri: path,
json: true,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public updateUser (username: string, body: User ) : Promise<{ response: http.ClientResponse; }> {
var path = this.url + this.basePath + '/user/{username}';
path = path.replace('{' + 'username' + '}', String(username));
var queryParameters: any = {};
var headers: any = {};
// verify required parameter 'username' is set
if (!username) {
throw new Error('Missing required parameter username when calling updateUser');
}
var deferred = promise.defer<{ response: http.ClientResponse; }>();
request({
method: 'PUT',
qs: queryParameters,
uri: path,
json: true,
body: body,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
public deleteUser (username: string ) : Promise<{ response: http.ClientResponse; }> {
var path = this.url + this.basePath + '/user/{username}';
path = path.replace('{' + 'username' + '}', String(username));
var queryParameters: any = {};
var headers: any = {};
// verify required parameter 'username' is set
if (!username) {
throw new Error('Missing required parameter username when calling deleteUser');
}
var deferred = promise.defer<{ response: http.ClientResponse; }>();
request({
method: 'DELETE',
qs: queryParameters,
uri: path,
json: true,
auth: {
username: this.username, password: this.password
}
}, (error, response, body) => {
if (error) {
deferred.reject(error);
} else {
if (response.statusCode >= 200 && response.statusCode <= 299) {
deferred.resolve({ response: response, body: body });
} else {
deferred.reject({ response: response, body: body });
}
}
});
return deferred.promise;
}
}

51
samples/client/petstore/typescript-node/client.ts Normal file
View File

@ -0,0 +1,51 @@
import api = require('./api');
import fs = require('fs');
var petApi = new api.PetApi('http://petstore.swagger.io');
petApi.apiKey = 'special-key';
var pet = new api.Pet();
pet.name = 'TypeScriptDoggie';
var petId: any;
var exitCode = 0;
// Test various API calls to the petstore
petApi.addPet(pet)
.then((res) => {
var newPet = <api.Pet>(<any>res.response).body;
petId = (<any>res.response).body.id;
console.log(`Created pet with ID ${petId}`);
newPet.status = api.Pet.StatusEnum.available;
return petApi.updatePet(newPet);
})
.then((res) => {
console.log('Updated pet using POST body');
return petApi.updatePetWithForm(petId, undefined, "pending");
})
.then((res) => {
console.log('Updated pet using POST form');
return petApi.uploadFile(petId, undefined, fs.createReadStream('sample.png'));
})
.then((res) => {
console.log('Uploaded image');
return petApi.getPetById(petId);
})
.then((res) => {
console.log('Got pet by ID: ' + JSON.stringify(res.body));
if (res.body.status != api.Pet.StatusEnum.pending) {
throw new Error("Unexpected pet status");
}
})
.catch((err:any) => {
console.error(err);
exitCode = 1;
})
.finally(() => {
return petApi.deletePet(petId);
})
.then((res) => {
console.log('Deleted pet');
process.exit(exitCode);
});

7
samples/client/petstore/typescript-node/model/Category.ts
View File

@ -1,7 +0,0 @@
export class Category {
id: number;
name: string;
}

26
samples/client/petstore/typescript-node/model/Order.ts
View File

@ -1,26 +0,0 @@
export class Order {
id: number;
petId: number;
quantity: number;
shipDate: DateTime;
/**
* Order Status
*/
status: Order.StatusEnum;
complete: boolean;
}
export module Order {
export enum StatusEnum {
placed = <any> 'placed',
approved = <any> 'approved',
delivered = <any> 'delivered',
}
}

26
samples/client/petstore/typescript-node/model/Pet.ts
View File

@ -1,26 +0,0 @@
export class Pet {
id: number;
category: Category;
name: string;
photoUrls: Array<string>;
tags: Array<Tag>;
/**
* pet status in the store
*/
status: Pet.StatusEnum;
}
export module Pet {
export enum StatusEnum {
available = <any> 'available',
pending = <any> 'pending',
sold = <any> 'sold',
}
}

7
samples/client/petstore/typescript-node/model/Tag.ts
View File

@ -1,7 +0,0 @@
export class Tag {
id: number;
name: string;
}

22
samples/client/petstore/typescript-node/model/User.ts
View File

@ -1,22 +0,0 @@
export class User {
id: number;
username: string;
firstName: string;
lastName: string;
email: string;
password: string;
phone: string;
/**
* User Status
*/
userStatus: number;
}

21
samples/client/petstore/typescript-node/package.json Normal file
View File

@ -0,0 +1,21 @@
{
"name": "petstore-typescript-node-sample",
"version": "1.0.0",
"description": "Sample of generated TypeScript petstore client",
"main": "api.js",
"scripts": {
"postinstall": "tsd reinstall --overwrite",
"test": "tsc && node client.js",
"clean": "rm -Rf node_modules/ typings/ *.js"
},
"author": "Mads M. Tandrup",
"license": "Apache 2.0",
"dependencies": {
"bluebird": "^2.9.34",
"request": "^2.60.0"
},
"devDependencies": {
"tsd": "^0.6.3",
"typescript": "^1.5.3"
}
}

BIN
samples/client/petstore/typescript-node/sample.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 95 B

12
samples/client/petstore/typescript-node/tsconfig.json Normal file
View File

@ -0,0 +1,12 @@
{
"compilerOptions": {
"module": "commonjs",
"noImplicitAny": true,
"target": "ES5"
},
"files": [
"api.ts",
"client.ts",
"typings/tsd.d.ts"
]
}

21
samples/client/petstore/typescript-node/tsd.json Normal file
View File

@ -0,0 +1,21 @@
{
"version": "v4",
"repo": "borisyankov/DefinitelyTyped",
"ref": "master",
"path": "typings",
"bundle": "typings/tsd.d.ts",
"installed": {
"bluebird/bluebird.d.ts": {
"commit": "f6c8ca47193fb67947944a3170912672ac3e908e"
},
"request/request.d.ts": {
"commit": "f6c8ca47193fb67947944a3170912672ac3e908e"
},
"form-data/form-data.d.ts": {
"commit": "f6c8ca47193fb67947944a3170912672ac3e908e"
},
"node/node.d.ts": {
"commit": "f6c8ca47193fb67947944a3170912672ac3e908e"
}
}
}