@rosoftlab/core 1.0.0-alpha-0

package/esm2022/lib/resolvers/dynamically-class-resolver.mjs

@@ -0,0 +1,22 @@
+export function DynamicallyModelResolver(modelsImport, className = undefined) {
+    return (route, state) => {
+        if (className == undefined)
+            className = route.paramMap.get('className');
+        const instance = getInstance(className, modelsImport);
+        if (!instance) {
+            throw new Error(`Invalid className: ${className}`);
+        }
+        return instance;
+    };
+}
+function getInstance(className, modelsImport) {
+    return modelsImport.then((module) => module[toProperCase(className)]);
+    // return modelsImport.then((module) => ({ modelInstance: module[toProperCase(className)] })
+    // );
+}
+function toProperCase(str) {
+    return str.replace(/\w\S*/g, (txt) => {
+        return txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase();
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/resolvers/dynamically-service-resolver.mjs

@@ -0,0 +1,22 @@
+export function DynamicallyServiceResolver(serviceImport, serviceName) {
+    return (route, state) => {
+        const instance = getInstance(serviceName, serviceImport);
+        if (!instance) {
+            throw new Error(`Invalid className: ${serviceName}`);
+        }
+        return instance;
+    };
+}
+function getInstance(serviceName, serviceImport) {
+    return serviceImport.then((module) => module[toProperCase(serviceName)]); // return Promise.all([serviceImport]).then(
+    //   (module) => ({
+    //     serviceInstance: module[toProperCase(serviceName)],
+    //   })
+    // );
+}
+function toProperCase(str) {
+    return str.replace(/\w\S*/g, (txt) => {
+        return txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase();
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/resolvers/index.mjs

@@ -0,0 +1,3 @@
+export { DynamicallyModelResolver } from './dynamically-class-resolver';
+export { DynamicallyServiceResolver } from './dynamically-service-resolver';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9yb3NvZnRsYWIvY29yZS9zcmMvbGliL3Jlc29sdmVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQTtBQUN2RSxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IER5bmFtaWNhbGx5TW9kZWxSZXNvbHZlciB9IGZyb20gJy4vZHluYW1pY2FsbHktY2xhc3MtcmVzb2x2ZXInXHJcbmV4cG9ydCB7IER5bmFtaWNhbGx5U2VydmljZVJlc29sdmVyIH0gZnJvbSAnLi9keW5hbWljYWxseS1zZXJ2aWNlLXJlc29sdmVyJ1xyXG5cclxuIl19

package/esm2022/lib/rsl-base-module.mjs

@@ -0,0 +1,64 @@
+import { CommonModule } from '@angular/common';
+import { HttpClient, HttpClientModule } from '@angular/common/http';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { TranslateLoader, TranslateModule } from '@ngx-translate/core';
+import { Configurations } from './configurations';
+import { PROVIDERS } from './providers';
+import { TranslateloaderService } from './services/translate-loader.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class RslBaseModule {
+    static forRoot(config) {
+        return {
+            ngModule: RslBaseModule,
+            providers: [
+                PROVIDERS,
+                { provide: Configurations, useValue: config }
+            ]
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: RslBaseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.1", ngImport: i0, type: RslBaseModule, imports: [CommonModule, i1.TranslateModule, ReactiveFormsModule], exports: [HttpClientModule,
+            TranslateModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: RslBaseModule, providers: [
+            PROVIDERS
+        ], imports: [CommonModule,
+            TranslateModule.forRoot({
+                loader: {
+                    provide: TranslateLoader,
+                    useClass: TranslateloaderService,
+                    deps: [HttpClient]
+                },
+                // missingTranslationHandler: { provide: MissingTranslationHandler, useClass: MyMissingTranslationHandler },
+                useDefaultLang: false,
+            }),
+            ReactiveFormsModule, HttpClientModule,
+            TranslateModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: RslBaseModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        TranslateModule.forRoot({
+                            loader: {
+                                provide: TranslateLoader,
+                                useClass: TranslateloaderService,
+                                deps: [HttpClient]
+                            },
+                            // missingTranslationHandler: { provide: MissingTranslationHandler, useClass: MyMissingTranslationHandler },
+                            useDefaultLang: false,
+                        }),
+                        ReactiveFormsModule
+                    ],
+                    providers: [
+                        PROVIDERS
+                    ],
+                    exports: [
+                        HttpClientModule,
+                        TranslateModule,
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,342 @@
+import { HttpClient, 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 { CacheService } from './cache.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./cache.service";
+export class BaseDatastore {
+    // 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;
+    }
+    constructor(httpClient, cacheService) {
+        this.httpClient = httpClient;
+        this.cacheService = cacheService;
+        // 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;
+    }
+    findAll(modelType, params, headers, customUrl) {
+        const customHeadhers = this.buildHeaders(headers);
+        const htmlParams = this.buildParams(modelType, 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(modelType, params);
+        const response = this.httpClient.get(url, { headers: customHeadhers, params: htmlParams, withCredentials: true })
+            .pipe(map(res => this.entityToModel(res, modelType, undefined)), catchError(this.handleError));
+        return response;
+    }
+    getCustom(modelType, params, headers, customUrl, customResponseType) {
+        const customHeadhers = this.buildHeaders(headers);
+        const url = this.buildUrl(modelType, customUrl);
+        const htmlParams = this.buildParams(modelType, params);
+        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(modelType, params);
+        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(modelType, params);
+        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(modelType, 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 => {
+            this.cacheService.clearCacheContainingKeyword(url);
+            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(modelType, 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 => {
+                this.cacheService.clearCacheContainingKeyword(url);
+                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(modelType, 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 => {
+            this.cacheService.clearCacheContainingKeyword(url);
+            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(map(res => {
+            this.cacheService.clearCacheContainingKeyword(url);
+            return res;
+        }), 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(modelType, params) {
+        let httpParams = new HttpParams();
+        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]);
+            });
+        }
+        const modelConfig = Reflect.getMetadata('BaseModelConfig', modelType);
+        httpParams = httpParams.set('bypassCache', modelConfig.bypassCache || false);
+        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' });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: BaseDatastore, deps: [{ token: i1.HttpClient }, { token: i2.CacheService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: BaseDatastore }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: BaseDatastore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.CacheService }]; } });
+//# 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":"AAAA,OAAO,EAAE,UAAU,EAAqB,WAAW,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAC9F,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AACzB,OAAO,EAAE,UAAU,EAAY,UAAU,EAAE,MAAM,MAAM,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAGjD,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;;;;AAI/C,MAAM,OAAO,aAAa;IASxB,gCAAgC;IAEhC,IAAY,kBAAkB;QAC5B,IAAI,IAAI,CAAC,eAAe,CAAC,SAAS;eAC7B,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,kBAAkB,EAAE;YACtD,OAAO,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,kBAAkB,CAAC;SAC1D;aAAM;YACL,OAAO,aAAa,CAAC,kBAAkB,CAAC;SACzC;IACH,CAAC;IAED,IAAW,gBAAgB;QACzB,IAAI,IAAI,CAAC,eAAe,CAAC,SAAS;eAC7B,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,gBAAgB,EAAE;YACpD,OAAO,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,gBAAgB,CAAC;SACxD;aAAM;YACL,OAAO,aAAa,CAAC,gBAAgB,CAAC;SACvC;IACH,CAAC;IAED,qCAAqC;IAE7B,MAAM,CAAC,kBAAkB,CAAC,kBAAuB;QACvD,MAAM,SAAS,GAAQ,EAAE,CAAC;QAE1B,KAAK,MAAM,YAAY,IAAI,kBAAkB,EAAE;YAC7C,IAAI,kBAAkB,CAAC,cAAc,CAAC,YAAY,CAAC,EAAE;gBACnD,MAAM,QAAQ,GAAQ,kBAAkB,CAAC,YAAY,CAAC,CAAC;gBAEvD,IAAI,QAAQ,CAAC,kBAAkB,EAAE;oBAC/B,MAAM,aAAa,GAAG,QAAQ,CAAC,cAAc,IAAI,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,YAAY,CAAC;oBAC/F,SAAS,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC,kBAAkB,CAAC,CAAC,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;iBAC1G;aACF;SACF;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,MAAM,CAAC,gBAAgB,CAAC,kBAAuB;QACrD,MAAM,SAAS,GAAQ,EAAE,CAAC;QAE1B,KAAK,MAAM,YAAY,IAAI,kBAAkB,EAAE;YAC7C,IAAI,kBAAkB,CAAC,cAAc,CAAC,YAAY,CAAC,EAAE;gBACnD,MAAM,QAAQ,GAAQ,kBAAkB,CAAC,YAAY,CAAC,CAAC;gBACvD,MAAM,aAAa,GAAG,QAAQ,CAAC,cAAc,IAAI,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,YAAY,CAAC;gBAC/F,SAAS,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC,kBAAkB,CAAC,CAAC,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;aAC1G;SACF;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,YACY,UAAsB,EACtB,YAA0B;QAD1B,eAAU,GAAV,UAAU,CAAY;QACtB,iBAAY,GAAZ,YAAY,CAAc;QA5DtC,yCAAyC;QACjC,WAAM,GAAoD,EAAE,CAAC;QACrE,gCAAgC;QAChC,qCAAqC;QAC7B,kBAAa,GAAa,IAAI,CAAC,eAAe,CAAC,SAAS;eAC3D,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YACjD,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC;IAwDrE,CAAC;IAED,OAAO,CACL,SAAuB,EACvB,MAAY,EACZ,OAAqB,EACrB,SAAkB;QAElB,MAAM,cAAc,GAAgB,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC/D,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACvD,MAAM,GAAG,GAAW,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QAExD,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,EACtC,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC;aACtE,IAAI,CACH,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,EACjD,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAC7B,CAAC;QACJ,OAAO,QAAQ,CAAC;IAElB,CAAC;IAED,UAAU,CACR,SAAuB,EACvB,EAAW,EACX,MAAY,EACZ,OAAqB,EACrB,SAAkB;QAElB,MAAM,cAAc,GAAgB,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC/D,IAAI,GAAG,GAAW,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QACtD,IAAI,EAAE,EAAE;YACN,GAAG,IAAI,GAAG,GAAG,EAAE,CAAC;SACjB;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC;aAC9G,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,EAC7D,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAC7B,CAAC;QACJ,OAAO,QAAQ,CAAC;IAElB,CAAC;IACD,SAAS,CAAyB,SAAuB,EACvD,MAAY,EACZ,OAAqB,EACrB,SAAkB,EAClB,kBAAwB;QACxB,MAAM,cAAc,GAAgB,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC/D,MAAM,GAAG,GAAW,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QACxD,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACvD,IAAI,CAAC,kBAAkB;YACrB,kBAAkB,GAAG,MAAM,CAAC;QAC9B,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,GAAG,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,IAAI,EAAE,YAAY,EAAE,kBAAkB,EAAE,CAAC,CAAC;IAC/I,CAAC;IAED,UAAU,CAAyB,SAAuB,EACxD,IAAS,EACT,MAAY,EACZ,OAAqB,EACrB,SAAkB;QAClB,MAAM,cAAc,GAAgB,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC/D,MAAM,GAAG,GAAW,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QACxD,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACvD,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAI,GAAG,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,IAAI,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1I,CAAC;IAED,WAAW,CAAyB,SAAuB,EACzD,IAAS,EACT,MAAY,EACZ,OAAqB,EACrB,SAAkB;QAClB,MAAM,cAAc,GAAgB,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC/D,MAAM,GAAG,GAAW,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QACxD,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACvD,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,CAAI,GAAG,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;IACrH,CAAC;IACD,YAAY,CAAsB,SAAuB,EAAE,IAAU;QACnE,OAAO,IAAI,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACnC,CAAC;IAED,UAAU,CACR,kBAAuB,EAAE,KAAQ,EACjC,MAAY,EACZ,OAAqB,EACrB,SAAkB,EAClB,UAAgB;QAEhB,MAAM,SAAS,GAAG,KAAK,CAAC,WAA2B,CAAC;QACpD,MAAM,WAAW,GAAgB,KAAK,CAAC,WAAW,CAAC;QACnD,MAAM,cAAc,GAAgB,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC/D,MAAM,GAAG,GAAW,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QACxD,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QAEvD,IAAI,QAAyB,CAAC;QAE9B,MAAM,IAAI,GAAG,UAAU,IAAI,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC;QAEzE,IAAI,KAAK,CAAC,EAAE,EAAE;YACZ,2CAA2C;YAC3C,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,GAAG,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;SACtI;aAAM;YACL,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;SACpH;QAED,OAAO,QAAQ;aACZ,IAAI,CACH,GAAG,CAAC,GAAG,CAAC,EAAE;YACR,IAAI,CAAC,YAAY,CAAC,2BAA2B,CAAC,GAAG,CAAC,CAAC;YACnD,MAAM,IAAI,GAAG,IAAI,CAAC,uBAAuB,CAAC,GAAG,EAAE,kBAAkB,EAAE,SAAS,CAAC,CAAC;YAC9E,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAC7C,CAAC,CAAC,EACF,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAC7B,CAAC;IACN,CAAC;IAED,WAAW,CACT,kBAAuB,EAAE,KAAQ,EACjC,SAAY,EACZ,MAAY,EACZ,OAAqB,EACrB,SAAkB;QAElB,MAAM,SAAS,GAAG,KAAK,CAAC,WAA2B,CAAC;QACpD,MAAM,WAAW,GAAgB,KAAK,CAAC,WAAW,CAAC;QACnD,MAAM,cAAc,GAAgB,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC/D,MAAM,GAAG,GAAW,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QACxD,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QAEvD,IAAI,QAAyB,CAAC;QAC9B,IAAI,QAAQ,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;QAC1B,IAAI,SAAS;YACX,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,SAAS,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;QAC9E,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,kBAAkB,EAAE,IAAI,CAAC,CAAC;QACpE,OAAO,CAAC,EAAE,GAAG,QAAQ,CAAC,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QACzC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;YACpB,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,GAAG,KAAK,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;YAEtI,OAAO,QAAQ;iBACZ,IAAI,CACH,GAAG,CAAC,GAAG,CAAC,EAAE;gBACR,IAAI,CAAC,YAAY,CAAC,2BAA2B,CAAC,GAAG,CAAC,CAAC;gBACnD,MAAM,IAAI,GAAG,IAAI,CAAC,uBAAuB,CAAC,GAAG,EAAE,kBAAkB,EAAE,SAAS,CAAC,CAAC;gBAC9E,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;YAC7C,CAAC,CAAC,EACF,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAC7B,CAAC;SACL;aAAM;YACL,OAAO,IAAI,UAAU,CAAC,CAAC,QAAqB,EAAE,EAAE;gBAC9C,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACrB,QAAQ,CAAC,QAAQ,EAAE,CAAC;YACtB,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;IACD,iCAAiC;IACjC,cAAc;IACd,yBAAyB;IAEzB,IAAI;IACJ,aAAa,CACX,kBAAuB,EAAE,KAAQ,EACjC,MAAY,EACZ,OAAqB,EACrB,SAAkB,EAClB,UAAgB;QAEhB,MAAM,SAAS,GAAG,KAAK,CAAC,WAA2B,CAAC;QACpD,MAAM,WAAW,GAAgB,KAAK,CAAC,WAAW,CAAC;QACnD,MAAM,cAAc,GAAgB,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC/D,MAAM,GAAG,GAAW,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QACxD,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QAEvD,IAAI,QAAyB,CAAC;QAE9B,MAAM,IAAI,GAAG,UAAU,IAAI,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,kBAAkB,EAAE,IAAI,CAAC,CAAC;QAE/E,IAAI,KAAK,CAAC,EAAE,EAAE;YACZ,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,GAAG,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;SACpI;aAAM;YACL,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;SACpH;QAED,OAAO,QAAQ;aACZ,IAAI,CACH,GAAG,CAAC,GAAG,CAAC,EAAE;YACR,IAAI,CAAC,YAAY,CAAC,2BAA2B,CAAC,GAAG,CAAC,CAAC;YACnD,MAAM,IAAI,GAAG,IAAI,CAAC,uBAAuB,CAAC,GAAG,EAAE,kBAAkB,EAAE,SAAS,CAAC,CAAC;YAC9E,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAC7C,CAAC,CAAC,EACF,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAC7B,CAAC;IACN,CAAC;IAGD,YAAY,CACV,SAAuB,EACvB,EAAU,EACV,OAAqB,EACrB,SAAkB;QAElB,MAAM,cAAc,GAAgB,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC/D,IAAI,GAAG,GAAW,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QACtD,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE;YAC1B,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAAE,CAAC;SACtB;QACD,kDAAkD;QAClD,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC;aACnF,IAAI,CACH,GAAG,CAAC,GAAG,CAAC,EAAE;YACR,IAAI,CAAC,YAAY,CAAC,2BAA2B,CAAC,GAAG,CAAC,CAAC;YACnD,OAAO,GAAG,CAAC;QACb,CAAC,CACA,EACD,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAC7B,CAAC;IACN,CAAC;IAEM,QAAQ,CACb,SAAuB,EACvB,SAAkB;QAGlB,IAAI,SAAS,EAAE;YACb,OAAO,SAAS,CAAC;SAClB;QAED,MAAM,WAAW,GAAgB,OAAO,CAAC,WAAW,CAAC,iBAAiB,EAAE,SAAS,CAAC,CAAC;QAEnF,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,IAAI,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC;QACpE,MAAM,UAAU,GAAG,WAAW,CAAC,UAAU,IAAI,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC;QAC7E,MAAM,gBAAgB,GAAW,WAAW,CAAC,gBAAgB,IAAI,WAAW,CAAC,IAAI,CAAC;QAElF,MAAM,GAAG,GAAW,CAAC,OAAO,EAAE,UAAU,EAAE,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAEvF,OAAO,GAAG,CAAC;IACb,CAAC;IAES,gBAAgB,CACxB,GAAQ,EACR,SAAuB;QAEvB,IAAI,MAAM,CAAC;QACX,MAAM,IAAI,GAAQ,GAAG,CAAC;QACtB,MAAM,MAAM,GAAQ,EAAE,CAAC;QAEvB,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE;YAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;YAC7D,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACpB;QAED,MAAM,GAAG,IAAI,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;QACpE,OAAO,MAAM,CAAC;IAChB,CAAC;IAES,gBAAgB,CAAsB,SAAuB,EAAE,IAAS;QAChF,IAAI,GAAG,IAAI,CAAC,uCAAuC,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QACrE,OAAO,IAAI,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACnC,CAAC;IAES,WAAW,CAAC,KAAwB;QAC5C,IAAI,KAAK,CAAC,KAAK,YAAY,UAAU,EAAE;YACrC,kEAAkE;YAClE,4DAA4D;SAC7D;aAAM;YACL,sDAAsD;YACtD,6DAA6D;YAC7D,iBAAiB;YACjB,gDAAgD;YAChD,iCAAiC;SAClC;QACD,wDAAwD;QACxD,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;IAES,SAAS,CAAC,IAAS,EAAE,SAA+B;QAC5D,MAAM,SAAS,GAAQ,OAAO,CAAC,WAAW,CAAC,iBAAiB,EAAE,SAAS,CAAC,CAAC,IAAI,CAAC;QAC9E,OAAO,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC;IAES,uBAAuB,CAAsB,GAAM,EAAE,kBAAuB,EAAE,SAAuB;QAC7G,qEAAqE;QAErE,KAAK,MAAM,YAAY,IAAI,kBAAkB,EAAE;YAC7C,IAAI,kBAAkB,CAAC,cAAc,CAAC,YAAY,CAAC,EAAE;gBACnD,MAAM,QAAQ,GAAQ,kBAAkB,CAAC,YAAY,CAAC,CAAC;gBAEvD,IAAI,QAAQ,CAAC,kBAAkB,EAAE;oBAC/B,QAAQ,CAAC,kBAAkB,GAAG,KAAK,CAAC;iBACrC;aACF;SACF;QAED,IAAI,GAAG,EAAE;YACP,GAAG,CAAC,iBAAiB,GAAG,kBAAkB,CAAC;SAC5C;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED,IAAW,eAAe;QACxB,MAAM,mBAAmB,GAAoB,OAAO,CAAC,WAAW,CAAC,qBAAqB,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAC1G,OAAO,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACzD,CAAC;IAES,uCAAuC,CAAsB,SAAuB,EAAE,UAAe;QAC7G,MAAM,4BAA4B,GAAG,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QACrF,MAAM,UAAU,GAAQ,EAAE,CAAC;QAE3B,MAAM,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAC,OAAO,CAAC,CAAC,cAAc,EAAE,EAAE;YACnE,IAAI,UAAU,CAAC,cAAc,CAAC,KAAK,IAAI,IAAI,UAAU,CAAC,cAAc,CAAC,KAAK,SAAS,EAAE;gBACnF,UAAU,CAAC,4BAA4B,CAAC,cAAc,CAAC,CAAC,GAAG,UAAU,CAAC,cAAc,CAAC,CAAC;aACvF;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,UAAU,CAAC;IACpB,CAAC;IAES,qBAAqB,CAAC,KAAgB;QAC9C,OAAO,OAAO,CAAC,WAAW,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;IACxD,CAAC;IAEM,YAAY,CAAC,aAA2B;QAC7C,MAAM,OAAO,GAAQ;YACnB,MAAM,EAAE,6BAA6B;YACrC,8CAA8C;YAC9C,cAAc,EAAE,6BAA6B;SAC9C,CAAC;QACF,IAAI,aAAa,IAAI,aAAa,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE;YAChD,yCAAyC;YACzC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,aAAa,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE;gBAChE,OAAO,CAAC,EAAE,GAAG,WAAW,CAAC,GAAG,aAAa,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;YAC7D,CAAC,CAAC,CAAC,CAAC;SACL;QACD,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC;IAClC,CAAC;IAEM,WAAW,CAAsB,SAAuB,EAC7D,MAAW;QACX,IAAI,UAAU,GAAG,IAAI,UAAU,EAAE,CAAC;QAClC,IAAI,MAAM,EAAE;YACV,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;iBAChB,MAAM,CAAC,GAAG,CAAC,EAAE;gBACZ,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;gBACtB,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC;oBAClD,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;oBAChB,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS,CAAC,CAAC;YACpC,CAAC,CAAC;iBACD,OAAO,CAAC,GAAG,CAAC,EAAE;gBACb,UAAU,GAAG,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YAChD,CAAC,CAAC,CAAC;SACN;QACD,MAAM,WAAW,GAAgB,OAAO,CAAC,WAAW,CAAC,iBAAiB,EAAE,SAAS,CAAC,CAAC;QACnF,UAAU,GAAG,UAAU,CAAC,GAAG,CAAC,aAAa,EAAE,WAAW,CAAC,WAAW,IAAI,KAAK,CAAC,CAAC;QAC7E,OAAO,UAAU,CAAC;IACpB,CAAC;IAGS,aAAa,CACrB,GAAQ,EACR,SAAuB,EACvB,KAAS;QAET,OAAO,IAAI,CAAC,qBAAqB,CAAC,GAAG,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IAC3D,CAAC;IAGO,qBAAqB,CAC3B,GAAa,EACb,SAAuB,EACvB,KAAS;QAET,MAAM,IAAI,GAAQ,GAAG,CAAC;QACtB,IAAI,CAAC,IAAI,EAAE;YACT,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;SACxC;QACD,IAAI,KAAK,EAAE;YACT,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;SAC5B;QACD,MAAM,iBAAiB,GAAG,KAAK,IAAI,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC;QACvF,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAEM,aAAa,CAClB,KAAQ,EACR,kBAAuB,EACvB,gBAAyB,KAAK;QAE9B,IAAI,UAAU,CAAC;QACf,IAAI,aAAa,EAAE;YACjB,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;SAC/D;aAAM;YACL,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;SACjE;QACD,4CAA4C;QAC5C,OAAO,UAAU,CAAC;IACpB,CAAC;IACO,cAAc,CAAC,MAAW;QAChC,OAAO,EAAE,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;IAC3D,CAAC;8GA9cU,aAAa;kHAAb,aAAa;;2FAAb,aAAa;kBADzB,UAAU","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\nimport { CacheService } from './cache.service';\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(\r\n    protected httpClient: HttpClient,\r\n    protected cacheService: CacheService\r\n  ) {\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(modelType, 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\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(modelType, params);\r\n    const response = 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    return response;\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(modelType, params);\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(modelType, params);\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(modelType, params);\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(modelType, 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          this.cacheService.clearCacheContainingKeyword(url);\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(modelType, 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            this.cacheService.clearCacheContainingKeyword(url);\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(modelType, 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          this.cacheService.clearCacheContainingKeyword(url);\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(\r\n        map(res => {\r\n          this.cacheService.clearCacheContainingKeyword(url);\r\n          return res;\r\n        }\r\n        ),\r\n        catchError(this.handleError)\r\n      );\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<T extends BaseModel>(modelType: ModelType<T>,\r\n    params: any): HttpParams {\r\n    let httpParams = new HttpParams();\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    const modelConfig: ModelConfig = Reflect.getMetadata('BaseModelConfig', modelType);\r\n    httpParams = httpParams.set('bypassCache', modelConfig.bypassCache || false);\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"]}