@rosoftlab/core 1.0.0-alpha-0

package/fesm2022/rosoftlab-core.mjs

@@ -0,0 +1,1637 @@
+import * as i0 from '@angular/core';
+import { Component, Input, Injectable, Directive, ContentChildren, Inject, Pipe, Optional, NgModule } from '@angular/core';
+import * as i6 from '@angular/common';
+import { DatePipe, DecimalPipe, PercentPipe, CommonModule } from '@angular/common';
+import * as i1$1 from '@angular/forms';
+import { UntypedFormGroup, UntypedFormControl, Validators, ReactiveFormsModule } from '@angular/forms';
+import * as i2 from '@angular/router';
+import * as i1$2 from '@ngx-translate/core';
+import { TranslateModule, TranslateLoader } from '@ngx-translate/core';
+import { Observable, throwError, from, merge, BehaviorSubject, combineLatest, of } from 'rxjs';
+import * as i1 from '@angular/common/http';
+import { HttpHeaders, HttpParams, HttpErrorResponse, HttpResponse, HttpClientModule, HttpClient } from '@angular/common/http';
+import { compare } from 'fast-json-patch';
+import * as qs from 'qs';
+import { map, catchError, switchMap, tap } from 'rxjs/operators';
+import Swal from 'sweetalert2';
+import 'reflect-metadata';
+import { parseISO } from 'date-fns';
+
+class FieldErrorDisplayComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: FieldErrorDisplayComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.1", type: FieldErrorDisplayComponent, selector: "rsl-field-error-display", inputs: { errorMsg: "errorMsg", displayError: "displayError" }, ngImport: i0, template: "<div *ngIf=\"displayError\" >\n  <!-- <span class=\"glyphicon glyphicon-remove form-control-feedback fix-error-icon\"></span> -->\n  <span class=\"sr-only\">(error)</span>\n  <div class=\"error-msg\">\n    {{ errorMsg }}\n  </div>\n</div>\n", styles: [".error-msg{color:red}.fix-error-icon{top:27px}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: FieldErrorDisplayComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'rsl-field-error-display', template: "<div *ngIf=\"displayError\" >\n  <!-- <span class=\"glyphicon glyphicon-remove form-control-feedback fix-error-icon\"></span> -->\n  <span class=\"sr-only\">(error)</span>\n  <div class=\"error-msg\">\n    {{ errorMsg }}\n  </div>\n</div>\n", styles: [".error-msg{color:red}.fix-error-icon{top:27px}\n"] }]
+        }], propDecorators: { errorMsg: [{
+                type: Input
+            }], displayError: [{
+                type: Input
+            }] } });
+
+class PageNotFoundComponent {
+    constructor() {
+    }
+    ngOnInit() {
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: PageNotFoundComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.1", type: PageNotFoundComponent, selector: "rsl-page-not-found", ngImport: i0, template: "<div class=\"forms-view-container\">\n  <div class=\"under-construction-view-container\">\n    Page not found\n  </div>\n</div>", styles: [".under-construction-view-container{height:calc(100vh - 250px);margin:60px 0 0;padding:0;display:flex;justify-content:center;align-items:center;box-sizing:border-box;font-size:1.8em;line-height:1.3em;font-weight:300;color:#58585b;text-align:center}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: PageNotFoundComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'rsl-page-not-found', template: "<div class=\"forms-view-container\">\n  <div class=\"under-construction-view-container\">\n    Page not found\n  </div>\n</div>", styles: [".under-construction-view-container{height:calc(100vh - 250px);margin:60px 0 0;padding:0;display:flex;justify-content:center;align-items:center;box-sizing:border-box;font-size:1.8em;line-height:1.3em;font-weight:300;color:#58585b;text-align:center}\n"] }]
+        }], ctorParameters: function () { return []; } });
+
+class UnderConstructionComponent {
+    constructor() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: UnderConstructionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.1", type: UnderConstructionComponent, selector: "rsl-under-construction", ngImport: i0, template: "<div class=\"forms-view-container\">\n  <div class=\"under-construction-view-container\">\n    Page under construction\n  </div>\n</div>", styles: [".under-construction-view-container{height:calc(100vh - 250px);margin:60px 0 0;padding:0;display:flex;justify-content:center;align-items:center;box-sizing:border-box;font-size:1.8em;line-height:1.3em;font-weight:300;color:#58585b;text-align:center}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: UnderConstructionComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'rsl-under-construction', template: "<div class=\"forms-view-container\">\n  <div class=\"under-construction-view-container\">\n    Page under construction\n  </div>\n</div>", styles: [".under-construction-view-container{height:calc(100vh - 250px);margin:60px 0 0;padding:0;display:flex;justify-content:center;align-items:center;box-sizing:border-box;font-size:1.8em;line-height:1.3em;font-weight:300;color:#58585b;text-align:center}\n"] }]
+        }], ctorParameters: function () { return []; } });
+
+class BaseQueryData {
+    constructor(jsonApiModels, metaData) {
+        this.jsonApiModels = jsonApiModels;
+        this.metaData = metaData;
+    }
+    getModels() {
+        return this.jsonApiModels;
+    }
+    getMeta() {
+        return this.metaData;
+    }
+}
+
+class CacheService {
+    constructor() {
+        this.cache = {};
+    }
+    get(key) {
+        const cachedItem = this.cache[key];
+        if (cachedItem && cachedItem.expiration > Date.now()) {
+            return cachedItem.data;
+        }
+        this.delete(key);
+        return null;
+    }
+    set(key, data, expiresInMs) {
+        const expiration = Date.now() + expiresInMs;
+        this.cache[key] = { data, expiration };
+    }
+    delete(key) {
+        delete this.cache[key];
+    }
+    clearCacheContainingKeyword(keyword) {
+        const keysToDelete = Object.keys(this.cache).filter(key => key.includes(keyword));
+        keysToDelete.forEach(key => this.delete(key));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: CacheService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: CacheService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: CacheService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+
+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: 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: CacheService }]; } });
+
+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 UntypedFormGroup) {
+                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 UntypedFormGroup) {
+            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;
+    }
+    getSelectValues(property) {
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: BaseService, deps: [{ token: BaseDatastore }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: BaseService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: BaseService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: BaseDatastore }]; } });
+
+/**
+ * Async modal dialog service
+ * DialogService makes this app easier to test by faking this service.
+ * TODO: better modal implementation that doesn't use window.confirm
+ */
+class DialogService {
+    /**
+     * Ask user to confirm an action. `message` explains the action and choices.
+     * Returns observable resolving to `true`=confirm or `false`=cancel
+     */
+    constructor() { }
+    confirm(message, text, confirmButtonText = 'Delete', cancelButtonText = 'Cancel') {
+        const confirmation = Swal.fire({
+            title: message || 'Are you sure?',
+            icon: 'warning',
+            text: text || '',
+            showCancelButton: true,
+            confirmButtonText: confirmButtonText,
+            cancelButtonText: cancelButtonText,
+            customClass: {
+                confirmButton: 'btn btn-red btn-fill btn-wd',
+                cancelButton: 'btn btn-grey btn-fill btn-wd',
+            },
+            buttonsStyling: false,
+            reverseButtons: true
+        })
+            .then((result) => {
+            if (result.value) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        }).catch();
+        return from(confirmation);
+    }
+    showSaveMessage(message, title) {
+        const confirmation = Swal.fire({
+            icon: 'success',
+            title: message,
+            timer: 2000,
+            showConfirmButton: false,
+            // customClass: 'overflow-hidden',
+            buttonsStyling: false
+        }).then(() => {
+            return true;
+        }, () => {
+            return false;
+        }).catch();
+        return from(confirmation);
+    }
+    showRegisteredMessage(message, title) {
+        const confirmation = Swal.fire({
+            icon: 'success',
+            title: message,
+            showConfirmButton: true,
+            customClass: {
+                confirmButton: 'btn btn-success',
+            },
+            buttonsStyling: false
+        }).then(() => {
+            return true;
+        }, () => {
+            return false;
+        }).catch();
+        return from(confirmation);
+    }
+    // notification(message?: string, type?: NotificationType, fromPosition?: NotificationFrom, align?: NotificationAlign, timer?: number) {
+    //   if (!type) {
+    //     type = NotificationType.success;
+    //   }
+    //   if (!fromPosition) {
+    //     fromPosition = NotificationFrom.bottom;
+    //   }
+    //   if (!align) {
+    //     align = NotificationAlign.center;
+    //   }
+    //   if (!timer) {
+    //     timer = 3000;
+    //   }
+    //   $.notify({
+    //     icon: 'notifications',
+    //     message: message
+    //   }, {
+    //       type: type,
+    //       timer: 3000,
+    //       placement: {
+    //         from: from,
+    //         align: align
+    //       }
+    //     });
+    // }
+    showErrorMessage(e, message) {
+        if (!message) {
+            message = 'Validation errors';
+        }
+        if (e instanceof HttpErrorResponse) {
+            // Validation errors
+            if (e.status === 400) {
+                const errors = e.error.errors;
+                if (errors) {
+                    errors.forEach(error => {
+                        message += error.field + ' ' + error.detail + '\n';
+                    });
+                    // message = errors.detail;
+                    // if (detail.relationships) {
+                    //   detail.relationships.forEach(relation => {
+                    //     console.log(relation);
+                    //   });
+                    // }
+                }
+            }
+        }
+        const confirmation = Swal.fire({
+            icon: 'error',
+            title: message,
+            // timer: 2000,
+            showConfirmButton: true,
+            customClass: {
+                confirmButton: 'btn btn-success',
+            },
+            buttonsStyling: false
+        }).then(() => {
+            return true;
+        }, () => {
+            return false;
+        }).catch();
+        return from(confirmation);
+    }
+    getTextTranslation(translationKey) {
+        // // const result = await promise;
+        // // return result;
+        // const result = this.translate.instant(translationKey);
+        // if (result === translationKey) {
+        return translationKey;
+        // }
+        // return result;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: DialogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: DialogService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+
+class BaseFormEditComponent {
+    constructor(fb, router, route, modelService, dialogService, translate, location) {
+        this.fb = fb;
+        this.router = router;
+        this.route = route;
+        this.modelService = modelService;
+        this.dialogService = dialogService;
+        this.translate = translate;
+        this.location = location;
+        this.isLoading = true;
+        this.changeUrlRoute = true;
+        this.generateForm(this.modelService.newModel());
+    }
+    afterSave(model) {
+        return new Observable((observer) => {
+            observer.next(model);
+            observer.complete();
+        });
+    }
+    beforeSave(model) {
+        return new Observable((observer) => {
+            observer.next(model);
+            observer.complete();
+        });
+    }
+    ngOnInit() {
+        this.initForm();
+    }
+    initForm(customInclude = '', newModelId = null, model = null) {
+        if (model === null) {
+            this.modelId = this.route.snapshot.paramMap.get('id') ?? newModelId;
+            this.isEdit = false;
+            if (this.modelId) {
+                this.modelService.get(this.modelId, customInclude).subscribe((value) => {
+                    this.isEdit = true;
+                    this.generateForm(value);
+                });
+            }
+            else {
+                if (this.changeUrlRoute) {
+                    const addUrl = this.router.createUrlTree([]).toString();
+                    this.editRoute = this.router.createUrlTree([addUrl.replace('add', 'edit')]).toString();
+                }
+                // }
+                this.generateForm(this.modelService.newModel());
+            }
+        }
+        else {
+            this.modelId = model.id;
+            this.isEdit = true;
+            this.generateForm(model);
+        }
+    }
+    generateForm(model) {
+        this.isLoading = false;
+        this.modelId = model.id;
+        this.model = model;
+        this.baseForm = this.modelService.toFormGroup(this.fb, model);
+        this.afterFormGenerated();
+    }
+    afterFormGenerated() {
+    }
+    getFromGroup(formGroup = null) {
+        if (!formGroup)
+            return this.baseForm;
+        if (formGroup instanceof UntypedFormGroup)
+            return formGroup;
+        return this.baseForm.controls[formGroup];
+    }
+    validateAllFormFields(formGroup = null) {
+        const fg = this.getFromGroup(formGroup);
+        Object.keys(fg.controls).forEach(field => {
+            // console.log(field);
+            const control = fg.get(field);
+            if (control instanceof UntypedFormControl) {
+                control.markAsTouched({ onlySelf: true });
+            }
+            else if (control instanceof UntypedFormGroup) {
+                this.validateAllFormFields(control);
+            }
+        });
+    }
+    isFieldValid(field, formGroup = null) {
+        const fg = this.getFromGroup(formGroup);
+        const filedControl = fg.get(field);
+        return !filedControl.valid && filedControl.touched;
+    }
+    isFieldValidFromArray(arrayIndex, field, arrayName = 'formArray') {
+        const fieldControl = this.baseForm.get(arrayName).get([arrayIndex]).get(field);
+        return !fieldControl.valid && fieldControl.touched;
+    }
+    displayFieldCss(field) {
+        return {
+            'has-error': this.isFieldValid(field),
+            'has-feedback': this.isFieldValid(field)
+        };
+    }
+    onCancel() {
+        this.router.navigate([this.cancelRoute]);
+    }
+    onSave() {
+        this.saveModel(this.baseForm);
+    }
+    saveModel(formGroup = null) {
+        const fg = this.getFromGroup(formGroup);
+        const that = this;
+        if (fg) {
+            if (fg.valid) {
+                this.beforeSave(this.model).subscribe(_ => {
+                    this.modelService.save(this.baseForm, this.modelId, this.model).subscribe((newModel) => {
+                        this.model = newModel;
+                        this.modelId = newModel.id;
+                        if (this.editRoute) {
+                            this.isEdit = true;
+                            if (this.changeUrlRoute) {
+                                const url = this.router.createUrlTree([this.editRoute, this.modelId]).toString();
+                                this.location.replaceState(url);
+                            }
+                        }
+                        this.afterSave(newModel).subscribe((val) => {
+                            this.dialogService.showSaveMessage('Your changes were saved successfully.').subscribe(d => {
+                                fg.markAsPristine();
+                            });
+                        });
+                    }, err => {
+                        this.serverErrors(err);
+                    });
+                });
+            }
+            else {
+                this.validateAllFormFields(formGroup);
+            }
+        }
+    }
+    serverErrors(err) {
+        if (err.error) {
+            if (err.error.errors) {
+                const validationErrors = err.error.errors;
+                if (Array.isArray(validationErrors)) {
+                    validationErrors.forEach(prop => {
+                        const formControl = this.baseForm.get(prop);
+                        if (formControl) {
+                            // activate the error message
+                            formControl.setErrors({
+                                serverError: validationErrors[prop].join('\n')
+                            });
+                        }
+                    });
+                }
+                else {
+                    const keys = Object.keys(validationErrors);
+                    keys.forEach(prop => {
+                        const formControl = this.baseForm.get(prop);
+                        if (formControl) {
+                            // activate the error message
+                            formControl.setErrors({
+                                serverError: validationErrors[prop].join('\n')
+                            });
+                        }
+                    });
+                }
+            }
+        }
+    }
+    canDeactivate() {
+        // Allow synchronous navigation (`true`) if no crisis or the crisis is unchanged
+        if (!this.baseForm.dirty) {
+            return true;
+        }
+        // Otherwise ask the user with the dialog service and return its
+        // observable which resolves to true or false when the user decides
+        return this.dialogService.confirm('Discard changes ?', null, 'Discard');
+    }
+    getFiledName(filedTranslationKey) {
+        return { field: this.translate.instant(filedTranslationKey) };
+    }
+    getCustomErrorMessage(error, fieldLabel) {
+        return '';
+    }
+    getErrorMessageFromArray(arrayIndex, field, filedTranslationKey, arrayName = 'formArray') {
+        const fieldControl = this.baseForm.get(arrayName).get([arrayIndex]).get(field);
+        return this.getErrorMessageForField(fieldControl, filedTranslationKey);
+    }
+    getErrorMessage(field, filedTranslationKey, formGroup = null) {
+        const fg = this.getFromGroup(formGroup);
+        return this.getErrorMessageForField(fg.get(field), filedTranslationKey);
+    }
+    getErrorMessageForField(fieldControl, filedTranslationKey) {
+        const error = fieldControl.errors;
+        const fieldLabel = this.translate.instant(filedTranslationKey);
+        let rvalue = '';
+        if (error !== null) {
+            if (error['required'] === true) {
+                rvalue = this.translate.instant('General.Field.Required', { field: fieldLabel });
+            }
+            if (error['minlength']) {
+                rvalue = this.translate.instant('General.Field.MinLength', { field: fieldLabel, requiredLength: error.minlength.requiredLength });
+            }
+            if (error['email'] === true) {
+                rvalue = this.translate.instant('General.Field.InvalidEmail');
+            }
+            if (error['url'] === true) {
+                rvalue = this.translate.instant('General.Field.InvalidUrl');
+            }
+            if (error['serverError']) {
+                rvalue = error['serverError'];
+            }
+            if (rvalue === '') {
+                rvalue = this.getCustomErrorMessage(error, fieldLabel);
+            }
+        }
+        return rvalue;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: BaseFormEditComponent, deps: [{ token: i1$1.UntypedFormBuilder }, { token: i2.Router }, { token: i2.ActivatedRoute }, { token: BaseService }, { token: DialogService }, { token: i1$2.TranslateService }, { token: i6.Location }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.1", type: BaseFormEditComponent, selector: "app-base.form.edit", ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: BaseFormEditComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-base.form.edit',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i1$1.UntypedFormBuilder }, { type: i2.Router }, { type: i2.ActivatedRoute }, { type: BaseService }, { type: DialogService }, { type: i1$2.TranslateService }, { type: i6.Location }]; } });
+
+var GridLayoutFormat;
+(function (GridLayoutFormat) {
+    GridLayoutFormat[GridLayoutFormat["none"] = 0] = "none";
+    GridLayoutFormat[GridLayoutFormat["date"] = 1] = "date";
+    GridLayoutFormat[GridLayoutFormat["number"] = 2] = "number";
+    GridLayoutFormat[GridLayoutFormat["percent"] = 3] = "percent";
+    GridLayoutFormat[GridLayoutFormat["picture"] = 4] = "picture";
+})(GridLayoutFormat || (GridLayoutFormat = {}));
+var CellTextAlign;
+(function (CellTextAlign) {
+    CellTextAlign["left"] = "left";
+    CellTextAlign["center"] = "center";
+    CellTextAlign["right"] = "right";
+})(CellTextAlign || (CellTextAlign = {}));
+
+// tslint:disable-next-line:variable-name
+const AttributeMetadata = Symbol('AttributeMetadata');
+
+class DateConverter {
+    mask(value) {
+        if (value instanceof Date && !isNaN(value.getTime())) {
+            return value;
+        }
+        const d = parseISO(value);
+        if (d instanceof Date && !isNaN(d.getTime())) {
+            return d;
+        }
+        else {
+            return value;
+        }
+    }
+    unmask(value) {
+        // const result = format(value, 'YYYY-MM-DDTHH:mm:ssZ');
+        return value;
+    }
+}
+
+function Attribute(options = {}) {
+    return (target, propertyName) => {
+        const converter = (dataType, value, forSerialisation = false) => {
+            let attrConverter;
+            if (dataType) {
+                if (options.converter) {
+                    attrConverter = options.converter;
+                }
+                else if (dataType === Date) {
+                    attrConverter = new DateConverter();
+                }
+                else {
+                    const datatype = new dataType();
+                    if (datatype.mask && datatype.unmask) {
+                        attrConverter = datatype;
+                    }
+                }
+                if (attrConverter) {
+                    if (!forSerialisation) {
+                        return attrConverter.mask(value);
+                    }
+                    return attrConverter.unmask(value);
+                }
+            }
+            return value;
+        };
+        const saveAnnotations = () => {
+            const metadata = Reflect.getMetadata('Attribute', target) || {};
+            metadata[propertyName] = {
+                marked: true
+            };
+            Reflect.defineMetadata('Attribute', metadata, target);
+            const mappingMetadata = Reflect.getMetadata('AttributeMapping', target) || {};
+            const serializedPropertyName = options.serializedName !== undefined ? options.serializedName : propertyName;
+            mappingMetadata[serializedPropertyName] = propertyName;
+            Reflect.defineMetadata('AttributeMapping', mappingMetadata, target);
+            const requiredMetadata = Reflect.getMetadata('AttributeRequired', target) || {};
+            requiredMetadata[serializedPropertyName] = options.required !== undefined ? options.required : false;
+            Reflect.defineMetadata('AttributeRequired', requiredMetadata, target);
+            const defaultMetadata = Reflect.getMetadata('AttributedefaultValue', target) || {};
+            defaultMetadata[serializedPropertyName] = options.defaultValue !== undefined ? options.defaultValue : null;
+            Reflect.defineMetadata('AttributedefaultValue', defaultMetadata, target);
+            const formSubGroupMetadata = Reflect.getMetadata('AttributeformSubGroup', target) || {};
+            formSubGroupMetadata[serializedPropertyName] = options.formSubGroup !== undefined ? options.formSubGroup : null;
+            Reflect.defineMetadata('AttributeformSubGroup', formSubGroupMetadata, target);
+        };
+        const setMetadata = (hasDirtyAttributes, instance, oldValue, newValue, isNew) => {
+            const targetType = Reflect.getMetadata('design:type', target, propertyName);
+            if (!instance[AttributeMetadata]) {
+                instance[AttributeMetadata] = {};
+            }
+            const propertyHasDirtyAttributes = typeof oldValue === 'undefined' && !isNew ? false : hasDirtyAttributes;
+            instance[AttributeMetadata][propertyName] = {
+                newValue,
+                oldValue,
+                serializedName: options.serializedName,
+                hasDirtyAttributes: propertyHasDirtyAttributes,
+                serialisationValue: converter(targetType, newValue, true)
+            };
+        };
+        const getter = function () {
+            return this['_' + propertyName];
+        };
+        const setter = function (newVal) {
+            const targetType = Reflect.getMetadata('design:type', target, propertyName);
+            const convertedValue = converter(targetType, newVal);
+            if (convertedValue !== this['_' + propertyName]) {
+                setMetadata(true, this, this['_' + propertyName], newVal, !this.id);
+                this['_' + propertyName] = convertedValue;
+            }
+        };
+        if (delete target[propertyName]) {
+            saveAnnotations();
+            Object.defineProperty(target, propertyName, {
+                get: getter,
+                set: setter,
+                enumerable: true,
+                configurable: true
+            });
+        }
+    };
+}
+
+function BaseDatastoreConfig(config = {}) {
+    // tslint:disable-next-line:only-arrow-functions
+    return (target) => {
+        Reflect.defineMetadata('BaseDatastoreConfig', config, target);
+    };
+}
+
+class BaseMetaModel {
+    constructor(response) {
+        this.links = response.links || [];
+        this.meta = response.meta;
+    }
+}
+
+function BaseModelConfig(config = {}) {
+    return (target) => {
+        if (typeof config['meta'] === 'undefined' || config['meta'] == null) {
+            config['meta'] = BaseMetaModel;
+        }
+        Reflect.defineMetadata('BaseModelConfig', config, target);
+    };
+}
+
+function CustomType(config = {}) {
+    return (target, propertyName) => {
+        const annotations = Reflect.getMetadata('CustomType', target) || [];
+        annotations.push({
+            propertyName,
+            relationship: config.key || propertyName
+        });
+        Reflect.defineMetadata('CustomType', annotations, target);
+    };
+}
+
+class TranslatedElementDirective {
+    constructor(viewRef, templateRef) {
+        this.viewRef = viewRef;
+        this.templateRef = templateRef;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: TranslatedElementDirective, deps: [{ token: i0.ViewContainerRef }, { token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.1", type: TranslatedElementDirective, selector: "[translatedElement]", inputs: { elementKey: ["translatedElement", "elementKey"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: TranslatedElementDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[translatedElement]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.TemplateRef }]; }, propDecorators: { elementKey: [{
+                type: Input,
+                args: ['translatedElement']
+            }] } });
+
+const TOKEN_START_DEMARC = '{{';
+const TOKEN_END_DEMARC = '}}';
+// adapted from @kasperlauge's solution in https://github.com/ngx-translate/core/issues/223
+class TranslatedContentDirective {
+    constructor(viewRef, renderer, translateService, changeDetectorRef) {
+        this.viewRef = viewRef;
+        this.renderer = renderer;
+        this.translateService = translateService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.subs = [];
+    }
+    ngOnInit() {
+        this.rawTranslation = merge(this.translateService.get(this.translationKey), this.translateService.onLangChange.asObservable().pipe(switchMap(() => this.translateService.get(this.translationKey))));
+    }
+    ngAfterContentInit() {
+        // QueryList.changes doesn't re-emit after its initial value, which we have by now
+        // BehaviorSubjects re-emit their initial value on subscription, so we get what we need by merging
+        // the BehaviorSubject and the QueryList.changes observable
+        const elementsSubject = new BehaviorSubject(this.elements.toArray());
+        const elementsChanges = merge(elementsSubject, this.elements.changes);
+        this.translationData = combineLatest(this.rawTranslation, elementsChanges)
+            .pipe(map(([rawTranslation]) => {
+            return {
+                elements: this.elements.toArray(),
+                rawTranslation,
+            };
+        }));
+        this.subs.push(this.translationData.subscribe(this.render.bind(this)));
+    }
+    render(translationData) {
+        if (!translationData.rawTranslation || translationData.rawTranslation === this.translationKey) {
+            throw new Error(`No resource matching the key '${this.translationKey}'`);
+        }
+        while (this.viewRef.element.nativeElement.firstChild) {
+            this.renderer.removeChild(this.viewRef.element.nativeElement, this.viewRef.element.nativeElement.firstChild);
+        }
+        let lastTokenEnd = 0;
+        while (lastTokenEnd < translationData.rawTranslation.length) {
+            const tokenStartDemarc = translationData.rawTranslation.indexOf(TOKEN_START_DEMARC, lastTokenEnd);
+            if (tokenStartDemarc < 0) {
+                break;
+            }
+            const tokenStart = tokenStartDemarc + TOKEN_START_DEMARC.length;
+            const tokenEnd = translationData.rawTranslation.indexOf(TOKEN_END_DEMARC, tokenStart);
+            if (tokenEnd < 0) {
+                throw new Error(`Encountered unterminated token in translation string '${this.translationKey}'`);
+            }
+            const tokenEndDemarc = tokenEnd + TOKEN_END_DEMARC.length;
+            const precedingText = translationData.rawTranslation.substring(lastTokenEnd, tokenStartDemarc);
+            const precedingTextElement = this.renderer.createText(precedingText);
+            this.renderer.appendChild(this.viewRef.element.nativeElement, precedingTextElement);
+            const elementKey = translationData.rawTranslation.substring(tokenStart, tokenEnd);
+            const embeddedElementTemplate = translationData.elements.find(element => element.elementKey === elementKey);
+            if (embeddedElementTemplate) {
+                const embeddedElementView = embeddedElementTemplate.viewRef.createEmbeddedView(embeddedElementTemplate.templateRef);
+                this.renderer.appendChild(this.viewRef.element.nativeElement, embeddedElementView.rootNodes[0]);
+            }
+            else {
+                const missingTokenText = translationData.rawTranslation.substring(tokenStartDemarc, tokenEndDemarc);
+                const missingTokenElement = this.renderer.createText(missingTokenText);
+                this.renderer.appendChild(this.viewRef.element.nativeElement, missingTokenElement);
+            }
+            lastTokenEnd = tokenEndDemarc;
+        }
+        const trailingText = translationData.rawTranslation.substring(lastTokenEnd);
+        const trailingTextElement = this.renderer.createText(trailingText);
+        this.renderer.appendChild(this.viewRef.element.nativeElement, trailingTextElement);
+        // in case the rendering happens outside of a change detection event, this ensures that any translations in the
+        // embedded elements are rendered
+        this.changeDetectorRef.detectChanges();
+    }
+    ngOnDestroy() {
+        this.subs.forEach(sub => sub.unsubscribe());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: TranslatedContentDirective, deps: [{ token: i0.ViewContainerRef }, { token: i0.Renderer2 }, { token: i1$2.TranslateService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.1", type: TranslatedContentDirective, selector: "[appTranslatedContent]", inputs: { translationKey: ["appTranslatedContent", "translationKey"] }, queries: [{ propertyName: "elements", predicate: TranslatedElementDirective }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: TranslatedContentDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[appTranslatedContent]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.Renderer2 }, { type: i1$2.TranslateService }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { translationKey: [{
+                type: Input,
+                args: ['appTranslatedContent']
+            }], elements: [{
+                type: ContentChildren,
+                args: [TranslatedElementDirective]
+            }] } });
+
+class CacheInterceptor {
+    constructor(expirationTime, cacheService) {
+        this.expirationTime = expirationTime;
+        this.cacheService = cacheService;
+        this.cache = new Map();
+    }
+    intercept(request, next) {
+        const bypassCache = request.params.get('bypassCache') || false;
+        if (bypassCache || request.method !== 'GET') {
+            return next.handle(request);
+        }
+        if (!bypassCache) {
+            const cachedResponse = this.cacheService.get(request.urlWithParams);
+            if (cachedResponse) {
+                return of(cachedResponse.clone());
+                //return cachedResponse;
+            }
+        }
+        return next.handle(request).pipe(tap((event) => {
+            if (event instanceof HttpResponse) {
+                this.cacheService.set(request.urlWithParams, event.clone(), this.expirationTime);
+            }
+        }));
+        // const cachedItem = this.cache.get(request.url);
+        // if (cachedItem && cachedItem.expiration > Date.now()) {
+        //   return of(cachedItem.response.clone());
+        // }
+        // return next.handle(request).pipe(
+        //   tap(event => {
+        //     if (event instanceof HttpResponse) {
+        //       this.cache.set(request.url, { response: event.clone(), expiration: Date.now() + this.expirationTime });
+        //     }
+        //   })
+        // );
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: CacheInterceptor, deps: [{ token: 'CACHE_EXPIRATION_TIME' }, { token: CacheService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: CacheInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: CacheInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['CACHE_EXPIRATION_TIME']
+                }] }, { type: CacheService }]; } });
+
+class BaseModel {
+    // tslint:disable-next-line:variable-name
+    constructor(_datastore, data) {
+        this._datastore = _datastore;
+        if (data) {
+            if (data.id) {
+                this.id = data.id;
+            }
+            Object.assign(this, data);
+        }
+    }
+    save(params, headers, customUrl, customBody) {
+        const attributesMetadata = this[AttributeMetadata];
+        return this._datastore.saveRecord(attributesMetadata, this, params, headers, customUrl, customBody);
+    }
+    patch(origModel, params, headers, customUrl) {
+        const attributesMetadata = this[AttributeMetadata];
+        return this._datastore.patchRecord(attributesMetadata, this, origModel, params, headers, customUrl);
+    }
+    replace(params, headers, customUrl, customBody) {
+        const attributesMetadata = this[AttributeMetadata];
+        return this._datastore.replaceRecord(attributesMetadata, this, params, headers, customUrl, customBody);
+    }
+    get attributeMetadata() {
+        const attributesMetadata = this[AttributeMetadata];
+        return attributesMetadata;
+    }
+    set attributeMetadata(val) {
+        this[AttributeMetadata] = val;
+    }
+    get hasDirtyAttributes() {
+        const attributesMetadata = this[AttributeMetadata];
+        let hasDirtyAttributes = false;
+        for (const propertyName in attributesMetadata) {
+            if (attributesMetadata.hasOwnProperty(propertyName)) {
+                const metadata = attributesMetadata[propertyName];
+                if (metadata.hasDirtyAttributes) {
+                    hasDirtyAttributes = true;
+                    break;
+                }
+            }
+        }
+        return hasDirtyAttributes;
+    }
+    rollbackAttributes() {
+        const attributesMetadata = this[AttributeMetadata];
+        let metadata;
+        for (const propertyName in attributesMetadata) {
+            if (attributesMetadata.hasOwnProperty(propertyName)) {
+                if (attributesMetadata[propertyName].hasDirtyAttributes) {
+                    this[propertyName] = attributesMetadata[propertyName].oldValue;
+                    metadata = {
+                        hasDirtyAttributes: false,
+                        newValue: attributesMetadata[propertyName].oldValue,
+                        oldValue: undefined
+                    };
+                    attributesMetadata[propertyName] = metadata;
+                }
+            }
+        }
+        this[AttributeMetadata] = attributesMetadata;
+    }
+    get modelConfig() {
+        return Reflect.getMetadata('BaseModelConfig', this.constructor);
+    }
+    deserializeModel(modelType, data) {
+        data = this.transformSerializedNamesToPropertyNames(modelType, data);
+        return new modelType(this._datastore, data);
+    }
+    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);
+    }
+    getModelRequiredPropertyNames(model) {
+        return Reflect.getMetadata('AttributeRequired', model);
+    }
+    getModelDefaultPropertyValues(model) {
+        return Reflect.getMetadata('AttributedefaultValue', model);
+    }
+    getModelSubGroupPropertyNames(model) {
+        return Reflect.getMetadata('AttributeformSubGroup', model);
+    }
+    getFromGroup(fb) {
+        const props = Object.keys(this.getModelPropertyNames(this));
+        const requiredProps = this.getModelRequiredPropertyNames(this);
+        const defaultValues = this.getModelDefaultPropertyValues(this);
+        const formSubGroupsValues = this.getModelSubGroupPropertyNames(this);
+        const controlsConfig = {};
+        const that = this;
+        if (props) {
+            props.forEach(property => {
+                const value = that[property] !== undefined ? that[property] : defaultValues[property];
+                const formSubGroup = formSubGroupsValues[property] ?? null;
+                if (requiredProps[property]) {
+                    if (formSubGroup)
+                        this.getSubFromGroup(fb, controlsConfig, formSubGroup).addControl(property, fb.control(value, Validators.required));
+                    else
+                        controlsConfig[property] = [value, Validators.required];
+                }
+                else {
+                    if (formSubGroup)
+                        this.getSubFromGroup(fb, controlsConfig, formSubGroup).addControl(property, fb.control(value));
+                    else
+                        controlsConfig[property] = value;
+                }
+            });
+        }
+        return fb.group(controlsConfig);
+    }
+    getSubFromGroup(fb, controlsConfig, subGroup) {
+        if (!controlsConfig[subGroup])
+            controlsConfig[subGroup] = fb.group({});
+        return controlsConfig[subGroup];
+    }
+    getModelFromFormGroup(formGroup, id) {
+        const props = Object.keys(this.getModelPropertyNames(this));
+        const formSubGroupsValues = this.getModelSubGroupPropertyNames(this);
+        const data = {};
+        if (id) {
+            data.id = id;
+        }
+        const that = this;
+        if (props) {
+            props.forEach(property => {
+                const formSubGroup = formSubGroupsValues[property] ?? null;
+                if (!formSubGroup)
+                    data[property] = formGroup.controls[property].value ?? null;
+                else
+                    data[property] = formGroup.controls[formSubGroup].controls[property].value ?? null;
+            });
+        }
+        if (data) {
+            if (id) {
+                this.id = id;
+            }
+            Object.assign(this, data);
+        }
+    }
+    getSerializedModel() {
+        const attributesMetadata = this[AttributeMetadata];
+        return this._datastore.modelToEntity(this, attributesMetadata, true);
+    }
+    getCellClass(property) {
+        return '';
+    }
+}
+
+class ErrorResponse {
+    constructor(errors) {
+        this.errors = [];
+        if (errors) {
+            this.errors = errors;
+        }
+    }
+}
+
+class Rule {
+    constructor() {
+        this.parameters = [];
+    }
+}
+
+class Nl2brPipe {
+    transform(value, args) {
+        // return value.replace(/\n/g, '<br />');
+        if (value) {
+            value = value.replace(/(?:\r\n\r\n|\r\r|\n\n)/g, '</p><p>');
+            return '<p>' + value.replace(/(?:\r\n|\r|\n)/g, '<br>') + '</p>';
+        }
+        return value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: Nl2brPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.1", ngImport: i0, type: Nl2brPipe, name: "nl2br" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: Nl2brPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'nl2br'
+                }]
+        }] });
+
+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;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: InputErrorPipe, deps: [{ token: i1$2.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.1", ngImport: i0, type: InputErrorPipe, name: "inputError" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: InputErrorPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'inputError'
+                }]
+        }], ctorParameters: function () { return [{ type: i1$2.TranslateService }]; } });
+
+class Configurations {
+    constructor() {
+        this.baseUrl = '';
+        this.authUrl = '';
+        this.apiVersion = 'api/v1';
+    }
+}
+
+class DatastoreCore extends BaseDatastore {
+    constructor(http, cacheService, configExt) {
+        super(http, cacheService);
+        this.configExt = configExt;
+        this.customConfig = {
+            apiVersion: configExt.apiVersion,
+            baseUrl: configExt.baseUrl
+        };
+        this.config = this.customConfig;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: DatastoreCore, deps: [{ token: i1.HttpClient }, { token: CacheService }, { token: Configurations }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: DatastoreCore }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: DatastoreCore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: CacheService }, { type: Configurations }]; } });
+
+const PROVIDERS = [
+    BaseDatastore,
+    DatastoreCore,
+    DatePipe,
+    DecimalPipe,
+    PercentPipe,
+];
+
+function DynamicallyModelResolver(modelsImport, className = undefined) {
+    return (route, state) => {
+        if (className == undefined)
+            className = route.paramMap.get('className');
+        const instance = getInstance$1(className, modelsImport);
+        if (!instance) {
+            throw new Error(`Invalid className: ${className}`);
+        }
+        return instance;
+    };
+}
+function getInstance$1(className, modelsImport) {
+    return modelsImport.then((module) => module[toProperCase$1(className)]);
+    // return modelsImport.then((module) => ({ modelInstance: module[toProperCase(className)] })
+    // );
+}
+function toProperCase$1(str) {
+    return str.replace(/\w\S*/g, (txt) => {
+        return txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase();
+    });
+}
+
+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();
+    });
+}
+
+class TranslateloaderService {
+    constructor(httpClient, config) {
+        this.httpClient = httpClient;
+        this._apiUrl = 'No Value';
+        this.headers = new HttpHeaders({
+            Accept: 'application/json',
+            'Content-Type': 'application/json'
+        });
+        if (config) {
+            this._apiUrl = config.baseUrl;
+        }
+    }
+    getTranslation(lang) {
+        const url = this._apiUrl + '/api/v1/language/' + lang + '/translationlist';
+        return this.httpClient.get(url, { headers: this.headers });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: TranslateloaderService, deps: [{ token: i1.HttpClient }, { token: Configurations, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: TranslateloaderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: TranslateloaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: Configurations, decorators: [{
+                    type: Optional
+                }] }]; } });
+
+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$2.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,
+                    ]
+                }]
+        }] });
+
+class CustomValidators {
+    static patternValidator(regex, error) {
+        return (control) => {
+            if (!control.value) {
+                // if control is empty return no error
+                return null;
+            }
+            // test the value of the control against the regexp supplied
+            const valid = regex.test(control.value);
+            // if true, return no error (no error), else return error passed in the second parameter
+            return valid ? null : error;
+        };
+    }
+}
+
+function readFileAsync(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = (event) => {
+            resolve(event.target.result);
+        };
+        reader.onerror = (event) => {
+            reject(event.target.error);
+        };
+        reader.readAsArrayBuffer(file);
+    });
+}
+function getValueFromJsonData(jsonData, key) {
+    // Convert the key and all JSON keys to lowercase
+    const lowercaseKey = key.toLowerCase();
+    const lowercaseKeys = Object.keys(jsonData).map(k => k.toLowerCase());
+    // Find the lowercase key in the lowercase keys array
+    const index = lowercaseKeys.indexOf(lowercaseKey);
+    // If found, use the original (proper case) key to access the value
+    if (index !== -1) {
+        const originalKey = Object.keys(jsonData)[index];
+        return jsonData[originalKey];
+    }
+    // Key not found
+    return undefined;
+}
+
+/*
+ * Public API Surface of core
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { Attribute, BaseDatastore, BaseDatastoreConfig, BaseFormEditComponent, BaseMetaModel, BaseModel, BaseModelConfig, BaseQueryData, BaseService, CacheInterceptor, CacheService, CellTextAlign, CustomType, CustomValidators, DatastoreCore, DialogService, DynamicallyModelResolver, DynamicallyServiceResolver, ErrorResponse, FieldErrorDisplayComponent, GridLayoutFormat, InputErrorPipe, Nl2brPipe, PROVIDERS, PageNotFoundComponent, RslBaseModule, Rule, TranslatedContentDirective, TranslatedElementDirective, UnderConstructionComponent, getValueFromJsonData, readFileAsync };
+//# sourceMappingURL=rosoftlab-core.mjs.map