@rosoftlab/core 1.0.5-alpha-4 → 1.0.5-alpha-6

package/fesm2022/rosoftlab-core.mjs

@@ -1,8 +1,11 @@
+import * as i1$1 from '@angular/common/http';
+import { HttpResponse, HttpHeaders, HttpParams, HttpClient, HttpClientModule } from '@angular/common/http';
 import * as i0 from '@angular/core';
-import { Injectable, InjectionToken, inject, Input, Component, HostBinding, Directive, Inject, Pipe, NgModule } from '@angular/core';
+import { InjectionToken, Optional, Inject, Injectable, inject, Input, Component, HostBinding, Directive, Pipe, NgModule } from '@angular/core';
 import * as i1 from 'oidc-client-ts';
-import { UserManager } from 'oidc-client-ts';
-import { BehaviorSubject, Observable, throwError, of, ReplaySubject } from 'rxjs';
+import { User as User$1, UserManager } from 'oidc-client-ts';
+import { BehaviorSubject, firstValueFrom, Observable, of, throwError, ReplaySubject } from 'rxjs';
+import { map, tap, catchError, filter } from 'rxjs/operators';
 import * as i5 from '@angular/common';
 import { Location, DatePipe, DecimalPipe, PercentPipe, CommonModule } from '@angular/common';
 import * as i1$2 from '@angular/forms';
@@ -11,17 +14,21 @@ import * as i2 from '@angular/router';
 import { Router, ActivatedRoute, UrlSegment, NavigationEnd } from '@angular/router';
 import * as i1$3 from '@ngx-translate/core';
 import { TranslateService, TranslateModule, TranslateLoader } from '@ngx-translate/core';
-import * as i1$1 from '@angular/common/http';
-import { HttpHeaders, HttpParams, HttpResponse, HttpClient, HttpClientModule } from '@angular/common/http';
+import { parseISO } from 'date-fns';
 import { compare } from 'fast-json-patch';
 import queryString from 'query-string';
-import { map, catchError, tap, filter } from 'rxjs/operators';
-import { parseISO } from 'date-fns';
 import { __decorate, __metadata } from 'tslib';
 
+class Tokens {
+}
+const OIDC_CLIENT_SETTINGS = new InjectionToken('OIDC_CLIENT_SETTINGS');
+const OIDC_GUEST_CLIENT_SETTINGS = new InjectionToken('OIDC_GUEST_CLIENT_SETTINGS');
+
 class AuthService {
-    constructor(manager) {
+    constructor(manager, http, guestSettings) {
         this.manager = manager;
+        this.http = http;
+        this.guestSettings = guestSettings;
         // Observable navItem source
         this._authNavStatusSource = new BehaviorSubject(false);
         // Observable navItem stream
@@ -93,17 +100,58 @@ class AuthService {
     async signout() {
         await this.manager.signoutRedirect();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: AuthService, deps: [{ token: i1.UserManager }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    async loginWithGuest() {
+        const token = localStorage.getItem('guest_token');
+        if (!token) {
+            throw new Error('No guest token found in local storage');
+        }
+        const authUrlToUse = this.guestSettings?.authority || this.manager.settings.authority;
+        const body = new URLSearchParams();
+        body.set('grant_type', 'guest');
+        body.set('guest_token', token);
+        body.set('client_id', this.guestSettings?.client_id || this.manager.settings.client_id);
+        body.set('scope', this.guestSettings?.scope || 'openid profile offline_access');
+        await firstValueFrom(this.http.post(`${authUrlToUse}/connect/token`, body.toString(), {
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+        }).pipe(map((response) => {
+            if (!response.access_token) {
+                throw new Error('Login failed');
+            }
+            const expires_at = response.expires_in ? Math.floor(Date.now() / 1000) + response.expires_in : 0;
+            const user = new User$1({
+                id_token: response.id_token || '',
+                session_state: null,
+                access_token: response.access_token,
+                refresh_token: response.refresh_token || '',
+                token_type: response.token_type || 'Bearer',
+                scope: response.scope || '',
+                profile: {
+                    sub: 'guest', // Dummy sub for guest
+                    iss: authUrlToUse,
+                    aud: this.manager.settings.client_id,
+                    exp: expires_at,
+                    iat: Math.floor(Date.now() / 1000)
+                }, // Cast to any to avoid strict typing
+                expires_at: expires_at,
+                userState: null
+            });
+            this.manager.storeUser(user);
+            this.user = user;
+            this._authNavStatusSource.next(this.isAuthenticated());
+        })));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: AuthService, deps: [{ token: i1.UserManager }, { token: i1$1.HttpClient }, { token: OIDC_GUEST_CLIENT_SETTINGS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: AuthService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: AuthService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: i1.UserManager }] });
-
-class Tokens {
-}
-const OIDC_CLIENT_SETTINGS = new InjectionToken('OIDC_CLIENT_SETTINGS');
+        }], ctorParameters: () => [{ type: i1.UserManager }, { type: i1$1.HttpClient }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [OIDC_GUEST_CLIENT_SETTINGS]
+                }] }] });
 
 // library/src/lib/auth/user-manager.factory.ts
 function provideOidcUserManager() {
@@ -113,10 +161,11 @@ function provideOidcUserManager() {
     };
 }
 
-function provideAuth(settings) {
+function provideAuth(settings, guest_settings) {
     return [
         { provide: OIDC_CLIENT_SETTINGS, useValue: settings },
-        provideOidcUserManager(),
+        { provide: OIDC_GUEST_CLIENT_SETTINGS, useValue: guest_settings },
+        provideOidcUserManager()
     ];
 }
 
@@ -161,9 +210,10 @@ const DIALOG_SERVICE_TOKEN = new InjectionToken('DIALOG_SERVICE_TOKEN');
 
 const MODEL_SERVICE = new InjectionToken('MODEL_SERVICE');
 const MODEL_TOKEN = new InjectionToken('MODEL_TOKEN');
-// This token will store a map of string keys to Component Classes
-const TABLE_IMPLEMENTATIONS_TOKEN = new InjectionToken('TABLE_IMPLEMENTATIONS_TOKEN');
-const CRUD_IMPLEMENTATIONS_TOKEN = new InjectionToken('CRUD_IMPLEMENTATIONS_TOKEN');
+const RSL_FORM_IMPLEMENTATIONS_TOKEN = new InjectionToken('RSL_FORM_IMPLEMENTATIONS_TOKEN');
+// // This token will store a map of string keys to Component Classes
+// export const TABLE_IMPLEMENTATIONS_TOKEN = new InjectionToken<Record<string, Type<any>>>('TABLE_IMPLEMENTATIONS_TOKEN');
+// export const CRUD_IMPLEMENTATIONS_TOKEN = new InjectionToken<Record<string, Type<any>>>('CRUD_IMPLEMENTATIONS_TOKEN');
 
 class BaseCrudImplementation {
     constructor() {
@@ -268,7 +318,7 @@ class BaseCrudImplementation {
         }
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseCrudImplementation, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.8", type: BaseCrudImplementation, isStandalone: true, inputs: { model: "model", modelName: "modelName", dictPath: "dictPath", fileLayout: "fileLayout", idProperty: "idProperty", customInclude: "customInclude", changeUrlRoute: "changeUrlRoute", hostClass: "hostClass" }, host: { properties: { "class": "this.hostClasses" } }, ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.8", type: BaseCrudImplementation, isStandalone: true, inputs: { model: "model", modelName: "modelName", dictPath: "dictPath", fileLayout: "fileLayout", idProperty: "idProperty", customInclude: "customInclude", changeUrlRoute: "changeUrlRoute", hostClass: "hostClass", modelFnConfig: "modelFnConfig" }, host: { properties: { "class": "this.hostClasses" } }, ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseCrudImplementation, decorators: [{
             type: Directive
@@ -288,1148 +338,1231 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
                 type: Input
             }], hostClass: [{
                 type: Input
+            }], modelFnConfig: [{
+                type: Input
             }], hostClasses: [{
                 type: HostBinding,
                 args: ['class']
             }] } });
 
-class BaseQueryData {
-    constructor(jsonApiModels, metaData) {
-        this.jsonApiModels = jsonApiModels;
-        this.metaData = metaData;
+const DATASTORE_PORT = new InjectionToken('DATASTORE_PORT');
+
+class BaseService {
+    constructor(datastore) {
+        this.datastore = datastore;
     }
-    getModels() {
-        return this.jsonApiModels;
+    setModelType(modelType) {
+        this.modelType = modelType;
     }
-    getMeta() {
-        return this.metaData;
+    get(id, customInclude = '') {
+        const response = this.datastore.findRecord(this.modelType, id, { customInclude });
+        return response;
     }
-}
-
-class MetadataStorage {
-    static { this.metadataMap = new WeakMap(); }
-    static getMetadata(key, target, propertyKey) {
-        const metadata = this.metadataMap.get(target) || {};
-        return propertyKey ? metadata[`${key}:${propertyKey}`] : metadata[key];
+    getAll(page, pageSize, sort = '', filters = '', customInclude = '') {
+        const response = this.datastore.findAll(this.modelType, {
+            Page: page,
+            PageSize: pageSize,
+            Sorts: sort,
+            Filters: filters,
+            customInclude
+        });
+        return response;
     }
-    static setMetadata(key, value, target, propertyKey) {
-        let metadata = this.metadataMap.get(target);
-        if (!metadata) {
-            metadata = {};
-            this.metadataMap.set(target, metadata);
+    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;
+            }
+            return this.datastore.saveRecord(fromModel.attributeMetadata, fromModel);
         }
-        if (propertyKey) {
-            metadata[`${key}:${propertyKey}`] = value;
+        else {
+            return this.patch(docTypeOrFormGroup, origModel, id);
+        }
+    }
+    patch(docTypeOrFormGroup, origModel, id) {
+        let fromModel;
+        if (docTypeOrFormGroup instanceof UntypedFormGroup) {
+            fromModel = this.fromFormGroup(docTypeOrFormGroup, id);
         }
         else {
-            metadata[key] = value;
+            fromModel = docTypeOrFormGroup;
         }
+        return this.datastore.patchRecord(fromModel.attributeMetadata, fromModel, origModel);
     }
-}
-
-class CacheService {
-    constructor() {
-        this.cache = {};
+    newModel(data) {
+        return new this.modelType(data);
     }
-    get(key) {
-        const cachedItem = this.cache[key];
-        if (cachedItem && cachedItem.expiration > Date.now()) {
-            return cachedItem.data;
+    toFormGroup(fb, fromModel) {
+        if (fromModel === undefined) {
+            fromModel = this.newModel();
         }
-        this.delete(key);
-        return null;
+        return fromModel.getFromGroup(fb);
     }
-    set(key, data, expiresInMs) {
-        const expiration = Date.now() + expiresInMs;
-        this.cache[key] = { data, expiration };
+    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;
     }
-    delete(key) {
-        delete this.cache[key];
+    serializeModel(model) {
+        return this.datastore.modelToEntity(model, model.attributeMetadata, true);
     }
-    clearCacheContainingKeyword(keyword) {
-        const keysToDelete = Object.keys(this.cache).filter(key => key.includes(keyword));
-        keysToDelete.forEach(key => this.delete(key));
+    getSelectValues(property) {
+        return null;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: CacheService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: CacheService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseService, deps: [{ token: DATASTORE_PORT }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: CacheService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [] });
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DATASTORE_PORT]
+                }] }] });
 
-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;
-        }
+const DialogSERVICE = new InjectionToken('DialogService');
+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());
     }
-    get getAllAttributes() {
-        if (this.datastoreConfig.overrides
-            && this.datastoreConfig.overrides.getAllAttributes) {
-            return this.datastoreConfig.overrides.getAllAttributes;
-        }
-        else {
-            return BaseDatastore.getAllAttributes;
-        }
+    afterSave(model) {
+        return new Observable((observer) => {
+            observer.next(model);
+            observer.complete();
+        });
     }
-    // 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;
+    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());
             }
         }
-        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;
-            }
+        else {
+            this.modelId = model.id;
+            this.isEdit = true;
+            this.generateForm(model);
         }
-        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;
+    generateForm(model) {
+        this.isLoading = false;
+        this.modelId = model.id;
+        this.model = model;
+        this.baseForm = this.modelService.toFormGroup(this.fb, model);
+        this.afterFormGenerated();
     }
-    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;
+    afterFormGenerated() {
     }
-    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 });
+    getFromGroup(formGroup = null) {
+        if (!formGroup)
+            return this.baseForm;
+        if (formGroup instanceof UntypedFormGroup)
+            return formGroup;
+        return this.baseForm.controls[formGroup];
     }
-    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 });
+    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);
+            }
+        });
     }
-    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 });
+    isFieldValid(field, formGroup = null) {
+        const fg = this.getFromGroup(formGroup);
+        const filedControl = fg.get(field);
+        return !filedControl.valid && filedControl.touched;
     }
-    createRecord(modelType, data) {
-        return new modelType(this, data);
+    isFieldValidFromArray(arrayIndex, field, arrayName = 'formArray') {
+        const fieldControl = this.baseForm.get(arrayName).get([arrayIndex]).get(field);
+        return !fieldControl.valid && fieldControl.touched;
     }
-    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));
+    displayFieldCss(field) {
+        return {
+            'has-error': this.isFieldValid(field),
+            'has-feedback': this.isFieldValid(field)
+        };
     }
-    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();
-            });
-        }
+    onCancel() {
+        this.router.navigate([this.cancelRoute]);
     }
-    // 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));
+    onSave() {
+        this.saveModel(this.baseForm);
     }
-    deleteRecord(modelType, id, headers, customUrl) {
-        const customHeadhers = this.buildHeaders(headers);
-        let url = this.buildUrl(modelType, customUrl);
-        if (!url.includes('share')) {
-            url = url + '/' + id;
+    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);
+            }
         }
-        // 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;
+    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')
+                            });
+                        }
+                    });
+                }
+            }
         }
-        const modelConfig = MetadataStorage.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);
+    canDeactivate() {
+        // Allow synchronous navigation (`true`) if no crisis or the crisis is unchanged
+        if (!this.baseForm.dirty) {
+            return true;
         }
-        result = new BaseQueryData(models, this.parseMeta(body, modelType));
-        return result;
+        // 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');
     }
-    deserializeModel(modelType, data) {
-        data = this.transformSerializedNamesToPropertyNames(modelType, data);
-        return new modelType(this, data);
+    getFiledName(filedTranslationKey) {
+        return { field: this.translate.instant(filedTranslationKey) };
     }
-    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);
+    getCustomErrorMessage(error, fieldLabel) {
+        return '';
     }
-    parseMeta(body, modelType) {
-        const metaModel = MetadataStorage.getMetadata('BaseModelConfig', modelType).meta;
-        return new metaModel(body);
+    getErrorMessageFromArray(arrayIndex, field, filedTranslationKey, arrayName = 'formArray') {
+        const fieldControl = this.baseForm.get(arrayName).get([arrayIndex]).get(field);
+        return this.getErrorMessageForField(fieldControl, filedTranslationKey);
     }
-    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 = MetadataStorage.getMetadata('BaseDatastoreConfig', this.constructor);
-        return Object.assign(configFromDecorator, this.config);
+    getErrorMessage(field, filedTranslationKey, formGroup = null) {
+        const fg = this.getFromGroup(formGroup);
+        return this.getErrorMessageForField(fg.get(field), filedTranslationKey);
     }
-    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];
+    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 properties;
-    }
-    getModelPropertyNames(model) {
-        return MetadataStorage.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 = MetadataStorage.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 queryString.stringify(params, { arrayFormat: 'bracket' });
+        return rvalue;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseDatastore, deps: [{ token: i1$1.HttpClient }, { token: CacheService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseDatastore }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseFormEditComponent, deps: [{ token: i1$2.UntypedFormBuilder }, { token: i2.Router }, { token: i2.ActivatedRoute }, { token: BaseService }, { token: DialogSERVICE }, { token: i1$3.TranslateService }, { token: i5.Location }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.8", type: BaseFormEditComponent, isStandalone: false, selector: "app-base.form.edit", ngImport: i0, template: '', isInline: true }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseDatastore, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1$1.HttpClient }, { type: CacheService }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseFormEditComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-base.form.edit',
+                    template: '',
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i1$2.UntypedFormBuilder }, { type: i2.Router }, { type: i2.ActivatedRoute }, { type: BaseService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DialogSERVICE]
+                }] }, { type: i1$3.TranslateService }, { type: i5.Location }] });
 
-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;
+class BaseTableImplementation {
+    constructor() {
+        // Access the Router without a constructor
+        this.router = inject(Router);
+        this.translate = inject(TranslateService);
+        // Common Dependency Injection
+        this.dataService = inject(MODEL_SERVICE, { optional: true });
+        this.modelToken = inject(MODEL_TOKEN, { optional: true });
+        this.dialogService = inject(DIALOG_SERVICE_TOKEN, { optional: true });
+        this.basePath = '';
+        this.title = '';
+        // --- Configuration Inputs (Your previous snapshot keys) ---
+        this.model = null;
+        this.dictPath = null; //rdict
+        this.fileLayout = ''; //rdict
+        this.idProperty = 'id';
+        // Visibility & UI
+        this.showHeader = true;
+        this.showSearch = false;
+        this.searchFields = null;
+        // Data & Pagination
+        this.pageable = false;
+        this.pageSizes = [10, 20, 30, 50, 100];
+        this.defaultSort = null;
+        this.defaultSortDirection = null;
+        this.defaultFilter = null;
+        this.customInclude = null;
+        // Actions & Rules
+        this.hasAdd = true;
+        this.canDelete = true;
+        this.canEdit = true;
+        this.deletePropertyName = 'name';
+        // Edit Behavior
+        this.editOnClick = false;
+        this.editOnDblClick = false;
+        this.editColumn = null;
+        this.useView = false; //rdict
+        this.hostClass = '';
     }
-    getCustom(params, headers, customUrl, customResponseType) {
-        return this.datastore.getCustom(this.modelType, params, headers, customUrl, customResponseType);
+    ngOnInit() {
+        const urlTree = this.router.url.split('?')[0];
+        const currentUrlSegments = urlTree
+            .split('/')
+            .filter((segment) => segment !== '')
+            .map((segment) => new UrlSegment(segment, {}));
+        this.basePath = currentUrlSegments.map((segment) => segment.path).join('/');
     }
-    postCustom(body, params, headers, customUrl) {
-        return this.datastore.postCustom(this.modelType, body, params, headers, customUrl);
+    get hostClasses() {
+        return this.hostClass;
     }
-    patchCustom(body, params, headers, customUrl) {
-        return this.datastore.patchCustom(this.modelType, body, params, headers, customUrl);
+    addHandler() {
+        this.router.navigate([`${this.basePath}/add`]);
     }
-    // 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();
+    edit(dataItem, column) {
+        // 1. Resolve the dynamic ID value from the object
+        const idValue = dataItem[this.idProperty];
+        if (idValue) {
+            // 2. Navigate using the resolved value
+            this.router.navigate([`${this.basePath}/edit/${idValue}`]);
         }
         else {
-            return this.patch(docTypeOrFormGroup, origModel, id);
+            console.warn(`Property "${this.idProperty}" not found on data item:`, dataItem);
         }
     }
-    patch(docTypeOrFormGroup, origModel, id) {
-        let fromModel;
-        if (docTypeOrFormGroup instanceof UntypedFormGroup) {
-            fromModel = this.fromFormGroup(docTypeOrFormGroup, id);
-        }
-        else {
-            fromModel = docTypeOrFormGroup;
+    /**
+     * Shared delete logic that can be called by any implementation
+     */
+    delete(dataItem) {
+        const idValue = Reflect.get(dataItem, this.idProperty);
+        const modelName = Reflect.get(dataItem, this.deletePropertyName);
+        const message = this.translate.instant('Are you sure you want to delete this {{modelName}}?', { modelName });
+        if (this.dialogService) {
+            // Use the generic confirm method
+            this.dialogService.confirmDelete().subscribe((confirmed) => {
+                if (confirmed)
+                    this.performDelete(idValue);
+            });
         }
-        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();
+        else if (confirm(message)) {
+            // Fallback to browser confirm if no service is provided
+            this.performDelete(idValue);
         }
-        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: "19.2.8", ngImport: i0, type: BaseService, deps: [{ token: BaseDatastore }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseTableImplementation, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.8", type: BaseTableImplementation, isStandalone: true, inputs: { model: "model", dictPath: "dictPath", fileLayout: "fileLayout", idProperty: "idProperty", showHeader: "showHeader", showSearch: "showSearch", searchFields: "searchFields", pageable: "pageable", pageSizes: "pageSizes", defaultSort: "defaultSort", defaultSortDirection: "defaultSortDirection", defaultFilter: "defaultFilter", customInclude: "customInclude", hasAdd: "hasAdd", canDelete: "canDelete", canEdit: "canEdit", deletePropertyName: "deletePropertyName", deleteDisableRule: "deleteDisableRule", editOnClick: "editOnClick", editOnDblClick: "editOnDblClick", editColumn: "editColumn", useView: "useView", hostClass: "hostClass" }, host: { properties: { "class": "this.hostClasses" } }, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: BaseDatastore }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseTableImplementation, decorators: [{
+            type: Directive
+        }], propDecorators: { model: [{
+                type: Input
+            }], dictPath: [{
+                type: Input
+            }], fileLayout: [{
+                type: Input
+            }], idProperty: [{
+                type: Input
+            }], showHeader: [{
+                type: Input
+            }], showSearch: [{
+                type: Input
+            }], searchFields: [{
+                type: Input
+            }], pageable: [{
+                type: Input
+            }], pageSizes: [{
+                type: Input
+            }], defaultSort: [{
+                type: Input
+            }], defaultSortDirection: [{
+                type: Input
+            }], defaultFilter: [{
+                type: Input
+            }], customInclude: [{
+                type: Input
+            }], hasAdd: [{
+                type: Input
+            }], canDelete: [{
+                type: Input
+            }], canEdit: [{
+                type: Input
+            }], deletePropertyName: [{
+                type: Input
+            }], deleteDisableRule: [{
+                type: Input
+            }], editOnClick: [{
+                type: Input
+            }], editOnDblClick: [{
+                type: Input
+            }], editColumn: [{
+                type: Input
+            }], useView: [{
+                type: Input
+            }], hostClass: [{
+                type: Input
+            }], hostClasses: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
 
-const DialogSERVICE = new InjectionToken('DialogService');
-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();
+class Configurations {
+    constructor() {
+        this.baseUrl = '';
+        this.authUrl = '';
+        this.apiVersion = 'api/v1';
     }
-    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());
-            }
+}
+
+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 {
-            this.modelId = model.id;
-            this.isEdit = true;
-            this.generateForm(model);
+            return value;
         }
     }
-    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]);
+    unmask(value) {
+        // const result = format(value, 'YYYY-MM-DDTHH:mm:ssZ');
+        return value;
     }
-    onSave() {
-        this.saveModel(this.baseForm);
+}
+
+class MetadataStorage {
+    static { this.metadataMap = new WeakMap(); }
+    static getMetadata(key, target, propertyKey) {
+        const metadata = this.metadataMap.get(target) || {};
+        return propertyKey ? metadata[`${key}:${propertyKey}`] : metadata[key];
     }
-    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);
-            }
+    static setMetadata(key, value, target, propertyKey) {
+        let metadata = this.metadataMap.get(target);
+        if (!metadata) {
+            metadata = {};
+            this.metadataMap.set(target, metadata);
+        }
+        if (propertyKey) {
+            metadata[`${key}:${propertyKey}`] = value;
+        }
+        else {
+            metadata[key] = value;
         }
     }
-    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')
-                            });
-                        }
-                    });
+}
+
+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 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')
-                            });
-                        }
-                    });
+                    const datatype = new dataType();
+                    if (datatype.mask && datatype.unmask) {
+                        attrConverter = datatype;
+                    }
+                }
+                if (attrConverter) {
+                    if (!forSerialisation) {
+                        return attrConverter.mask(value);
+                    }
+                    return attrConverter.unmask(value);
                 }
             }
-        }
-    }
-    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'];
+            return value;
+        };
+        const saveAnnotations = () => {
+            const metadata = MetadataStorage.getMetadata('Attribute', target) || {};
+            metadata[propertyName] = {
+                marked: true
+            };
+            MetadataStorage.setMetadata('Attribute', metadata, target);
+            const mappingMetadata = MetadataStorage.getMetadata('AttributeMapping', target) || {};
+            const serializedPropertyName = options.serializedName !== undefined ? options.serializedName : propertyName;
+            mappingMetadata[serializedPropertyName] = propertyName;
+            MetadataStorage.setMetadata('AttributeMapping', mappingMetadata, target);
+            const requiredMetadata = MetadataStorage.getMetadata('AttributeRequired', target) || {};
+            requiredMetadata[serializedPropertyName] = options.required !== undefined ? options.required : false;
+            MetadataStorage.setMetadata('AttributeRequired', requiredMetadata, target);
+            const defaultMetadata = MetadataStorage.getMetadata('AttributedefaultValue', target) || {};
+            defaultMetadata[serializedPropertyName] = options.defaultValue !== undefined ? options.defaultValue : null;
+            MetadataStorage.setMetadata('AttributedefaultValue', defaultMetadata, target);
+            const formSubGroupMetadata = MetadataStorage.getMetadata('AttributeformSubGroup', target) || {};
+            formSubGroupMetadata[serializedPropertyName] = options.formSubGroup !== undefined ? options.formSubGroup : null;
+            MetadataStorage.setMetadata('AttributeformSubGroup', formSubGroupMetadata, target);
+        };
+        const setMetadata = (hasDirtyAttributes, instance, oldValue, newValue, isNew) => {
+            const targetType = MetadataStorage.getMetadata('design:type', target, propertyName);
+            if (!instance[AttributeMetadata]) {
+                instance[AttributeMetadata] = {};
             }
-            if (rvalue === '') {
-                rvalue = this.getCustomErrorMessage(error, fieldLabel);
+            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 = MetadataStorage.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
+            });
         }
-        return rvalue;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseFormEditComponent, deps: [{ token: i1$2.UntypedFormBuilder }, { token: i2.Router }, { token: i2.ActivatedRoute }, { token: BaseService }, { token: DialogSERVICE }, { token: i1$3.TranslateService }, { token: i5.Location }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.8", type: BaseFormEditComponent, isStandalone: false, selector: "app-base.form.edit", ngImport: i0, template: '', isInline: true }); }
+    };
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseFormEditComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'app-base.form.edit',
-                    template: '',
-                    standalone: false
-                }]
-        }], ctorParameters: () => [{ type: i1$2.UntypedFormBuilder }, { type: i2.Router }, { type: i2.ActivatedRoute }, { type: BaseService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [DialogSERVICE]
-                }] }, { type: i1$3.TranslateService }, { type: i5.Location }] });
 
-class BaseTableImplementation {
-    constructor() {
-        // Access the Router without a constructor
-        this.router = inject(Router);
-        this.translate = inject(TranslateService);
-        // Common Dependency Injection
-        this.dataService = inject(MODEL_SERVICE, { optional: true });
-        this.modelToken = inject(MODEL_TOKEN, { optional: true });
-        this.dialogService = inject(DIALOG_SERVICE_TOKEN, { optional: true });
-        this.basePath = '';
-        this.title = '';
-        // --- Configuration Inputs (Your previous snapshot keys) ---
-        this.model = null;
-        this.dictPath = null; //rdict
-        this.fileLayout = ''; //rdict
-        this.idProperty = 'id';
-        // Visibility & UI
-        this.showHeader = true;
-        this.showSearch = false;
-        this.searchFields = null;
-        // Data & Pagination
-        this.pageable = false;
-        this.pageSizes = [10, 20, 30, 50, 100];
-        this.defaultSort = null;
-        this.defaultSortDirection = null;
-        this.defaultFilter = null;
-        this.customInclude = null;
-        // Actions & Rules
-        this.hasAdd = true;
-        this.canDelete = true;
-        this.canEdit = true;
-        this.deletePropertyName = 'name';
-        // Edit Behavior
-        this.editOnClick = false;
-        this.editOnDblClick = false;
-        this.editColumn = null;
-        this.useView = false; //rdict
-        this.hostClass = '';
+function BaseDatastoreConfig(config = {}) {
+    // tslint:disable-next-line:only-arrow-functions
+    return (target) => {
+        MetadataStorage.setMetadata('BaseDatastoreConfig', config, target);
+    };
+}
+
+class BaseMetaModel {
+    constructor(response) {
+        this.links = response.links || [];
+        this.meta = response.meta;
     }
-    ngOnInit() {
-        const urlTree = this.router.url.split('?')[0];
-        const currentUrlSegments = urlTree
-            .split('/')
-            .filter((segment) => segment !== '')
-            .map((segment) => new UrlSegment(segment, {}));
-        this.basePath = currentUrlSegments.map((segment) => segment.path).join('/');
+}
+
+function BaseModelConfig(config = {}) {
+    return (target) => {
+        if (typeof config['meta'] === 'undefined' || config['meta'] == null) {
+            config['meta'] = BaseMetaModel;
+        }
+        MetadataStorage.setMetadata('BaseModelConfig', config, target);
+    };
+}
+
+function CustomType(config = {}) {
+    return (target, propertyName) => {
+        const annotations = MetadataStorage.getMetadata('CustomType', target) || [];
+        annotations.push({
+            propertyName,
+            relationship: config.key || propertyName
+        });
+        MetadataStorage.setMetadata('CustomType', annotations, target);
+    };
+}
+
+class CacheService {
+    constructor() {
+        this.cache = {};
     }
-    get hostClasses() {
-        return this.hostClass;
+    get(key) {
+        const cachedItem = this.cache[key];
+        if (cachedItem && cachedItem.expiration > Date.now()) {
+            return cachedItem.data;
+        }
+        this.delete(key);
+        return null;
     }
-    addHandler() {
-        this.router.navigate([`${this.basePath}/add`]);
+    set(key, data, expiresInMs) {
+        const expiration = Date.now() + expiresInMs;
+        this.cache[key] = { data, expiration };
     }
-    edit(dataItem, column) {
-        // 1. Resolve the dynamic ID value from the object
-        const idValue = dataItem[this.idProperty];
-        if (idValue) {
-            // 2. Navigate using the resolved value
-            this.router.navigate([`${this.basePath}/edit/${idValue}`]);
-        }
-        else {
-            console.warn(`Property "${this.idProperty}" not found on data item:`, dataItem);
-        }
+    delete(key) {
+        delete this.cache[key];
     }
-    /**
-     * Shared delete logic that can be called by any implementation
-     */
-    delete(dataItem) {
-        const idValue = Reflect.get(dataItem, this.idProperty);
-        const modelName = Reflect.get(dataItem, this.deletePropertyName);
-        const message = this.translate.instant('Are you sure you want to delete this {{modelName}}?', { modelName });
-        if (this.dialogService) {
-            // Use the generic confirm method
-            this.dialogService.confirmDelete().subscribe((confirmed) => {
-                if (confirmed)
-                    this.performDelete(idValue);
-            });
+    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: "19.2.8", ngImport: i0, type: CacheService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: CacheService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: CacheService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+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);
         }
-        else if (confirm(message)) {
-            // Fallback to browser confirm if no service is provided
-            this.performDelete(idValue);
+        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: "19.2.8", ngImport: i0, type: BaseTableImplementation, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.8", type: BaseTableImplementation, isStandalone: true, inputs: { model: "model", dictPath: "dictPath", fileLayout: "fileLayout", idProperty: "idProperty", showHeader: "showHeader", showSearch: "showSearch", searchFields: "searchFields", pageable: "pageable", pageSizes: "pageSizes", defaultSort: "defaultSort", defaultSortDirection: "defaultSortDirection", defaultFilter: "defaultFilter", customInclude: "customInclude", hasAdd: "hasAdd", canDelete: "canDelete", canEdit: "canEdit", deletePropertyName: "deletePropertyName", deleteDisableRule: "deleteDisableRule", editOnClick: "editOnClick", editOnDblClick: "editOnDblClick", editColumn: "editColumn", useView: "useView", hostClass: "hostClass" }, host: { properties: { "class": "this.hostClasses" } }, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", 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: "19.2.8", ngImport: i0, type: CacheInterceptor }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseTableImplementation, decorators: [{
-            type: Directive
-        }], propDecorators: { model: [{
-                type: Input
-            }], dictPath: [{
-                type: Input
-            }], fileLayout: [{
-                type: Input
-            }], idProperty: [{
-                type: Input
-            }], showHeader: [{
-                type: Input
-            }], showSearch: [{
-                type: Input
-            }], searchFields: [{
-                type: Input
-            }], pageable: [{
-                type: Input
-            }], pageSizes: [{
-                type: Input
-            }], defaultSort: [{
-                type: Input
-            }], defaultSortDirection: [{
-                type: Input
-            }], defaultFilter: [{
-                type: Input
-            }], customInclude: [{
-                type: Input
-            }], hasAdd: [{
-                type: Input
-            }], canDelete: [{
-                type: Input
-            }], canEdit: [{
-                type: Input
-            }], deletePropertyName: [{
-                type: Input
-            }], deleteDisableRule: [{
-                type: Input
-            }], editOnClick: [{
-                type: Input
-            }], editOnDblClick: [{
-                type: Input
-            }], editColumn: [{
-                type: Input
-            }], useView: [{
-                type: Input
-            }], hostClass: [{
-                type: Input
-            }], hostClasses: [{
-                type: HostBinding,
-                args: ['class']
-            }] } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: CacheInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['CACHE_EXPIRATION_TIME']
+                }] }, { type: CacheService }] });
 
-class Configurations {
-    constructor() {
-        this.baseUrl = '';
-        this.authUrl = '';
-        this.apiVersion = 'api/v1';
+class BaseQueryData {
+    constructor(jsonApiModels, metaData) {
+        this.jsonApiModels = jsonApiModels;
+        this.metaData = metaData;
+    }
+    getModels() {
+        return this.jsonApiModels;
+    }
+    getMeta() {
+        return this.metaData;
     }
 }
 
-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;
+class BaseModel {
+    // tslint:disable-next-line:variable-name
+    constructor(data) {
+        if (data) {
+            if (data.id) {
+                this.id = data.id;
+            }
+            Object.assign(this, data);
         }
-        const d = parseISO(value);
-        if (d instanceof Date && !isNaN(d.getTime())) {
-            return d;
+    }
+    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;
+                }
+            }
         }
-        else {
-            return value;
+        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;
     }
-    unmask(value) {
-        // const result = format(value, 'YYYY-MM-DDTHH:mm:ssZ');
-        return value;
+    get modelConfig() {
+        return MetadataStorage.getMetadata('BaseModelConfig', this.constructor);
     }
-}
-
-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();
+    deserializeModel(modelType, data) {
+        data = this.transformSerializedNamesToPropertyNames(modelType, data);
+        return new modelType(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 MetadataStorage.getMetadata('AttributeMapping', model);
+    }
+    getModelRequiredPropertyNames(model) {
+        return MetadataStorage.getMetadata('AttributeRequired', model);
+    }
+    getModelDefaultPropertyValues(model) {
+        return MetadataStorage.getMetadata('AttributedefaultValue', model);
+    }
+    getModelSubGroupPropertyNames(model) {
+        return MetadataStorage.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 {
-                    const datatype = new dataType();
-                    if (datatype.mask && datatype.unmask) {
-                        attrConverter = datatype;
-                    }
-                }
-                if (attrConverter) {
-                    if (!forSerialisation) {
-                        return attrConverter.mask(value);
-                    }
-                    return attrConverter.unmask(value);
+                    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) {
+        try {
+            const props = Object.keys(this.getModelPropertyNames(this));
+            const formSubGroupsValues = this.getModelSubGroupPropertyNames(this);
+            const data = {};
+            if (id) {
+                data.id = id;
             }
-            return value;
-        };
-        const saveAnnotations = () => {
-            const metadata = MetadataStorage.getMetadata('Attribute', target) || {};
-            metadata[propertyName] = {
-                marked: true
-            };
-            MetadataStorage.setMetadata('Attribute', metadata, target);
-            const mappingMetadata = MetadataStorage.getMetadata('AttributeMapping', target) || {};
-            const serializedPropertyName = options.serializedName !== undefined ? options.serializedName : propertyName;
-            mappingMetadata[serializedPropertyName] = propertyName;
-            MetadataStorage.setMetadata('AttributeMapping', mappingMetadata, target);
-            const requiredMetadata = MetadataStorage.getMetadata('AttributeRequired', target) || {};
-            requiredMetadata[serializedPropertyName] = options.required !== undefined ? options.required : false;
-            MetadataStorage.setMetadata('AttributeRequired', requiredMetadata, target);
-            const defaultMetadata = MetadataStorage.getMetadata('AttributedefaultValue', target) || {};
-            defaultMetadata[serializedPropertyName] = options.defaultValue !== undefined ? options.defaultValue : null;
-            MetadataStorage.setMetadata('AttributedefaultValue', defaultMetadata, target);
-            const formSubGroupMetadata = MetadataStorage.getMetadata('AttributeformSubGroup', target) || {};
-            formSubGroupMetadata[serializedPropertyName] = options.formSubGroup !== undefined ? options.formSubGroup : null;
-            MetadataStorage.setMetadata('AttributeformSubGroup', formSubGroupMetadata, target);
-        };
-        const setMetadata = (hasDirtyAttributes, instance, oldValue, newValue, isNew) => {
-            const targetType = MetadataStorage.getMetadata('design:type', target, propertyName);
-            if (!instance[AttributeMetadata]) {
-                instance[AttributeMetadata] = {};
+            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;
+                });
             }
-            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 = MetadataStorage.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 (data) {
+                if (id) {
+                    this.id = id;
+                }
+                Object.assign(this, data);
             }
-        };
-        if (delete target[propertyName]) {
-            saveAnnotations();
-            Object.defineProperty(target, propertyName, {
-                get: getter,
-                set: setter,
-                enumerable: true,
-                configurable: true
-            });
         }
-    };
+        catch (error) {
+            Object.assign(this, formGroup.value);
+        }
+    }
+    getCellClass(property) {
+        return '';
+    }
 }
 
-function BaseDatastoreConfig(config = {}) {
-    // tslint:disable-next-line:only-arrow-functions
-    return (target) => {
-        MetadataStorage.setMetadata('BaseDatastoreConfig', config, target);
-    };
+class ErrorResponse {
+    constructor(errors) {
+        this.errors = [];
+        if (errors) {
+            this.errors = errors;
+        }
+    }
 }
 
-class BaseMetaModel {
-    constructor(response) {
-        this.links = response.links || [];
-        this.meta = response.meta;
+class Rule {
+    constructor() {
+        this.parameters = [];
     }
 }
 
-function BaseModelConfig(config = {}) {
-    return (target) => {
-        if (typeof config['meta'] === 'undefined' || config['meta'] == null) {
-            config['meta'] = BaseMetaModel;
+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 });
+            }
         }
-        MetadataStorage.setMetadata('BaseModelConfig', config, target);
-    };
+        return rvalue;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: InputErrorPipe, deps: [{ token: i1$3.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.8", ngImport: i0, type: InputErrorPipe, isStandalone: false, name: "inputError" }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: InputErrorPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'inputError',
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i1$3.TranslateService }] });
 
-function CustomType(config = {}) {
-    return (target, propertyName) => {
-        const annotations = MetadataStorage.getMetadata('CustomType', target) || [];
-        annotations.push({
-            propertyName,
-            relationship: config.key || propertyName
-        });
-        MetadataStorage.setMetadata('CustomType', annotations, target);
-    };
+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: "19.2.8", ngImport: i0, type: Nl2brPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.8", ngImport: i0, type: Nl2brPipe, isStandalone: false, name: "nl2br" }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: Nl2brPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'nl2br',
+                    standalone: false
+                }]
+        }] });
 
-class CacheInterceptor {
-    constructor(expirationTime, cacheService) {
-        this.expirationTime = expirationTime;
-        this.cacheService = cacheService;
-        this.cache = new Map();
+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;
+        }
     }
-    intercept(request, next) {
-        const bypassCache = request.params.get('bypassCache') || false;
-        if (bypassCache || request.method !== 'GET') {
-            return next.handle(request);
+    get getAllAttributes() {
+        if (this.datastoreConfig.overrides
+            && this.datastoreConfig.overrides.getAllAttributes) {
+            return this.datastoreConfig.overrides.getAllAttributes;
         }
-        if (!bypassCache) {
-            const cachedResponse = this.cacheService.get(request.urlWithParams);
-            if (cachedResponse) {
-                return of(cachedResponse.clone());
-                //return cachedResponse;
-            }
+        else {
+            return BaseDatastore.getAllAttributes;
         }
-        return next.handle(request).pipe(tap((event) => {
-            if (event instanceof HttpResponse) {
-                this.cacheService.set(request.urlWithParams, event.clone(), this.expirationTime);
+    }
+    // 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;
+                }
             }
-        }));
-        // 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 });
-        //     }
-        //   })
-        // );
+        }
+        return dirtyData;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", 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: "19.2.8", ngImport: i0, type: CacheInterceptor }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: CacheInterceptor, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ 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;
+    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;
             }
-            Object.assign(this, data);
         }
+        return dirtyData;
     }
-    save(params, headers, customUrl, customBody) {
-        const attributesMetadata = this[AttributeMetadata];
-        return this._datastore.saveRecord(attributesMetadata, this, params, headers, customUrl, customBody);
+    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;
     }
-    patch(origModel, params, headers, customUrl) {
-        const attributesMetadata = this[AttributeMetadata];
-        return this._datastore.patchRecord(attributesMetadata, this, origModel, params, headers, customUrl);
+    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;
     }
-    replace(params, headers, customUrl, customBody) {
-        const attributesMetadata = this[AttributeMetadata];
-        return this._datastore.replaceRecord(attributesMetadata, this, params, headers, customUrl, customBody);
+    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(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 = MetadataStorage.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(data);
     }
-    get attributeMetadata() {
-        const attributesMetadata = this[AttributeMetadata];
-        return attributesMetadata;
+    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);
     }
-    set attributeMetadata(val) {
-        this[AttributeMetadata] = val;
+    parseMeta(body, modelType) {
+        const metaModel = MetadataStorage.getMetadata('BaseModelConfig', modelType).meta;
+        return new metaModel(body);
     }
-    get hasDirtyAttributes() {
-        const attributesMetadata = this[AttributeMetadata];
-        let hasDirtyAttributes = false;
+    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) {
-                    hasDirtyAttributes = true;
-                    break;
+                    metadata.hasDirtyAttributes = false;
                 }
             }
         }
-        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;
-                }
-            }
+        if (res) {
+            res.attributeMetadata = attributesMetadata;
         }
-        this[AttributeMetadata] = attributesMetadata;
-    }
-    get modelConfig() {
-        return MetadataStorage.getMetadata('BaseModelConfig', this.constructor);
+        return res;
     }
-    deserializeModel(modelType, data) {
-        data = this.transformSerializedNamesToPropertyNames(modelType, data);
-        return new modelType(this._datastore, data);
+    get datastoreConfig() {
+        const configFromDecorator = MetadataStorage.getMetadata('BaseDatastoreConfig', this.constructor);
+        return Object.assign(configFromDecorator, this.config);
     }
     transformSerializedNamesToPropertyNames(modelType, attributes) {
+        const apiFieldMap = this.getApiFieldMap(modelType);
+        if (apiFieldMap) {
+            const properties = {};
+            Object.keys(apiFieldMap).forEach((serializedName) => {
+                if (attributes[serializedName] !== null && attributes[serializedName] !== undefined) {
+                    properties[apiFieldMap[serializedName]] = attributes[serializedName];
+                }
+            });
+            return properties;
+        }
         const serializedNameToPropertyName = this.getModelPropertyNames(modelType.prototype);
         const properties = {};
         Object.keys(serializedNameToPropertyName).forEach((serializedName) => {
@@ -1442,154 +1575,75 @@ class BaseModel {
     getModelPropertyNames(model) {
         return MetadataStorage.getMetadata('AttributeMapping', model);
     }
-    getModelRequiredPropertyNames(model) {
-        return MetadataStorage.getMetadata('AttributeRequired', model);
-    }
-    getModelDefaultPropertyValues(model) {
-        return MetadataStorage.getMetadata('AttributedefaultValue', model);
+    getApiFieldMap(modelType) {
+        return modelType.apiFieldMap || null;
     }
-    getModelSubGroupPropertyNames(model) {
-        return MetadataStorage.getMetadata('AttributeformSubGroup', 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);
     }
-    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;
-                }
+    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]);
             });
         }
-        return fb.group(controlsConfig);
+        const modelConfig = MetadataStorage.getMetadata('BaseModelConfig', modelType);
+        httpParams = httpParams.set('bypassCache', modelConfig.bypassCache || false);
+        return httpParams;
     }
-    getSubFromGroup(fb, controlsConfig, subGroup) {
-        if (!controlsConfig[subGroup])
-            controlsConfig[subGroup] = fb.group({});
-        return controlsConfig[subGroup];
+    entityToModel(res, modelType, model) {
+        return this.extractRecordDataJson(res, modelType, model);
     }
-    getModelFromFormGroup(formGroup, id) {
-        try {
-            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);
-            }
+    extractRecordDataJson(res, modelType, model) {
+        const body = res;
+        if (!body) {
+            throw new Error('no body in response');
         }
-        catch (error) {
-            Object.assign(this, formGroup.value);
+        if (model) {
+            Object.assign(model, body);
         }
+        const deserializedModel = model || this.deserializeModel(modelType, body.data || body);
+        return deserializedModel;
     }
-    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;
+    modelToEntity(model, attributesMetadata, allAttributes = false) {
+        let attributes;
+        if (allAttributes) {
+            attributes = this.getAllAttributes(attributesMetadata, model);
         }
-    }
-}
-
-class Rule {
-    constructor() {
-        this.parameters = [];
-    }
-}
-
-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 });
-            }
+        else {
+            attributes = this.getDirtyAttributes(attributesMetadata, model);
         }
-        return rvalue;
+        // this.getRelationships(model, attributes);
+        return attributes;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: InputErrorPipe, deps: [{ token: i1$3.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.8", ngImport: i0, type: InputErrorPipe, isStandalone: false, name: "inputError" }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: InputErrorPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'inputError',
-                    standalone: false
-                }]
-        }], ctorParameters: () => [{ type: i1$3.TranslateService }] });
-
-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;
+    _toQueryString(params) {
+        return queryString.stringify(params, { arrayFormat: 'bracket' });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: Nl2brPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.8", ngImport: i0, type: Nl2brPipe, isStandalone: false, name: "nl2br" }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseDatastore, deps: [{ token: i1$1.HttpClient }, { token: CacheService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseDatastore }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: Nl2brPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'nl2br',
-                    standalone: false
-                }]
-        }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: BaseDatastore, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1$1.HttpClient }, { type: CacheService }] });
 
 let DatastoreCore = class DatastoreCore extends BaseDatastore {
     constructor(http, cacheService, configExt) {
@@ -1818,7 +1872,7 @@ class EmployeeService extends BaseService {
         super(datastore);
         this.setModelType(Employee);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: EmployeeService, deps: [{ token: DatastoreCore }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: EmployeeService, deps: [{ token: DATASTORE_PORT }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: EmployeeService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: EmployeeService, decorators: [{
@@ -1826,7 +1880,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [{ type: DatastoreCore }] });
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DATASTORE_PORT]
+                }] }] });
 
 class LocalFileService {
     constructor(http) {
@@ -1839,10 +1896,13 @@ class LocalFileService {
         }
         const dataSubject = new ReplaySubject(1); // Store the latest value
         this.cache.set(jsonUrl, dataSubject);
-        this.http.get(jsonUrl).pipe(tap(data => dataSubject.next(data)) // Cache the fetched data
-        ).subscribe({
-            next: data => console.log('Data loaded for', jsonUrl),
-            error: err => console.error('Error loading JSON:', err)
+        this.http
+            .get(jsonUrl)
+            .pipe(tap((data) => dataSubject.next(data)) // Cache the fetched data
+        )
+            .subscribe({
+            next: (data) => console.log('Data loaded for', jsonUrl),
+            error: (err) => console.error('Error loading JSON:', err)
         });
         return dataSubject.asObservable(); // Return observable
     }
@@ -1865,7 +1925,7 @@ class RoleService extends BaseService {
         const url = `${this.datastore.buildUrl(Role)}/${roleId}/rights`;
         return this.getCustom(null, null, url);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: RoleService, deps: [{ token: DatastoreCore }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: RoleService, deps: [{ token: DATASTORE_PORT }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: RoleService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: RoleService, decorators: [{
@@ -1873,7 +1933,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [{ type: DatastoreCore }] });
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DATASTORE_PORT]
+                }] }] });
 
 class RouteHistoryService {
     constructor(router) {
@@ -1955,7 +2018,7 @@ class UserService extends BaseService {
         const response = this.datastore.findAll(Menu);
         return response;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: UserService, deps: [{ token: DatastoreCore }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: UserService, deps: [{ token: DATASTORE_PORT }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: UserService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: UserService, decorators: [{
@@ -1963,11 +2026,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [{ type: DatastoreCore }] });
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DATASTORE_PORT]
+                }] }] });
 
 const PROVIDERS = [
     BaseDatastore,
     DatastoreCore,
+    { provide: DATASTORE_PORT, useExisting: DatastoreCore },
     DatePipe,
     DecimalPipe,
     PercentPipe
@@ -2091,7 +2158,7 @@ class RightService extends BaseService {
         super(datastore);
         this.setModelType(Right);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: RightService, deps: [{ token: DatastoreCore }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: RightService, deps: [{ token: DATASTORE_PORT }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: RightService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: RightService, decorators: [{
@@ -2099,7 +2166,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [{ type: DatastoreCore }] });
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DATASTORE_PORT]
+                }] }] });
 
 function readFileAsync(file) {
     return new Promise((resolve, reject) => {
@@ -2136,5 +2206,5 @@ function getValueFromJsonData(jsonData, key) {
  * Generated bundle index. Do not edit.
  */
 
-export { Attribute, AuthService, BaseCrudImplementation, BaseDatastore, BaseDatastoreConfig, BaseFormEditComponent, BaseMetaModel, BaseModel, BaseModelConfig, BaseQueryData, BaseService, BaseTableImplementation, CRUD_IMPLEMENTATIONS_TOKEN, CacheInterceptor, CacheService, CellTextAlign, Configurations, CustomType, CustomValidators, DIALOG_SERVICE_TOKEN, DatastoreCore, DynamicallyModelResolver, DynamicallyServiceResolver, Employee, EmployeeService, ErrorResponse, FieldErrorDisplayComponent, GridLayoutFormat, InputErrorPipe, LocalFileService, MODEL_SERVICE, MODEL_TOKEN, Menu, MetadataStorage, Nl2brPipe, OIDC_CLIENT_SETTINGS, PROVIDERS, PageNotFoundComponent, Right, RightService, Role, RoleService, RouteHistoryService, RslBaseModule, Rule, TABLE_IMPLEMENTATIONS_TOKEN, Tokens, TranslateloaderService, UnderConstructionComponent, User, UserService, getValueFromJsonData, provideAuth, provideOidcUserManager, readFileAsync };
+export { Attribute, AuthService, BaseCrudImplementation, BaseDatastore, BaseDatastoreConfig, BaseFormEditComponent, BaseMetaModel, BaseModel, BaseModelConfig, BaseQueryData, BaseService, BaseTableImplementation, CacheInterceptor, CacheService, CellTextAlign, Configurations, CustomType, CustomValidators, DATASTORE_PORT, DIALOG_SERVICE_TOKEN, DatastoreCore, DynamicallyModelResolver, DynamicallyServiceResolver, Employee, EmployeeService, ErrorResponse, FieldErrorDisplayComponent, GridLayoutFormat, InputErrorPipe, LocalFileService, MODEL_SERVICE, MODEL_TOKEN, Menu, MetadataStorage, Nl2brPipe, OIDC_CLIENT_SETTINGS, OIDC_GUEST_CLIENT_SETTINGS, PROVIDERS, PageNotFoundComponent, RSL_FORM_IMPLEMENTATIONS_TOKEN, Right, RightService, Role, RoleService, RouteHistoryService, RslBaseModule, Rule, Tokens, TranslateloaderService, UnderConstructionComponent, User, UserService, getValueFromJsonData, provideAuth, provideOidcUserManager, readFileAsync };
 //# sourceMappingURL=rosoftlab-core.mjs.map