@rosoftlab/core 0.0.100

package/esm2020/lib/pipes/input-error.pipe.mjs

@@ -0,0 +1,37 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class InputErrorPipe {
+    constructor(translate) {
+        this.translate = translate;
+    }
+    transform(value, filedTranslationKey) {
+        let rvalue = '';
+        if (value !== null) {
+            if (value['invalid'] === true) {
+                rvalue = 'ERROR.INVALID';
+            }
+            if (value['mustMatch'] === true) {
+                rvalue = 'Account.Password.MustMach';
+            }
+            if (value['required'] === true) {
+                const field = this.translate.instant(filedTranslationKey.field);
+                rvalue = this.translate.instant('General.Field.Required', { field });
+            }
+            if (value['minlength']) {
+                const field = this.translate.instant(filedTranslationKey.field);
+                rvalue = this.translate.instant('General.Field.MinLength', { field, requiredLength: value.minlength.requiredLength });
+            }
+        }
+        return rvalue;
+    }
+}
+InputErrorPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: InputErrorPipe, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe });
+InputErrorPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: InputErrorPipe, name: "inputError" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: InputErrorPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'inputError'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/providers.mjs

@@ -0,0 +1,10 @@
+import { DatePipe, DecimalPipe, PercentPipe } from '@angular/common';
+import { BaseDatastore } from './services/base-datastore.service';
+export * from './services';
+export const PROVIDERS = [
+    BaseDatastore,
+    DatePipe,
+    DecimalPipe,
+    PercentPipe,
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvcm9zb2Z0bGFiL2NvcmUvc3JjL2xpYi9wcm92aWRlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxXQUFXLEVBQUUsV0FBVyxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDckUsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQ2xFLGNBQWMsWUFBWSxDQUFDO0FBRTNCLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBVTtJQUM5QixhQUFhO0lBQ2IsUUFBUTtJQUNSLFdBQVc7SUFDWCxXQUFXO0NBQ1osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERhdGVQaXBlLCBEZWNpbWFsUGlwZSwgUGVyY2VudFBpcGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xyXG5pbXBvcnQgeyBCYXNlRGF0YXN0b3JlIH0gZnJvbSAnLi9zZXJ2aWNlcy9iYXNlLWRhdGFzdG9yZS5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcyc7XHJcblxyXG5leHBvcnQgY29uc3QgUFJPVklERVJTOiBhbnlbXSA9IFtcclxuICBCYXNlRGF0YXN0b3JlLFxyXG4gIERhdGVQaXBlLFxyXG4gIERlY2ltYWxQaXBlLFxyXG4gIFBlcmNlbnRQaXBlLFxyXG5dO1xyXG4iXX0=

package/esm2020/lib/services/base-datastore.service.mjs

@@ -0,0 +1,333 @@
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { compare } from 'fast-json-patch';
+import * as qs from 'qs';
+import { Observable, throwError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { BaseQueryData } from '../models/base-query-data';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class BaseDatastore {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        // tslint:disable-next-line:variable-name
+        this._store = {};
+        // tslint:enable:max-line-length
+        // tslint:disable-next-line:ban-types
+        this.toQueryString = this.datastoreConfig.overrides
+            && this.datastoreConfig.overrides.toQueryString ?
+            this.datastoreConfig.overrides.toQueryString : this._toQueryString;
+    }
+    // tslint:enable:max-line-length
+    get getDirtyAttributes() {
+        if (this.datastoreConfig.overrides
+            && this.datastoreConfig.overrides.getDirtyAttributes) {
+            return this.datastoreConfig.overrides.getDirtyAttributes;
+        }
+        else {
+            return BaseDatastore.getDirtyAttributes;
+        }
+    }
+    get getAllAttributes() {
+        if (this.datastoreConfig.overrides
+            && this.datastoreConfig.overrides.getAllAttributes) {
+            return this.datastoreConfig.overrides.getAllAttributes;
+        }
+        else {
+            return BaseDatastore.getAllAttributes;
+        }
+    }
+    // protected config: DatastoreConfig;
+    static getDirtyAttributes(attributesMetadata) {
+        const dirtyData = {};
+        for (const propertyName in attributesMetadata) {
+            if (attributesMetadata.hasOwnProperty(propertyName)) {
+                const metadata = attributesMetadata[propertyName];
+                if (metadata.hasDirtyAttributes) {
+                    const attributeName = metadata.serializedName != null ? metadata.serializedName : propertyName;
+                    dirtyData[attributeName] = metadata.serialisationValue ? metadata.serialisationValue : metadata.newValue;
+                }
+            }
+        }
+        return dirtyData;
+    }
+    static getAllAttributes(attributesMetadata) {
+        const dirtyData = {};
+        for (const propertyName in attributesMetadata) {
+            if (attributesMetadata.hasOwnProperty(propertyName)) {
+                const metadata = attributesMetadata[propertyName];
+                const attributeName = metadata.serializedName != null ? metadata.serializedName : propertyName;
+                dirtyData[attributeName] = metadata.serialisationValue ? metadata.serialisationValue : metadata.newValue;
+            }
+        }
+        return dirtyData;
+    }
+    findAll(modelType, params, headers, customUrl) {
+        const customHeadhers = this.buildHeaders(headers);
+        const htmlParams = this.buildParams(params);
+        const url = this.buildUrl(modelType, customUrl);
+        const response = this.httpClient.get(url, { headers: customHeadhers, params: htmlParams, withCredentials: true })
+            .pipe(map(res => this.extractQueryData(res, modelType)), catchError(this.handleError));
+        return response;
+    }
+    findRecord(modelType, id, params, headers, customUrl) {
+        const customHeadhers = this.buildHeaders(headers);
+        let url = this.buildUrl(modelType, customUrl);
+        if (id) {
+            url += '/' + id;
+        }
+        const htmlParams = this.buildParams(params, undefined);
+        return this.httpClient.get(url, { headers: customHeadhers, params: htmlParams, withCredentials: true })
+            .pipe(map(res => this.entityToModel(res, modelType, undefined)), catchError(this.handleError));
+    }
+    getCustom(modelType, params, headers, customUrl, customResponseType) {
+        const customHeadhers = this.buildHeaders(headers);
+        const url = this.buildUrl(modelType, customUrl);
+        const htmlParams = this.buildParams(params, undefined);
+        if (!customResponseType)
+            customResponseType = 'json';
+        return this.httpClient.get(url, { headers: customHeadhers, params: htmlParams, withCredentials: true, responseType: customResponseType });
+    }
+    postCustom(modelType, body, params, headers, customUrl) {
+        const customHeadhers = this.buildHeaders(headers);
+        const url = this.buildUrl(modelType, customUrl);
+        const htmlParams = this.buildParams(params, undefined);
+        return this.httpClient.post(url, body, { headers: customHeadhers, params: htmlParams, reportProgress: true, withCredentials: true });
+    }
+    patchCustom(modelType, body, params, headers, customUrl) {
+        const customHeadhers = this.buildHeaders(headers);
+        const url = this.buildUrl(modelType, customUrl);
+        const htmlParams = this.buildParams(params, undefined);
+        return this.httpClient.patch(url, body, { headers: customHeadhers, params: htmlParams, withCredentials: true });
+    }
+    createRecord(modelType, data) {
+        return new modelType(this, data);
+    }
+    saveRecord(attributesMetadata, model, params, headers, customUrl, customBody) {
+        const modelType = model.constructor;
+        const modelConfig = model.modelConfig;
+        const customHeadhers = this.buildHeaders(headers);
+        const url = this.buildUrl(modelType, customUrl);
+        const htmlParams = this.buildParams(params);
+        let httpCall;
+        const body = customBody || this.modelToEntity(model, attributesMetadata);
+        if (model.id) {
+            // tslint:disable-next-line:max-line-length
+            httpCall = this.httpClient.patch(url + '/' + model.id, body, { headers: customHeadhers, params: htmlParams, withCredentials: true });
+        }
+        else {
+            httpCall = this.httpClient.post(url, body, { headers: customHeadhers, params: htmlParams, withCredentials: true });
+        }
+        return httpCall
+            .pipe(map(res => {
+            const data = this.resetMetadataAttributes(res, attributesMetadata, modelType);
+            return this.entityToModel(data, modelType);
+        }), catchError(this.handleError));
+    }
+    patchRecord(attributesMetadata, model, origModel, params, headers, customUrl) {
+        const modelType = model.constructor;
+        const modelConfig = model.modelConfig;
+        const customHeadhers = this.buildHeaders(headers);
+        const url = this.buildUrl(modelType, customUrl);
+        const htmlParams = this.buildParams(params);
+        let httpCall;
+        let origData = { id: '' };
+        if (origModel)
+            origData = this.modelToEntity(origModel, origModel.attributeMetadata, true);
+        const newData = this.modelToEntity(model, attributesMetadata, true);
+        newData.id = origData.id;
+        const patch = compare(origData, newData);
+        if (patch.length > 0) {
+            httpCall = this.httpClient.patch(url + '/' + model.id, patch, { headers: customHeadhers, params: htmlParams, withCredentials: true });
+            return httpCall
+                .pipe(map(res => {
+                const data = this.resetMetadataAttributes(res, attributesMetadata, modelType);
+                return this.entityToModel(data, modelType);
+            }), catchError(this.handleError));
+        }
+        else {
+            return new Observable((observer) => {
+                observer.next(model);
+                observer.complete();
+            });
+        }
+    }
+    // getPatch<T extends BaseModel>(
+    //   model: T,
+    //   origModel: T): any {
+    // }
+    replaceRecord(attributesMetadata, model, params, headers, customUrl, customBody) {
+        const modelType = model.constructor;
+        const modelConfig = model.modelConfig;
+        const customHeadhers = this.buildHeaders(headers);
+        const url = this.buildUrl(modelType, customUrl);
+        const htmlParams = this.buildParams(params);
+        let httpCall;
+        const body = customBody || this.modelToEntity(model, attributesMetadata, true);
+        if (model.id) {
+            httpCall = this.httpClient.put(url + '/' + model.id, body, { headers: customHeadhers, params: htmlParams, withCredentials: true });
+        }
+        else {
+            httpCall = this.httpClient.post(url, body, { headers: customHeadhers, params: htmlParams, withCredentials: true });
+        }
+        return httpCall
+            .pipe(map(res => {
+            const data = this.resetMetadataAttributes(res, attributesMetadata, modelType);
+            return this.entityToModel(data, modelType);
+        }), catchError(this.handleError));
+    }
+    deleteRecord(modelType, id, headers, customUrl) {
+        const customHeadhers = this.buildHeaders(headers);
+        let url = this.buildUrl(modelType, customUrl);
+        if (!url.includes('share')) {
+            url = url + '/' + id;
+        }
+        // const idParam = new HttpParams().set('id', id);
+        return this.httpClient.delete(url, { headers: customHeadhers, withCredentials: true })
+            .pipe(catchError(this.handleError));
+    }
+    buildUrl(modelType, customUrl) {
+        if (customUrl) {
+            return customUrl;
+        }
+        const modelConfig = Reflect.getMetadata('BaseModelConfig', modelType);
+        const baseUrl = modelConfig.baseUrl || this.datastoreConfig.baseUrl;
+        const apiVersion = modelConfig.apiVersion || this.datastoreConfig.apiVersion;
+        const modelEndpointUrl = modelConfig.modelEndpointUrl || modelConfig.type;
+        const url = [baseUrl, apiVersion, modelEndpointUrl].filter((x) => x).join('/');
+        return url;
+    }
+    extractQueryData(res, modelType) {
+        let result;
+        const body = res;
+        const models = [];
+        for (const data of body.data) {
+            const model = this.entityToModel(data, modelType, undefined);
+            models.push(model);
+        }
+        result = new BaseQueryData(models, this.parseMeta(body, modelType));
+        return result;
+    }
+    deserializeModel(modelType, data) {
+        data = this.transformSerializedNamesToPropertyNames(modelType, data);
+        return new modelType(this, data);
+    }
+    handleError(error) {
+        if (error.error instanceof ErrorEvent) {
+            // A client-side or network error occurred. Handle it accordingly.
+            // console.error('An error occurred:', error.error.message);
+        }
+        else {
+            // The backend returned an unsuccessful response code.
+            // The response body may contain clues as to what went wrong,
+            // console.error(
+            //   'Backend returned code ${error.status}, ' +
+            //   'body was: ${error.error}');
+        }
+        // return an observable with a user-facing error message
+        return throwError(error);
+    }
+    parseMeta(body, modelType) {
+        const metaModel = Reflect.getMetadata('BaseModelConfig', modelType).meta;
+        return new metaModel(body);
+    }
+    resetMetadataAttributes(res, attributesMetadata, modelType) {
+        // TODO check why is attributesMetadata from the arguments never used
+        for (const propertyName in attributesMetadata) {
+            if (attributesMetadata.hasOwnProperty(propertyName)) {
+                const metadata = attributesMetadata[propertyName];
+                if (metadata.hasDirtyAttributes) {
+                    metadata.hasDirtyAttributes = false;
+                }
+            }
+        }
+        if (res) {
+            res.attributeMetadata = attributesMetadata;
+        }
+        return res;
+    }
+    get datastoreConfig() {
+        const configFromDecorator = Reflect.getMetadata('BaseDatastoreConfig', this.constructor);
+        return Object.assign(configFromDecorator, this.config);
+    }
+    transformSerializedNamesToPropertyNames(modelType, attributes) {
+        const serializedNameToPropertyName = this.getModelPropertyNames(modelType.prototype);
+        const properties = {};
+        Object.keys(serializedNameToPropertyName).forEach((serializedName) => {
+            if (attributes[serializedName] !== null && attributes[serializedName] !== undefined) {
+                properties[serializedNameToPropertyName[serializedName]] = attributes[serializedName];
+            }
+        });
+        return properties;
+    }
+    getModelPropertyNames(model) {
+        return Reflect.getMetadata('AttributeMapping', model);
+    }
+    buildHeaders(customHeaders) {
+        const headers = {
+            Accept: 'application/json-patch+json',
+            // 'Content-Type': 'application/vnd.api+json',
+            'Content-Type': 'application/json-patch+json'
+        };
+        if (customHeaders && customHeaders.keys().length) {
+            // tslint:disable-next-line:variable-name
+            Object.assign({}, headers, customHeaders.keys().map(header_name => {
+                headers['' + header_name] = customHeaders.get(header_name);
+            }));
+        }
+        return new HttpHeaders(headers);
+    }
+    buildParams(params, id) {
+        let httpParams = new HttpParams();
+        if (id) {
+            httpParams = httpParams.set('id', id);
+        }
+        if (params) {
+            Object.keys(params)
+                .filter(key => {
+                const v = params[key];
+                return (Array.isArray(v) || typeof v === 'string') ?
+                    (v.length > 0) :
+                    (v !== null && v !== undefined);
+            })
+                .forEach(key => {
+                httpParams = httpParams.set(key, params[key]);
+            });
+        }
+        return httpParams;
+    }
+    entityToModel(res, modelType, model) {
+        return this.extractRecordDataJson(res, modelType, model);
+    }
+    extractRecordDataJson(res, modelType, model) {
+        const body = res;
+        if (!body) {
+            throw new Error('no body in response');
+        }
+        if (model) {
+            Object.assign(model, body);
+        }
+        const deserializedModel = model || this.deserializeModel(modelType, body.data || body);
+        return deserializedModel;
+    }
+    modelToEntity(model, attributesMetadata, allAttributes = false) {
+        let attributes;
+        if (allAttributes) {
+            attributes = this.getAllAttributes(attributesMetadata, model);
+        }
+        else {
+            attributes = this.getDirtyAttributes(attributesMetadata, model);
+        }
+        // this.getRelationships(model, attributes);
+        return attributes;
+    }
+    _toQueryString(params) {
+        return qs.stringify(params, { arrayFormat: 'brackets' });
+    }
+}
+BaseDatastore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: BaseDatastore, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+BaseDatastore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: BaseDatastore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: BaseDatastore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-datastore.service.js","sourceRoot":"","sources":["../../../../../../projects/rosoftlab/core/src/lib/services/base-datastore.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpErrorResponse, HttpHeaders, HttpParams } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { compare } from 'fast-json-patch';\r\nimport * as qs from 'qs';\r\nimport { Observable, Observer, throwError } from 'rxjs';\r\nimport { catchError, map } from 'rxjs/operators';\r\nimport { DatastoreConfig } from '../interfaces/datastore-config.interface';\r\nimport { ModelConfig } from '../interfaces/model-config.interface';\r\nimport { BaseQueryData } from '../models/base-query-data';\r\nimport { BaseModel } from '../models/base.model';\r\nexport type ModelType<T extends BaseModel> = new (datastore: BaseDatastore, data: any) => T;\r\n\r\n@Injectable()\r\nexport class BaseDatastore {\r\n  protected config!: DatastoreConfig;\r\n  // tslint:disable-next-line:variable-name\r\n  private _store: { [type: string]: { [id: string]: BaseModel } } = {};\r\n  // tslint:enable:max-line-length\r\n  // tslint:disable-next-line:ban-types\r\n  private toQueryString: Function = this.datastoreConfig.overrides\r\n    && this.datastoreConfig.overrides.toQueryString ?\r\n    this.datastoreConfig.overrides.toQueryString : this._toQueryString;\r\n  // tslint:enable:max-line-length\r\n\r\n  private get getDirtyAttributes() {\r\n    if (this.datastoreConfig.overrides\r\n      && this.datastoreConfig.overrides.getDirtyAttributes) {\r\n      return this.datastoreConfig.overrides.getDirtyAttributes;\r\n    } else {\r\n      return BaseDatastore.getDirtyAttributes;\r\n    }\r\n  }\r\n\r\n  public get getAllAttributes() {\r\n    if (this.datastoreConfig.overrides\r\n      && this.datastoreConfig.overrides.getAllAttributes) {\r\n      return this.datastoreConfig.overrides.getAllAttributes;\r\n    } else {\r\n      return BaseDatastore.getAllAttributes;\r\n    }\r\n  }\r\n\r\n  // protected config: DatastoreConfig;\r\n\r\n  private static getDirtyAttributes(attributesMetadata: any): { string: any } {\r\n    const dirtyData: any = {};\r\n\r\n    for (const propertyName in attributesMetadata) {\r\n      if (attributesMetadata.hasOwnProperty(propertyName)) {\r\n        const metadata: any = attributesMetadata[propertyName];\r\n\r\n        if (metadata.hasDirtyAttributes) {\r\n          const attributeName = metadata.serializedName != null ? metadata.serializedName : propertyName;\r\n          dirtyData[attributeName] = metadata.serialisationValue ? metadata.serialisationValue : metadata.newValue;\r\n        }\r\n      }\r\n    }\r\n    return dirtyData;\r\n  }\r\n\r\n  private static getAllAttributes(attributesMetadata: any): { string: any } {\r\n    const dirtyData: any = {};\r\n\r\n    for (const propertyName in attributesMetadata) {\r\n      if (attributesMetadata.hasOwnProperty(propertyName)) {\r\n        const metadata: any = attributesMetadata[propertyName];\r\n        const attributeName = metadata.serializedName != null ? metadata.serializedName : propertyName;\r\n        dirtyData[attributeName] = metadata.serialisationValue ? metadata.serialisationValue : metadata.newValue;\r\n      }\r\n    }\r\n    return dirtyData;\r\n  }\r\n\r\n  constructor(protected httpClient: HttpClient) {\r\n  }\r\n\r\n  findAll<T extends BaseModel>(\r\n    modelType: ModelType<T>,\r\n    params?: any,\r\n    headers?: HttpHeaders,\r\n    customUrl?: string\r\n  ): Observable<BaseQueryData<T>> {\r\n    const customHeadhers: HttpHeaders = this.buildHeaders(headers);\r\n    const htmlParams = this.buildParams(params);\r\n    const url: string = this.buildUrl(modelType, customUrl);\r\n\r\n    const response = this.httpClient.get(url,\r\n      { headers: customHeadhers, params: htmlParams, withCredentials: true })\r\n      .pipe(\r\n        map(res => this.extractQueryData(res, modelType)),\r\n        catchError(this.handleError)\r\n      );\r\n    return response;\r\n  }\r\n\r\n  findRecord<T extends BaseModel>(\r\n    modelType: ModelType<T>,\r\n    id?: string,\r\n    params?: any,\r\n    headers?: HttpHeaders,\r\n    customUrl?: string\r\n  ): Observable<T> {\r\n    const customHeadhers: HttpHeaders = this.buildHeaders(headers);\r\n    let url: string = this.buildUrl(modelType, customUrl);\r\n    if (id) {\r\n      url += '/' + id;\r\n    }\r\n\r\n    const htmlParams = this.buildParams(params, undefined);\r\n    return this.httpClient.get(url, { headers: customHeadhers, params: htmlParams, withCredentials: true })\r\n      .pipe(map(res => this.entityToModel(res, modelType, undefined)),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n  getCustom<U, T extends BaseModel>(modelType: ModelType<T>,\r\n    params?: any,\r\n    headers?: HttpHeaders,\r\n    customUrl?: string,\r\n    customResponseType?: any): Observable<U> {\r\n    const customHeadhers: HttpHeaders = this.buildHeaders(headers);\r\n    const url: string = this.buildUrl(modelType, customUrl);\r\n    const htmlParams = this.buildParams(params, undefined);\r\n    if (!customResponseType)\r\n      customResponseType = 'json';\r\n    return this.httpClient.get<U>(url, { headers: customHeadhers, params: htmlParams, withCredentials: true, responseType: customResponseType });\r\n  }\r\n\r\n  postCustom<U, T extends BaseModel>(modelType: ModelType<T>,\r\n    body: any,\r\n    params?: any,\r\n    headers?: HttpHeaders,\r\n    customUrl?: string): Observable<U> {\r\n    const customHeadhers: HttpHeaders = this.buildHeaders(headers);\r\n    const url: string = this.buildUrl(modelType, customUrl);\r\n    const htmlParams = this.buildParams(params, undefined);\r\n    return this.httpClient.post<U>(url, body, { headers: customHeadhers, params: htmlParams, reportProgress: true, withCredentials: true });\r\n  }\r\n\r\n  patchCustom<U, T extends BaseModel>(modelType: ModelType<T>,\r\n    body: any,\r\n    params?: any,\r\n    headers?: HttpHeaders,\r\n    customUrl?: string): Observable<U> {\r\n    const customHeadhers: HttpHeaders = this.buildHeaders(headers);\r\n    const url: string = this.buildUrl(modelType, customUrl);\r\n    const htmlParams = this.buildParams(params, undefined);\r\n    return this.httpClient.patch<U>(url, body, { headers: customHeadhers, params: htmlParams, withCredentials: true });\r\n  }\r\n  createRecord<T extends BaseModel>(modelType: ModelType<T>, data?: any): T {\r\n    return new modelType(this, data);\r\n  }\r\n\r\n  saveRecord<T extends BaseModel>(\r\n    attributesMetadata: any, model: T,\r\n    params?: any,\r\n    headers?: HttpHeaders,\r\n    customUrl?: string,\r\n    customBody?: any\r\n  ): Observable<T> {\r\n    const modelType = model.constructor as ModelType<T>;\r\n    const modelConfig: ModelConfig = model.modelConfig;\r\n    const customHeadhers: HttpHeaders = this.buildHeaders(headers);\r\n    const url: string = this.buildUrl(modelType, customUrl);\r\n    const htmlParams = this.buildParams(params);\r\n\r\n    let httpCall: Observable<any>;\r\n\r\n    const body = customBody || this.modelToEntity(model, attributesMetadata);\r\n\r\n    if (model.id) {\r\n      // tslint:disable-next-line:max-line-length\r\n      httpCall = this.httpClient.patch(url + '/' + model.id, body, { headers: customHeadhers, params: htmlParams, withCredentials: true });\r\n    } else {\r\n      httpCall = this.httpClient.post(url, body, { headers: customHeadhers, params: htmlParams, withCredentials: true });\r\n    }\r\n\r\n    return httpCall\r\n      .pipe(\r\n        map(res => {\r\n          const data = this.resetMetadataAttributes(res, attributesMetadata, modelType);\r\n          return this.entityToModel(data, modelType);\r\n        }),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  patchRecord<T extends BaseModel>(\r\n    attributesMetadata: any, model: T,\r\n    origModel: T,\r\n    params?: any,\r\n    headers?: HttpHeaders,\r\n    customUrl?: string\r\n  ): Observable<T> {\r\n    const modelType = model.constructor as ModelType<T>;\r\n    const modelConfig: ModelConfig = model.modelConfig;\r\n    const customHeadhers: HttpHeaders = this.buildHeaders(headers);\r\n    const url: string = this.buildUrl(modelType, customUrl);\r\n    const htmlParams = this.buildParams(params);\r\n\r\n    let httpCall: Observable<any>;\r\n    let origData = { id: '' };\r\n    if (origModel)\r\n      origData = this.modelToEntity(origModel, origModel.attributeMetadata, true);\r\n    const newData = this.modelToEntity(model, attributesMetadata, true);\r\n    newData.id = origData.id;\r\n    const patch = compare(origData, newData);\r\n    if (patch.length > 0) {\r\n      httpCall = this.httpClient.patch(url + '/' + model.id, patch, { headers: customHeadhers, params: htmlParams, withCredentials: true });\r\n\r\n      return httpCall\r\n        .pipe(\r\n          map(res => {\r\n            const data = this.resetMetadataAttributes(res, attributesMetadata, modelType);\r\n            return this.entityToModel(data, modelType);\r\n          }),\r\n          catchError(this.handleError)\r\n        );\r\n    } else {\r\n      return new Observable((observer: Observer<T>) => {\r\n        observer.next(model);\r\n        observer.complete();\r\n      });\r\n    }\r\n  }\r\n  // getPatch<T extends BaseModel>(\r\n  //   model: T,\r\n  //   origModel: T): any {\r\n\r\n  // }\r\n  replaceRecord<T extends BaseModel>(\r\n    attributesMetadata: any, model: T,\r\n    params?: any,\r\n    headers?: HttpHeaders,\r\n    customUrl?: string,\r\n    customBody?: any\r\n  ): Observable<T> {\r\n    const modelType = model.constructor as ModelType<T>;\r\n    const modelConfig: ModelConfig = model.modelConfig;\r\n    const customHeadhers: HttpHeaders = this.buildHeaders(headers);\r\n    const url: string = this.buildUrl(modelType, customUrl);\r\n    const htmlParams = this.buildParams(params);\r\n\r\n    let httpCall: Observable<any>;\r\n\r\n    const body = customBody || this.modelToEntity(model, attributesMetadata, true);\r\n\r\n    if (model.id) {\r\n      httpCall = this.httpClient.put(url + '/' + model.id, body, { headers: customHeadhers, params: htmlParams, withCredentials: true });\r\n    } else {\r\n      httpCall = this.httpClient.post(url, body, { headers: customHeadhers, params: htmlParams, withCredentials: true });\r\n    }\r\n\r\n    return httpCall\r\n      .pipe(\r\n        map(res => {\r\n          const data = this.resetMetadataAttributes(res, attributesMetadata, modelType);\r\n          return this.entityToModel(data, modelType);\r\n        }),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n\r\n  deleteRecord<T extends BaseModel>(\r\n    modelType: ModelType<T>,\r\n    id: string,\r\n    headers?: HttpHeaders,\r\n    customUrl?: string\r\n  ): Observable<{}> {\r\n    const customHeadhers: HttpHeaders = this.buildHeaders(headers);\r\n    let url: string = this.buildUrl(modelType, customUrl);\r\n    if (!url.includes('share')) {\r\n      url = url + '/' + id;\r\n    }\r\n    // const idParam = new HttpParams().set('id', id);\r\n    return this.httpClient.delete(url, { headers: customHeadhers, withCredentials: true })\r\n      .pipe(catchError(this.handleError));\r\n  }\r\n\r\n  public buildUrl<T extends BaseModel>(\r\n    modelType: ModelType<T>,\r\n    customUrl?: string\r\n  ): string {\r\n\r\n    if (customUrl) {\r\n      return customUrl;\r\n    }\r\n\r\n    const modelConfig: ModelConfig = Reflect.getMetadata('BaseModelConfig', modelType);\r\n\r\n    const baseUrl = modelConfig.baseUrl || this.datastoreConfig.baseUrl;\r\n    const apiVersion = modelConfig.apiVersion || this.datastoreConfig.apiVersion;\r\n    const modelEndpointUrl: string = modelConfig.modelEndpointUrl || modelConfig.type;\r\n\r\n    const url: string = [baseUrl, apiVersion, modelEndpointUrl].filter((x) => x).join('/');\r\n\r\n    return url;\r\n  }\r\n\r\n  protected extractQueryData<T extends BaseModel>(\r\n    res: any,\r\n    modelType: ModelType<T>\r\n  ): BaseQueryData<T> {\r\n    let result;\r\n    const body: any = res;\r\n    const models: T[] = [];\r\n\r\n    for (const data of body.data) {\r\n      const model = this.entityToModel(data, modelType, undefined);\r\n      models.push(model);\r\n    }\r\n\r\n    result = new BaseQueryData(models, this.parseMeta(body, modelType));\r\n    return result;\r\n  }\r\n\r\n  protected deserializeModel<T extends BaseModel>(modelType: ModelType<T>, data: any) {\r\n    data = this.transformSerializedNamesToPropertyNames(modelType, data);\r\n    return new modelType(this, data);\r\n  }\r\n\r\n  protected handleError(error: HttpErrorResponse) {\r\n    if (error.error instanceof ErrorEvent) {\r\n      // A client-side or network error occurred. Handle it accordingly.\r\n      // console.error('An error occurred:', error.error.message);\r\n    } else {\r\n      // The backend returned an unsuccessful response code.\r\n      // The response body may contain clues as to what went wrong,\r\n      // console.error(\r\n      //   'Backend returned code ${error.status}, ' +\r\n      //   'body was: ${error.error}');\r\n    }\r\n    // return an observable with a user-facing error message\r\n    return throwError(error);\r\n  }\r\n\r\n  protected parseMeta(body: any, modelType: ModelType<BaseModel>): any {\r\n    const metaModel: any = Reflect.getMetadata('BaseModelConfig', modelType).meta;\r\n    return new metaModel(body);\r\n  }\r\n\r\n  protected resetMetadataAttributes<T extends BaseModel>(res: T, attributesMetadata: any, modelType: ModelType<T>) {\r\n    // TODO check why is attributesMetadata from the arguments never used\r\n\r\n    for (const propertyName in attributesMetadata) {\r\n      if (attributesMetadata.hasOwnProperty(propertyName)) {\r\n        const metadata: any = attributesMetadata[propertyName];\r\n\r\n        if (metadata.hasDirtyAttributes) {\r\n          metadata.hasDirtyAttributes = false;\r\n        }\r\n      }\r\n    }\r\n\r\n    if (res) {\r\n      res.attributeMetadata = attributesMetadata;\r\n    }\r\n    return res;\r\n  }\r\n\r\n  public get datastoreConfig(): DatastoreConfig {\r\n    const configFromDecorator: DatastoreConfig = Reflect.getMetadata('BaseDatastoreConfig', this.constructor);\r\n    return Object.assign(configFromDecorator, this.config);\r\n  }\r\n\r\n  protected transformSerializedNamesToPropertyNames<T extends BaseModel>(modelType: ModelType<T>, attributes: any) {\r\n    const serializedNameToPropertyName = this.getModelPropertyNames(modelType.prototype);\r\n    const properties: any = {};\r\n\r\n    Object.keys(serializedNameToPropertyName).forEach((serializedName) => {\r\n      if (attributes[serializedName] !== null && attributes[serializedName] !== undefined) {\r\n        properties[serializedNameToPropertyName[serializedName]] = attributes[serializedName];\r\n      }\r\n    });\r\n\r\n    return properties;\r\n  }\r\n\r\n  protected getModelPropertyNames(model: BaseModel) {\r\n    return Reflect.getMetadata('AttributeMapping', model);\r\n  }\r\n\r\n  public buildHeaders(customHeaders?: HttpHeaders): HttpHeaders {\r\n    const headers: any = {\r\n      Accept: 'application/json-patch+json',\r\n      // 'Content-Type': 'application/vnd.api+json',\r\n      'Content-Type': 'application/json-patch+json'\r\n    };\r\n    if (customHeaders && customHeaders.keys().length) {\r\n      // tslint:disable-next-line:variable-name\r\n      Object.assign({}, headers, customHeaders.keys().map(header_name => {\r\n        headers['' + header_name] = customHeaders.get(header_name);\r\n      }));\r\n    }\r\n    return new HttpHeaders(headers);\r\n  }\r\n\r\n  public buildParams(params: any, id?: string): HttpParams {\r\n    let httpParams = new HttpParams();\r\n    if (id) {\r\n      httpParams = httpParams.set('id', id);\r\n    }\r\n    if (params) {\r\n      Object.keys(params)\r\n        .filter(key => {\r\n          const v = params[key];\r\n          return (Array.isArray(v) || typeof v === 'string') ?\r\n            (v.length > 0) :\r\n            (v !== null && v !== undefined);\r\n        })\r\n        .forEach(key => {\r\n          httpParams = httpParams.set(key, params[key]);\r\n        });\r\n    }\r\n    return httpParams;\r\n  }\r\n\r\n\r\n  protected entityToModel<T extends BaseModel>(\r\n    res: any,\r\n    modelType: ModelType<T>,\r\n    model?: T\r\n  ) {\r\n    return this.extractRecordDataJson(res, modelType, model);\r\n  }\r\n\r\n\r\n  private extractRecordDataJson<T extends BaseModel>(\r\n    res: Response,\r\n    modelType: ModelType<T>,\r\n    model?: T\r\n  ): T {\r\n    const body: any = res;\r\n    if (!body) {\r\n      throw new Error('no body in response');\r\n    }\r\n    if (model) {\r\n      Object.assign(model, body);\r\n    }\r\n    const deserializedModel = model || this.deserializeModel(modelType, body.data || body);\r\n    return deserializedModel;\r\n  }\r\n\r\n  public modelToEntity<T extends BaseModel>(\r\n    model: T,\r\n    attributesMetadata: any,\r\n    allAttributes: boolean = false\r\n  ): any {\r\n    let attributes;\r\n    if (allAttributes) {\r\n      attributes = this.getAllAttributes(attributesMetadata, model);\r\n    } else {\r\n      attributes = this.getDirtyAttributes(attributesMetadata, model);\r\n    }\r\n    // this.getRelationships(model, attributes);\r\n    return attributes;\r\n  }\r\n  private _toQueryString(params: any): string {\r\n    return qs.stringify(params, { arrayFormat: 'brackets' });\r\n  }\r\n\r\n\r\n}\r\n"]}

package/esm2020/lib/services/base.service.mjs

@@ -0,0 +1,95 @@
+import { Injectable } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "./base-datastore.service";
+export class BaseService {
+    constructor(datastore) {
+        this.datastore = datastore;
+    }
+    setModelType(modelType) {
+        this.modelType = modelType;
+    }
+    get(id, customInclude = '') {
+        const response = this.datastore.findRecord(this.modelType, id, { customInclude });
+        return response;
+    }
+    getAll(page, pageSize, sort = '', filters = '', customInclude = '') {
+        const response = this.datastore.findAll(this.modelType, {
+            Page: page,
+            PageSize: pageSize,
+            Sorts: sort,
+            Filters: filters,
+            customInclude
+        });
+        return response;
+    }
+    delete(id) {
+        const response = this.datastore.deleteRecord(this.modelType, id);
+        return response;
+    }
+    getCustom(params, headers, customUrl, customResponseType) {
+        return this.datastore.getCustom(this.modelType, params, headers, customUrl, customResponseType);
+    }
+    postCustom(body, params, headers, customUrl) {
+        return this.datastore.postCustom(this.modelType, body, params, headers, customUrl);
+    }
+    patchCustom(body, params, headers, customUrl) {
+        return this.datastore.patchCustom(this.modelType, body, params, headers, customUrl);
+    }
+    // checkIfPropertyUnique(property: string, value: any): Observable<boolean> {
+    // }
+    save(docTypeOrFormGroup, id, origModel) {
+        if (id == null) {
+            let fromModel;
+            if (docTypeOrFormGroup instanceof FormGroup) {
+                fromModel = this.fromFormGroup(docTypeOrFormGroup, id);
+            }
+            else {
+                fromModel = docTypeOrFormGroup;
+            }
+            const data = this.datastore.createRecord(this.modelType, fromModel);
+            return data.save();
+        }
+        else {
+            return this.patch(docTypeOrFormGroup, origModel, id);
+        }
+    }
+    patch(docTypeOrFormGroup, origModel, id) {
+        let fromModel;
+        if (docTypeOrFormGroup instanceof FormGroup) {
+            fromModel = this.fromFormGroup(docTypeOrFormGroup, id);
+        }
+        else {
+            fromModel = docTypeOrFormGroup;
+        }
+        const data = this.datastore.createRecord(this.modelType, fromModel);
+        return data.patch(origModel);
+    }
+    newModel(data) {
+        return new this.modelType(this.datastore, data);
+    }
+    toFormGroup(fb, fromModel) {
+        if (fromModel === undefined) {
+            fromModel = this.newModel();
+        }
+        return fromModel.getFromGroup(fb);
+    }
+    fromFormGroup(formGroup, id) {
+        // const saveModel = this.newModel(formGroup.getRawValue());
+        // saveModel.id = id ? id : null;
+        // return saveModel;
+        const saveModel = this.newModel();
+        saveModel.getModelFromFormGroup(formGroup);
+        saveModel.id = id ? id : null;
+        return saveModel;
+    }
+}
+BaseService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: BaseService, deps: [{ token: i1.BaseDatastore }], target: i0.ɵɵFactoryTarget.Injectable });
+BaseService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: BaseService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: BaseService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BaseDatastore }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.service.js","sourceRoot":"","sources":["../../../../../../projects/rosoftlab/core/src/lib/services/base.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpHeaders } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { FormBuilder, FormGroup } from '@angular/forms';\r\nimport { Observable } from 'rxjs';\r\nimport { BaseQueryData } from '../models/base-query-data';\r\nimport { BaseModel } from '../models/base.model';\r\nimport { BaseDatastore, ModelType } from './base-datastore.service';\r\n\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport abstract class BaseService<T extends BaseModel> {\r\n  public modelType: ModelType<T>;\r\n  constructor(public datastore: BaseDatastore) {\r\n  }\r\n  setModelType(modelType: ModelType<T>) {\r\n    this.modelType = modelType;\r\n  }\r\n\r\n  get(id?: any, customInclude: string = ''): Observable<T> {\r\n    const response = this.datastore.findRecord(this.modelType, id, { customInclude });\r\n    return response;\r\n  }\r\n\r\n  getAll(page: number,\r\n    pageSize: number,\r\n    sort: string = '',\r\n    filters: string = '',\r\n    customInclude: string = ''): Observable<BaseQueryData<T>> {\r\n    const response = this.datastore.findAll(this.modelType,\r\n      {\r\n        Page: page,\r\n        PageSize: pageSize,\r\n        Sorts: sort,\r\n        Filters: filters,\r\n        customInclude\r\n      });\r\n    return response;\r\n  }\r\n  delete(id: any): Observable<{}> {\r\n    const response = this.datastore.deleteRecord(this.modelType, id);\r\n    return response;\r\n  }\r\n  getCustom<U>(params?: any,\r\n    headers?: HttpHeaders,\r\n    customUrl?: string,\r\n    customResponseType?: any): Observable<U> {\r\n    return this.datastore.getCustom<U, T>(this.modelType, params, headers, customUrl, customResponseType);\r\n  }\r\n  postCustom<U>(\r\n    body: any,\r\n    params?: any,\r\n    headers?: HttpHeaders,\r\n    customUrl?: string): Observable<U> {\r\n    return this.datastore.postCustom<U, T>(this.modelType, body, params, headers, customUrl);\r\n  }\r\n  patchCustom<U>(\r\n    body: any,\r\n    params?: any,\r\n    headers?: HttpHeaders,\r\n    customUrl?: string): Observable<U> {\r\n    return this.datastore.patchCustom<U, T>(this.modelType, body, params, headers, customUrl);\r\n  }\r\n  // checkIfPropertyUnique(property: string, value: any): Observable<boolean> {\r\n\r\n  // }\r\n\r\n  save(docTypeOrFormGroup: T | FormGroup, id?: any, origModel?: T): Observable<T> {\r\n    if (id == null) {\r\n      let fromModel: T;\r\n      if (docTypeOrFormGroup instanceof FormGroup) {\r\n        fromModel = this.fromFormGroup(docTypeOrFormGroup, id);\r\n      } else {\r\n        fromModel = docTypeOrFormGroup;\r\n      }\r\n      const data = this.datastore.createRecord(this.modelType, fromModel);\r\n      return data.save();\r\n    } else {\r\n      return this.patch(docTypeOrFormGroup, origModel, id);\r\n    }\r\n  }\r\n\r\n  patch(docTypeOrFormGroup: T | FormGroup, origModel: T, id?: any): Observable<T> {\r\n    let fromModel: T;\r\n    if (docTypeOrFormGroup instanceof FormGroup) {\r\n      fromModel = this.fromFormGroup(docTypeOrFormGroup, id);\r\n    } else {\r\n      fromModel = docTypeOrFormGroup;\r\n    }\r\n    const data = this.datastore.createRecord(this.modelType, fromModel);\r\n    return data.patch(origModel);\r\n  }\r\n\r\n  newModel(data?: any): T {\r\n    return new this.modelType(this.datastore, data);\r\n  }\r\n\r\n  toFormGroup(fb: FormBuilder, fromModel?: T): FormGroup {\r\n    if (fromModel === undefined) {\r\n      fromModel = this.newModel();\r\n    }\r\n    return fromModel.getFromGroup(fb);\r\n  }\r\n\r\n  fromFormGroup(formGroup: FormGroup, id?: any): T {\r\n    // const saveModel = this.newModel(formGroup.getRawValue());\r\n    // saveModel.id = id ? id : null;\r\n    // return saveModel;\r\n    const saveModel = this.newModel();\r\n    saveModel.getModelFromFormGroup(formGroup)\r\n    saveModel.id = id ? id : null;    \r\n    return saveModel;\r\n  }\r\n}"]}