Added Model Base for angular template (with mappers)

ProtocolNebula · ProtocolNebula · commit 70844fa206cd · 2021-01-18T21:46:59.000+01:00
diff --git a/ApiBase/api-base.service.ts b/ApiBase/api-base.service.ts
@@ -3,6 +3,7 @@ import {
   HttpClient,
   HttpHeaders,
   HttpErrorResponse,
+  HttpParams,
 } from '@angular/common/http';
 import { Observable } from 'rxjs/Observable';
 import { Subscription } from 'rxjs/internal/Subscription';
@@ -21,6 +22,23 @@ export interface APIError {
   errorText: string;
 }
 
+export interface HttpOptions {
+  headers?:
+    | HttpHeaders
+    | {
+        [header: string]: string | string[];
+      };
+  observe?: 'body';
+  params?:
+    | HttpParams
+    | {
+        [param: string]: string | string[];
+      };
+  reportProgress?: boolean;
+  responseType?: 'json';
+  withCredentials?: boolean;
+}
+
 /**
  * Implementation of angular-http
  * https://angular.io/guide/http
@@ -83,50 +101,80 @@ export class ApiBaseService {
     this.serverURL = url;
   }
 
-  public doGet(url, params = null, data = null): Observable<any> {
-    const options = this.getOptions(url, params, data);
+  public doGet(
+    url,
+    params = null,
+    data = null,
+    customOptions?: Partial<HttpOptions>,
+  ): Observable<any> {
+    const options = this.getOptions(customOptions);
     url = this.parseURLParams(url, params);
     // TODO: Add support to http.get<RESPONSETYPE>() or on .subscribe
     return this.http.get(this.serverURL + url, options).pipe(
       // retry(1),
-      catchError((error) => this.handleError(error))
+      catchError((error) => this.handleError(error)),
     );
   }
 
-  public doPost(url, params, data): Observable<any> {
-    const options = this.getOptions(url, params, data);
+  public doPost(
+    url,
+    params,
+    data,
+    customOptions?: Partial<HttpOptions>,
+  ): Observable<any> {
+    const options = this.getOptions(customOptions);
     url = this.parseURLParams(url, params);
     return this.http
       .post(this.serverURL + url, data, options)
       .pipe(catchError((error) => this.handleError(error)));
   }
 
-  public doPut(url, params, data): Observable<any> {
-    const options = this.getOptions(url, params, data);
+  public doPut(
+    url,
+    params,
+    data,
+    customOptions?: Partial<HttpOptions>,
+  ): Observable<any> {
+    const options = this.getOptions(customOptions);
     url = this.parseURLParams(url, params);
     return this.http
       .put(this.serverURL + url, data, options)
       .pipe(catchError((error) => this.handleError(error)));
   }
 
-  public doOptions(url, params, data = null): Observable<any> {
-    const options = this.getOptions(url, params, data);
+  public doOptions(
+    url,
+    params,
+    data = null,
+    customOptions?: Partial<HttpOptions>,
+  ): Observable<any> {
+    const options = this.getOptions(customOptions);
     url = this.parseURLParams(url, params);
     return this.http
       .options(this.serverURL + url, options)
       .pipe(catchError((error) => this.handleError(error)));
   }
 
-  public doPatch(url, params, data = null): Observable<any> {
-    const options = this.getOptions(url, params, data);
+  public doPatch(
+    url,
+    params,
+    data = null,
+    customOptions?: Partial<HttpOptions>,
+  ): Observable<any> {
+    const options = this.getOptions(customOptions);
     url = this.parseURLParams(url, params);
     return this.http
       .patch(this.serverURL + url, options)
       .pipe(catchError((error) => this.handleError(error)));
   }
 
-  public doDelete(url, params, data = null): Observable<any> {
-    const options = this.getOptions(url, params, data);
+  public doDelete(
+    url,
+    params,
+    data = null,
+    customOptions?: Partial<HttpOptions>,
+  ): Observable<any> {
+    const options = this.getOptions(customOptions);
     url = this.parseURLParams(url, params);
     return this.http
       .delete(this.serverURL + url, options)
@@ -194,11 +242,8 @@ export class ApiBaseService {
     } as APIError);
   }
 
-  protected getOptions(url, params = null, data = null) {
-    return {
-      headers: this.httpHeaders,
-      // params: this.parseURLParams(url, params),
-    };
+  protected getOptions(customOptions?: Partial<HttpOptions>) {
+    return Object.assign({ headers: { ...this.httpHeaders } }, customOptions);
   }
 
   /**
diff --git a/ApiBase/model-base.model.ts b/ApiBase/model-base.model.ts
@@ -0,0 +1,79 @@
+export interface ModelPropertyDef {
+  type: any;
+}
+
+export function recursiveInstance(classType, value: any): any {
+  if (value?.__proto__?.constructor?.name === 'Array') {
+    return value.map((element) => recursiveInstance(classType, element));
+  } else {
+    return new classType(value);
+  }
+}
+
+export function recursiveStringfy(model: any): any {
+  if ((model as any)?.__proto__?.constructor?.name === 'Array') {
+    return model.map((el) => recursiveStringfy(el));
+  }
+  const data = {};
+  let paramsList;
+  if (model.PARAMS_MAPPER) {
+    paramsList = model.PARAMS_MAPPER;
+  } else {
+    paramsList = model;
+  }
+  for (const key in paramsList) {
+    if (!model[key]) {
+      continue;
+    }
+    const value = model[key];
+    if (value?.__proto__?.constructor?.name === 'Array') {
+      data[key] = value.map((el) => recursiveStringfy(el));
+    } else if (value.json) {
+      data[key] = value.json();
+    } else {
+      data[key] = value;
+    }
+  }
+  return data;
+}
+
+export abstract class ModelBase {
+  protected readonly PARAMS_MAPPER: { [param: string]: ModelPropertyDef } = {};
+
+  parse(params: any): void {
+    if (!params) {
+      return;
+    }
+
+    for (const paramKey in params) {
+      if (!params[paramKey]) {
+        continue;
+      }
+      const paramValue = params[paramKey];
+      if (this.PARAMS_MAPPER[paramKey]) {
+        this[paramKey] = this.parseParam(paramKey, paramValue);
+      }
+    }
+  }
+
+  parseParam(key: string, value: any): any {
+    const mapper = this.PARAMS_MAPPER[key];
+    if (
+      mapper &&
+      typeof mapper?.type === 'function' &&
+      typeof value !== 'function' &&
+      value?.__proto__?.constructor?.name !== 'Array'
+    ) {
+      return recursiveInstance(mapper.type, value);
+    }
+    return value;
+  }
+
+  json(): any {
+    return recursiveStringfy(this);
+  }
+
+  toString(): string {
+    return JSON.stringify(this.json());
+  }
+}
diff --git a/src/models/api.model.ts b/src/models/api.model.ts
@@ -16,6 +16,7 @@ export class ApiModel implements PhysycalFile {
   private _operationId: string;
 
   queryParams: ModelAttributessModel;
+  requestContentType?: string;
   requestBody: ModelAttributessModel;
   response: ModelAttributessModel;
 
@@ -27,6 +28,14 @@ export class ApiModel implements PhysycalFile {
     return this.tags[0]?.length ? capital(this.tags[0], '', true) : null;
   }
 
+  get isFormRequest(): boolean {
+    return this.requestContentType === 'multipart/form-data';
+  }
+
+  get isResponsePrimitive(): boolean {
+    return !this.response || this.response?.typeIsPrimitive;
+  }
+
   get models(): ModelAttributessModel[] {
     return [this.queryParams, this.requestBody, this.response].filter(
       (el) => !!el,
diff --git a/src/services/parsers/open-api-v3/api-parser.service.ts b/src/services/parsers/open-api-v3/api-parser.service.ts
@@ -83,6 +83,7 @@ export class APIParserService extends ParserBaseService {
     } else if (this.isRequestBodyObject(scheme)) {
       const keys = Object.keys(scheme.content);
       const mainKey = keys[0];
+      apiModel.requestContentType = mainKey;
       apiModel.requestBody = this.parseSchema(
         scheme.content[mainKey].schema,
         getApiDefaultModelName(apiModel, 'Request'),
diff --git a/templates/angular2/api.ts b/templates/angular2/api.ts
@@ -4,9 +4,11 @@
 // Angular dependences
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs/Observable';
+import { map } from 'rxjs/operators';
 
 // Main dependences
 import { ApiBaseService } from '../../ApiBase/api-base.service';
+import { recursiveInstance, recursiveStringfy } from '../../ApiBase/model-base.model';
 
 // Models dependences
 {{#dependences}}
@@ -32,10 +34,10 @@ export class {{groupName}}Service {
   {{#hasComments}}
   /**
   {{#description}}
-   * {{description}}
+   * {{{description}}}
   {{/description}}
   {{#example}}
-   * @example {{example}}
+   * @example {{{example}}}
   {{/example}}
   {{#deprecated}}
    * @deprecated
@@ -55,8 +57,22 @@ export class {{groupName}}Service {
     return this.apiService.do{{verb}}(
       '{{{ url }}}',
       {{#queryParamsType}}uriOptions{{/queryParamsType}}{{^queryParamsType}}null{{/queryParamsType}},
-      {{#requestBodyType}}requestBody{{/requestBodyType}}{{^requestBodyType}}null{{/requestBodyType}}
-    );
+      {{^requestBodyType}}null{{/requestBodyType}}{{
+        #requestBodyType}}{{
+        ^isFormRequest}}recursiveStringfy(requestBody){{/isFormRequest
+        }}{{
+        #isFormRequest}}this.apiService.generateFormData(recursiveStringfy(requestBody)){{/isFormRequest
+        }}{{/requestBodyType}},
+      {{!
+        // Remove "null" line and uncomment line below
+        // if you want to set "content-type" on headers
+      }}
+      null,
+      // { {{#requestContentType}} headers: { 'Content-Type': '{{{requestContentType}}}' } {{/requestContentType}} },
+    ){{^isResponsePrimitive}}
+      .pipe(
+        map(response => recursiveInstance({{responseType}}, response))
+      ){{/isResponsePrimitive}};
   }
 
   {{/apis}}
diff --git a/templates/angular2/model.ts b/templates/angular2/model.ts
@@ -1,3 +1,4 @@
+import { ModelBase } from '../../ApiBase/model-base.model';
 {{#dependences}}
 import { {{name}} } from './{{fileName}}';
 {{/dependences}}
@@ -16,10 +17,11 @@ import { {{name}} } from './{{fileName}}';
  */
 {{/hasComments}}
 {{#model}}
-export class {{ name }} {
+export interface {{ name }}I {
 
-{{#attributes}}
+  {{#attributes}}
   {{#hasComments}}
+  {{#description}}
   /**
   {{#description}}
    * {{description}}
@@ -31,14 +33,46 @@ export class {{ name }} {
    * @deprecated
   {{/deprecated}}
    */
+  {{/description}}
   {{/hasComments}}
-  {{name}}{{
-    #isOptional}}?{{/isOptional
-  }}: {{type}}{{
+  {{name}}{{#isOptional}}?{{/isOptional}}: {{type}}{{#isArray}}[]{{/isArray}};
+
+  {{/attributes}}
+}
+
+
+export class {{ name }} extends ModelBase implements {{ name }}I {
+
+  protected readonly PARAMS_MAPPER = PARAMS_MAPPER;
+
+{{#attributes}}
+  private _{{name}}: {{type}}{{
     #arrayLevelsRepeater}}[]{{/arrayLevelsRepeater
   }}{{#default}} = {{default}}{{/default
   }};
+  get {{name}}(): {{type}}{{#arrayLevelsRepeater}}[]{{/arrayLevelsRepeater}} {
+    return this._{{name}};
+  }
+  set {{name}}(value: {{type}}{{#arrayLevelsRepeater}}[]{{/arrayLevelsRepeater}}) {
+    this._{{name}} = this.parseParam('{{name}}', value);
+  }
 
 {{/attributes}}
+  constructor(params?: {{name}}I) {
+    super();
+    this.parse(params);
+  }
 }
 {{/model}}
+
+const PARAMS_MAPPER = {
+{{#model}}
+{{#attributes}}
+  {{name}}: {
+    type: {{#typeIsPrimitive}}'{{/typeIsPrimitive}}{{
+      type
+    }}{{#typeIsPrimitive}}'{{/typeIsPrimitive}},
+  },
+{{/attributes}}
+{{/model}}
+};
