@rosoftlab/core 1.0.5-alpha-8 → 1.0.5-alpha-9

package/fesm2022/rosoftlab-core.mjs

@@ -4,8 +4,8 @@ import * as i0 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 { 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 { BehaviorSubject, firstValueFrom, of, Observable, throwError, ReplaySubject } from 'rxjs';
+import { switchMap, catchError, map, tap, 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';
@@ -14,10 +14,9 @@ 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 { parseISO } from 'date-fns';
-import { __decorate, __metadata } from 'tslib';
 import { compare } from 'fast-json-patch';
 import queryString from 'query-string';
+import { __decorate, __metadata } from 'tslib';
 
 class Tokens {
 }
@@ -38,6 +37,83 @@ class AuthService {
             this._authNavStatusSource.next(this.isAuthenticated());
         });
     }
+    async restoreUserFromStorage() {
+        if (this.user) {
+            return true;
+        }
+        try {
+            const stored = await this.manager.getUser();
+            if (stored) {
+                this.user = stored;
+                this._authNavStatusSource.next(this.isAuthenticated());
+                return true;
+            }
+        }
+        catch {
+            // ignore
+        }
+        const raw = this.findOidcUserInWebStorage();
+        if (!raw) {
+            return false;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            const profile = parsed?.profile ?? this.decodeJwt(parsed?.access_token) ?? this.decodeJwt(parsed?.id_token);
+            const hydrated = new User$1({
+                ...parsed,
+                profile: profile ?? parsed?.profile ?? { sub: 'offline' }
+            });
+            this.user = hydrated;
+            this._authNavStatusSource.next(this.isAuthenticated());
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    findOidcUserInWebStorage() {
+        try {
+            if (typeof localStorage !== 'undefined') {
+                const key = Object.keys(localStorage).find((k) => k.startsWith('oidc.user:'));
+                if (key) {
+                    return localStorage.getItem(key);
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+        try {
+            if (typeof sessionStorage !== 'undefined') {
+                const key = Object.keys(sessionStorage).find((k) => k.startsWith('oidc.user:'));
+                if (key) {
+                    return sessionStorage.getItem(key);
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+        return null;
+    }
+    decodeJwt(token) {
+        if (!token || typeof token !== 'string') {
+            return null;
+        }
+        const parts = token.split('.');
+        if (parts.length < 2) {
+            return null;
+        }
+        try {
+            const payload = parts[1].replace(/-/g, '+').replace(/_/g, '/');
+            const padded = payload.padEnd(payload.length + ((4 - (payload.length % 4)) % 4), '=');
+            const decoded = atob(padded);
+            return JSON.parse(decoded);
+        }
+        catch {
+            return null;
+        }
+    }
     login() {
         this.manager.clearStaleState().then(() => {
             this.manager.signinRedirect();
@@ -113,10 +189,13 @@ class AuthService {
         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) => {
+        }).pipe(switchMap((response) => {
             if (!response.access_token) {
                 throw new Error('Login failed');
             }
+            const headers = { Authorization: `Bearer ${response.access_token}` };
+            return this.http.get(`${authUrlToUse}/connect/userinfo`, { headers }).pipe(catchError(() => of(null)), map((profile) => ({ response, profile })));
+        }), map(({ response, profile }) => {
             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 || '',
@@ -125,13 +204,7 @@ class AuthService {
                 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
+                profile: (profile ?? { sub: 'guest' }),
                 expires_at: expires_at,
                 userState: null
             });
@@ -392,7 +465,7 @@ class BaseService {
             else {
                 fromModel = docTypeOrFormGroup;
             }
-            return this.datastore.saveRecord(fromModel.attributeMetadata, fromModel);
+            return this.datastore.saveRecord(fromModel);
         }
         else {
             return this.patch(docTypeOrFormGroup, origModel, id);
@@ -406,7 +479,7 @@ class BaseService {
         else {
             fromModel = docTypeOrFormGroup;
         }
-        return this.datastore.patchRecord(fromModel.attributeMetadata, fromModel, origModel);
+        return this.datastore.patchRecord(fromModel, origModel);
     }
     newModel(data) {
         return new this.modelType(data);
@@ -427,7 +500,7 @@ class BaseService {
         return saveModel;
     }
     serializeModel(model) {
-        return this.datastore.modelToEntity(model, model.attributeMetadata, true);
+        return this.datastore.modelToEntity(model);
     }
     getSelectValues(property) {
         return null;
@@ -721,6 +794,7 @@ class BaseTableImplementation {
             .map((segment) => new UrlSegment(segment, {}));
         this.basePath = currentUrlSegments.map((segment) => segment.path).join('/');
     }
+    ngOnDestroy() { }
     get hostClasses() {
         return this.hostClass;
     }
@@ -836,28 +910,6 @@ var CellTextAlign;
     CellTextAlign["right"] = "right";
 })(CellTextAlign || (CellTextAlign = {}));
 
-// tslint:disable-next-line:variable-name
-const AttributeMetadata = Symbol('AttributeMetadata');
-
-class DateConverter {
-    mask(value) {
-        if (value instanceof Date && !isNaN(value.getTime())) {
-            return value;
-        }
-        const d = parseISO(value);
-        if (d instanceof Date && !isNaN(d.getTime())) {
-            return d;
-        }
-        else {
-            return value;
-        }
-    }
-    unmask(value) {
-        // const result = format(value, 'YYYY-MM-DDTHH:mm:ssZ');
-        return value;
-    }
-}
-
 class MetadataStorage {
     static { this.metadataMap = new WeakMap(); }
     static getMetadata(key, target, propertyKey) {
@@ -895,89 +947,6 @@ class MetadataStorage {
     }
 }
 
-function Attribute(options = {}) {
-    return (target, propertyName) => {
-        const converter = (dataType, value, forSerialisation = false) => {
-            let attrConverter;
-            if (dataType) {
-                if (options.converter) {
-                    attrConverter = options.converter;
-                }
-                else if (dataType === Date) {
-                    attrConverter = new DateConverter();
-                }
-                else {
-                    const datatype = new dataType();
-                    if (datatype.mask && datatype.unmask) {
-                        attrConverter = datatype;
-                    }
-                }
-                if (attrConverter) {
-                    if (!forSerialisation) {
-                        return attrConverter.mask(value);
-                    }
-                    return attrConverter.unmask(value);
-                }
-            }
-            return value;
-        };
-        const saveAnnotations = () => {
-            const metadata = 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 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
-            });
-        }
-    };
-}
-
 function BaseDatastoreConfig(config = {}) {
     // tslint:disable-next-line:only-arrow-functions
     return (target) => {
@@ -1016,6 +985,14 @@ class CacheService {
     constructor() {
         this.cache = {};
     }
+    pruneExpired() {
+        const now = Date.now();
+        Object.keys(this.cache).forEach((key) => {
+            if (this.cache[key].expiration <= now) {
+                delete this.cache[key];
+            }
+        });
+    }
     get(key) {
         const cachedItem = this.cache[key];
         if (cachedItem && cachedItem.expiration > Date.now()) {
@@ -1025,6 +1002,7 @@ class CacheService {
         return null;
     }
     set(key, data, expiresInMs) {
+        this.pruneExpired();
         const expiration = Date.now() + expiresInMs;
         this.cache[key] = { data, expiration };
     }
@@ -1113,73 +1091,33 @@ class BaseModel {
             Object.assign(this, data);
         }
     }
-    get attributeMetadata() {
-        const attributesMetadata = this[AttributeMetadata];
-        return attributesMetadata;
-    }
-    set attributeMetadata(val) {
-        this[AttributeMetadata] = val;
-    }
-    get hasDirtyAttributes() {
-        const attributesMetadata = this[AttributeMetadata];
-        let hasDirtyAttributes = false;
-        for (const propertyName in attributesMetadata) {
-            if (attributesMetadata.hasOwnProperty(propertyName)) {
-                const metadata = attributesMetadata[propertyName];
-                if (metadata.hasDirtyAttributes) {
-                    hasDirtyAttributes = true;
-                    break;
-                }
-            }
-        }
-        return hasDirtyAttributes;
-    }
-    rollbackAttributes() {
-        const attributesMetadata = this[AttributeMetadata];
-        let metadata;
-        for (const propertyName in attributesMetadata) {
-            if (attributesMetadata.hasOwnProperty(propertyName)) {
-                if (attributesMetadata[propertyName].hasDirtyAttributes) {
-                    this[propertyName] = attributesMetadata[propertyName].oldValue;
-                    metadata = {
-                        hasDirtyAttributes: false,
-                        newValue: attributesMetadata[propertyName].oldValue,
-                        oldValue: undefined
-                    };
-                    attributesMetadata[propertyName] = metadata;
-                }
-            }
-        }
-        this[AttributeMetadata] = attributesMetadata;
-    }
     get modelConfig() {
         return MetadataStorage.getMetadata('BaseModelConfig', this.constructor);
     }
-    deserializeModel(modelType, data) {
-        data = this.transformSerializedNamesToPropertyNames(modelType, data);
-        return new modelType(data);
-    }
-    transformSerializedNamesToPropertyNames(modelType, attributes) {
-        const serializedNameToPropertyName = this.getModelPropertyNames(modelType.prototype);
+    getModelPropertyNames(model) {
+        const staticFields = model.constructor.fields;
+        if (Array.isArray(staticFields) && staticFields.length) {
+            return staticFields.reduce((acc, key) => {
+                acc[key] = key;
+                return acc;
+            }, {});
+        }
         const properties = {};
-        Object.keys(serializedNameToPropertyName).forEach((serializedName) => {
-            if (attributes[serializedName] !== null && attributes[serializedName] !== undefined) {
-                properties[serializedNameToPropertyName[serializedName]] = attributes[serializedName];
-            }
+        Object.keys(model)
+            .filter((key) => !key.startsWith('_') && key !== 'highlighted')
+            .forEach((key) => {
+            properties[key] = key;
         });
         return properties;
     }
-    getModelPropertyNames(model) {
-        return MetadataStorage.getMergedMetadata('AttributeMapping', model);
-    }
     getModelRequiredPropertyNames(model) {
-        return MetadataStorage.getMergedMetadata('AttributeRequired', model);
+        return model.constructor.requiredFields || {};
     }
     getModelDefaultPropertyValues(model) {
-        return MetadataStorage.getMergedMetadata('AttributedefaultValue', model);
+        return model.constructor.defaultValues || {};
     }
     getModelSubGroupPropertyNames(model) {
-        return MetadataStorage.getMergedMetadata('AttributeformSubGroup', model);
+        return model.constructor.formSubGroups || {};
     }
     getFromGroup(fb) {
         const props = Object.keys(this.getModelPropertyNames(this));
@@ -1246,10 +1184,6 @@ class BaseModel {
         return '';
     }
 }
-__decorate([
-    Attribute({ serializedName: 'id' }),
-    __metadata("design:type", Object)
-], BaseModel.prototype, "id", void 0);
 
 class ErrorResponse {
     constructor(errors) {
@@ -1323,49 +1257,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
 
 class BaseDatastore {
     // tslint:enable:max-line-length
-    get getDirtyAttributes() {
-        if (this.datastoreConfig.overrides
-            && this.datastoreConfig.overrides.getDirtyAttributes) {
-            return this.datastoreConfig.overrides.getDirtyAttributes;
-        }
-        else {
-            return BaseDatastore.getDirtyAttributes;
-        }
-    }
-    get getAllAttributes() {
-        if (this.datastoreConfig.overrides
-            && this.datastoreConfig.overrides.getAllAttributes) {
-            return this.datastoreConfig.overrides.getAllAttributes;
-        }
-        else {
-            return BaseDatastore.getAllAttributes;
-        }
-    }
     // protected config: DatastoreConfig;
-    static getDirtyAttributes(attributesMetadata) {
-        const dirtyData = {};
-        for (const propertyName in attributesMetadata) {
-            if (attributesMetadata.hasOwnProperty(propertyName)) {
-                const metadata = attributesMetadata[propertyName];
-                if (metadata.hasDirtyAttributes) {
-                    const attributeName = metadata.serializedName != null ? metadata.serializedName : propertyName;
-                    dirtyData[attributeName] = metadata.serialisationValue ? metadata.serialisationValue : metadata.newValue;
-                }
-            }
-        }
-        return dirtyData;
-    }
-    static getAllAttributes(attributesMetadata) {
-        const dirtyData = {};
-        for (const propertyName in attributesMetadata) {
-            if (attributesMetadata.hasOwnProperty(propertyName)) {
-                const metadata = attributesMetadata[propertyName];
-                const attributeName = metadata.serializedName != null ? metadata.serializedName : propertyName;
-                dirtyData[attributeName] = metadata.serialisationValue ? metadata.serialisationValue : metadata.newValue;
-            }
-        }
-        return dirtyData;
-    }
     constructor(httpClient, cacheService) {
         this.httpClient = httpClient;
         this.cacheService = cacheService;
@@ -1373,16 +1265,15 @@ class BaseDatastore {
         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;
+        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));
+        const response = this.httpClient.get(url, { headers: customHeadhers, params: htmlParams, withCredentials: true }).pipe(map((res) => this.extractQueryData(res, modelType)), catchError(this.handleError));
         return response;
     }
     findRecord(modelType, id, params, headers, customUrl) {
@@ -1392,8 +1283,7 @@ class BaseDatastore {
             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));
+        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) {
@@ -1402,16 +1292,21 @@ class BaseDatastore {
         const htmlParams = this.buildParams(modelType, params);
         if (!customResponseType)
             customResponseType = 'json';
-        return this.httpClient.get(url, { headers: customHeadhers, params: htmlParams, withCredentials: true, responseType: customResponseType });
+        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 customHeadhers = this.buildHeaders(headers, 'application/json');
         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 customHeadhers = this.buildHeaders(headers, 'application/json');
         const url = this.buildUrl(modelType, customUrl);
         const htmlParams = this.buildParams(modelType, params);
         return this.httpClient.patch(url, body, { headers: customHeadhers, params: htmlParams, withCredentials: true });
@@ -1419,14 +1314,13 @@ class BaseDatastore {
     createRecord(modelType, data) {
         return new modelType(data);
     }
-    saveRecord(attributesMetadata, model, params, headers, customUrl, customBody) {
+    saveRecord(model, params, headers, customUrl, customBody) {
         const modelType = model.constructor;
-        const modelConfig = model.modelConfig;
-        const customHeadhers = this.buildHeaders(headers);
+        const customHeadhers = this.buildHeaders(headers, 'application/json');
         const url = this.buildUrl(modelType, customUrl);
         const htmlParams = this.buildParams(modelType, params);
         let httpCall;
-        const body = customBody || this.modelToEntity(model, attributesMetadata);
+        const body = customBody || this.modelToEntity(model);
         if (model.id) {
             // tslint:disable-next-line:max-line-length
             httpCall = this.httpClient.patch(url + '/' + model.id, body, { headers: customHeadhers, params: htmlParams, withCredentials: true });
@@ -1434,33 +1328,27 @@ class BaseDatastore {
         else {
             httpCall = this.httpClient.post(url, body, { headers: customHeadhers, params: htmlParams, withCredentials: true });
         }
-        return httpCall
-            .pipe(map(res => {
+        return httpCall.pipe(map((res) => {
             this.cacheService.clearCacheContainingKeyword(url);
-            const data = this.resetMetadataAttributes(res, attributesMetadata, modelType);
-            return this.entityToModel(data, modelType);
+            return this.entityToModel(res, modelType);
         }), catchError(this.handleError));
     }
-    patchRecord(attributesMetadata, model, origModel, params, headers, customUrl) {
+    patchRecord(model, origModel, params, headers, customUrl) {
         const modelType = model.constructor;
-        const modelConfig = model.modelConfig;
-        const customHeadhers = this.buildHeaders(headers);
+        const customHeadhers = this.buildHeaders(headers, 'application/json-patch+json');
         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 (!origModel) {
+            return this.replaceRecord(model, params, headers, customUrl);
+        }
+        model.id = origModel.id;
+        const patch = compare(this.modelToEntity(origModel), this.modelToEntity(model));
         if (patch.length > 0) {
             httpCall = this.httpClient.patch(url + '/' + model.id, patch, { headers: customHeadhers, params: htmlParams, withCredentials: true });
-            return httpCall
-                .pipe(map(res => {
+            return httpCall.pipe(map((res) => {
                 this.cacheService.clearCacheContainingKeyword(url);
-                const data = this.resetMetadataAttributes(res, attributesMetadata, modelType);
-                return this.entityToModel(data, modelType);
+                return this.entityToModel(res, modelType);
             }), catchError(this.handleError));
         }
         else {
@@ -1474,25 +1362,22 @@ class BaseDatastore {
     //   model: T,
     //   origModel: T): any {
     // }
-    replaceRecord(attributesMetadata, model, params, headers, customUrl, customBody) {
+    replaceRecord(model, params, headers, customUrl, customBody) {
         const modelType = model.constructor;
-        const modelConfig = model.modelConfig;
-        const customHeadhers = this.buildHeaders(headers);
+        const customHeadhers = this.buildHeaders(headers, 'application/json');
         const url = this.buildUrl(modelType, customUrl);
         const htmlParams = this.buildParams(modelType, params);
         let httpCall;
-        const body = customBody || this.modelToEntity(model, attributesMetadata, true);
+        const body = customBody || this.modelToEntity(model);
         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 => {
+        return httpCall.pipe(map((res) => {
             this.cacheService.clearCacheContainingKeyword(url);
-            const data = this.resetMetadataAttributes(res, attributesMetadata, modelType);
-            return this.entityToModel(data, modelType);
+            return this.entityToModel(res, modelType);
         }), catchError(this.handleError));
     }
     deleteRecord(modelType, id, headers, customUrl) {
@@ -1502,8 +1387,7 @@ class BaseDatastore {
             url = url + '/' + id;
         }
         // const idParam = new HttpParams().set('id', id);
-        return this.httpClient.delete(url, { headers: customHeadhers, withCredentials: true })
-            .pipe(map(res => {
+        return this.httpClient.delete(url, { headers: customHeadhers, withCredentials: true }).pipe(map((res) => {
             this.cacheService.clearCacheContainingKeyword(url);
             return res;
         }), catchError(this.handleError));
@@ -1531,7 +1415,6 @@ class BaseDatastore {
         return result;
     }
     deserializeModel(modelType, data) {
-        data = this.transformSerializedNamesToPropertyNames(modelType, data);
         return new modelType(data);
     }
     handleError(error) {
@@ -1553,60 +1436,20 @@ class BaseDatastore {
         const metaModel = MetadataStorage.getMetadata('BaseModelConfig', modelType).meta;
         return new metaModel(body);
     }
-    resetMetadataAttributes(res, attributesMetadata, modelType) {
-        // TODO check why is attributesMetadata from the arguments never used
-        for (const propertyName in attributesMetadata) {
-            if (attributesMetadata.hasOwnProperty(propertyName)) {
-                const metadata = attributesMetadata[propertyName];
-                if (metadata.hasDirtyAttributes) {
-                    metadata.hasDirtyAttributes = false;
-                }
-            }
-        }
-        if (res) {
-            res.attributeMetadata = attributesMetadata;
-        }
-        return res;
-    }
     get datastoreConfig() {
         const configFromDecorator = 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) => {
-            if (attributes[serializedName] !== null && attributes[serializedName] !== undefined) {
-                properties[serializedNameToPropertyName[serializedName]] = attributes[serializedName];
-            }
-        });
-        return properties;
-    }
-    getModelPropertyNames(model) {
-        return MetadataStorage.getMergedMetadata('AttributeMapping', model);
-    }
-    getApiFieldMap(modelType) {
-        return modelType.apiFieldMap || null;
-    }
-    buildHeaders(customHeaders) {
+    buildHeaders(customHeaders, contentType) {
         const headers = {
-            Accept: 'application/json-patch+json',
-            // 'Content-Type': 'application/vnd.api+json',
-            'Content-Type': 'application/json-patch+json'
+            Accept: 'application/json'
         };
+        if (contentType) {
+            headers['Content-Type'] = contentType;
+        }
         if (customHeaders && customHeaders.keys().length) {
             // tslint:disable-next-line:variable-name
-            Object.assign({}, headers, customHeaders.keys().map(header_name => {
+            Object.assign({}, headers, customHeaders.keys().map((header_name) => {
                 headers['' + header_name] = customHeaders.get(header_name);
             }));
         }
@@ -1616,13 +1459,11 @@ class BaseDatastore {
         let httpParams = new HttpParams();
         if (params) {
             Object.keys(params)
-                .filter(key => {
+                .filter((key) => {
                 const v = params[key];
-                return (Array.isArray(v) || typeof v === 'string') ?
-                    (v.length > 0) :
-                    (v !== null && v !== undefined);
+                return Array.isArray(v) || typeof v === 'string' ? v.length > 0 : v !== null && v !== undefined;
             })
-                .forEach(key => {
+                .forEach((key) => {
                 httpParams = httpParams.set(key, params[key]);
             });
         }
@@ -1644,16 +1485,22 @@ class BaseDatastore {
         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);
+    modelToEntity(model) {
+        if (!model) {
+            return model;
         }
-        else {
-            attributes = this.getDirtyAttributes(attributesMetadata, model);
-        }
-        // this.getRelationships(model, attributes);
-        return attributes;
+        const entity = {};
+        Object.keys(model).forEach((key) => {
+            if (key.startsWith('_') || key === 'highlighted' || key === 'attributeMetadata') {
+                return;
+            }
+            const value = model[key];
+            if (typeof value === 'function') {
+                return;
+            }
+            entity[key] = value;
+        });
+        return entity;
     }
     _toQueryString(params) {
         return queryString.stringify(params, { arrayFormat: 'bracket' });
@@ -1688,90 +1535,27 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
 
 let Employee = class Employee extends BaseModel {
 };
-__decorate([
-    Attribute({ serializedName: 'userName', required: true }),
-    __metadata("design:type", String)
-], Employee.prototype, "userName", void 0);
-__decorate([
-    Attribute({ serializedName: 'firstName', required: true }),
-    __metadata("design:type", String)
-], Employee.prototype, "firstName", void 0);
-__decorate([
-    Attribute({ serializedName: 'lastName', required: true }),
-    __metadata("design:type", String)
-], Employee.prototype, "lastName", void 0);
-__decorate([
-    Attribute({ serializedName: 'email', required: true }),
-    __metadata("design:type", String)
-], Employee.prototype, "email", void 0);
-__decorate([
-    Attribute({ serializedName: 'role', required: true }),
-    __metadata("design:type", Object)
-], Employee.prototype, "role", void 0);
-__decorate([
-    Attribute({ serializedName: 'password' }),
-    __metadata("design:type", String)
-], Employee.prototype, "password", void 0);
-__decorate([
-    Attribute({ serializedName: 'confirmPassword' }),
-    __metadata("design:type", String)
-], Employee.prototype, "confirmPassword", void 0);
-__decorate([
-    Attribute({ serializedName: 'extraData' }),
-    __metadata("design:type", String)
-], Employee.prototype, "extraData", void 0);
 Employee = __decorate([
     BaseModelConfig({
         type: 'employee'
     })
 ], Employee);
 
+let File = class File extends BaseModel {
+    constructor() {
+        super(...arguments);
+        // Gets or sets if the file is a temporary one and not saved to s3
+        this.isTemporary = false;
+    }
+};
+File = __decorate([
+    BaseModelConfig({
+        type: 'file'
+    })
+], File);
+
 let Menu = class Menu extends BaseModel {
 };
-__decorate([
-    Attribute({ serializedName: 'header' }),
-    __metadata("design:type", String)
-], Menu.prototype, "header", void 0);
-__decorate([
-    Attribute({ serializedName: 'icon' }),
-    __metadata("design:type", String)
-], Menu.prototype, "icon", void 0);
-__decorate([
-    Attribute({ serializedName: 'link' }),
-    __metadata("design:type", String)
-], Menu.prototype, "link", void 0);
-__decorate([
-    Attribute({ serializedName: 'title' }),
-    __metadata("design:type", String)
-], Menu.prototype, "title", void 0);
-__decorate([
-    Attribute({ serializedName: 'sublinks' }),
-    __metadata("design:type", Array)
-], Menu.prototype, "sublinks", void 0);
-__decorate([
-    Attribute({ serializedName: 'target' }),
-    __metadata("design:type", String)
-], Menu.prototype, "target", void 0);
-__decorate([
-    Attribute({ serializedName: 'external' }),
-    __metadata("design:type", Boolean)
-], Menu.prototype, "external", void 0);
-__decorate([
-    Attribute({ serializedName: 'description' }),
-    __metadata("design:type", String)
-], Menu.prototype, "description", void 0);
-__decorate([
-    Attribute({ serializedName: 'order' }),
-    __metadata("design:type", Number)
-], Menu.prototype, "order", void 0);
-__decorate([
-    Attribute({ serializedName: 'translationKey' }),
-    __metadata("design:type", String)
-], Menu.prototype, "translationKey", void 0);
-__decorate([
-    Attribute({ serializedName: 'color' }),
-    __metadata("design:type", String)
-], Menu.prototype, "color", void 0);
 Menu = __decorate([
     BaseModelConfig({
         type: 'user',
@@ -1781,46 +1565,6 @@ Menu = __decorate([
 
 let Right = class Right extends BaseModel {
 };
-__decorate([
-    Attribute({ serializedName: 'name' }),
-    __metadata("design:type", String)
-], Right.prototype, "name", void 0);
-__decorate([
-    Attribute({ serializedName: 'rightKey' }),
-    __metadata("design:type", String)
-], Right.prototype, "rightKey", void 0);
-__decorate([
-    Attribute({ serializedName: 'pagePath' }),
-    __metadata("design:type", String)
-], Right.prototype, "pagePath", void 0);
-__decorate([
-    Attribute({ serializedName: 'order' }),
-    __metadata("design:type", Number)
-], Right.prototype, "order", void 0);
-__decorate([
-    Attribute({ serializedName: 'isMenu' }),
-    __metadata("design:type", Boolean)
-], Right.prototype, "isMenu", void 0);
-__decorate([
-    Attribute({ serializedName: 'resourceName' }),
-    __metadata("design:type", String)
-], Right.prototype, "resourceName", void 0);
-__decorate([
-    Attribute({ serializedName: 'parentId' }),
-    __metadata("design:type", String)
-], Right.prototype, "parentId", void 0);
-__decorate([
-    Attribute({ serializedName: 'color' }),
-    __metadata("design:type", String)
-], Right.prototype, "color", void 0);
-__decorate([
-    Attribute({ serializedName: 'defaultRoles' }),
-    __metadata("design:type", String)
-], Right.prototype, "defaultRoles", void 0);
-__decorate([
-    Attribute({ serializedName: 'icon' }),
-    __metadata("design:type", String)
-], Right.prototype, "icon", void 0);
 Right = __decorate([
     BaseModelConfig({
         type: 'right',
@@ -1830,14 +1574,6 @@ Right = __decorate([
 
 let Role = class Role extends BaseModel {
 };
-__decorate([
-    Attribute({ serializedName: 'name' }),
-    __metadata("design:type", String)
-], Role.prototype, "name", void 0);
-__decorate([
-    Attribute({ serializedName: 'roleDetail' }),
-    __metadata("design:type", Object)
-], Role.prototype, "roleDetail", void 0);
 Role = __decorate([
     BaseModelConfig({
         type: 'role'
@@ -1849,18 +1585,6 @@ let User = class User extends BaseModel {
         return this.firstName + ' ' + this.lastName;
     }
 };
-__decorate([
-    Attribute({ serializedName: 'firstName' }),
-    __metadata("design:type", String)
-], User.prototype, "firstName", void 0);
-__decorate([
-    Attribute({ serializedName: 'lastName' }),
-    __metadata("design:type", String)
-], User.prototype, "lastName", void 0);
-__decorate([
-    Attribute({ serializedName: 'email' }),
-    __metadata("design:type", String)
-], User.prototype, "email", void 0);
 User = __decorate([
     BaseModelConfig({
         type: 'user'
@@ -1885,6 +1609,50 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
                     args: [DATASTORE_PORT]
                 }] }] });
 
+class FileService extends BaseService {
+    constructor(datastore, httpClient) {
+        super(datastore);
+        this.httpClient = httpClient;
+        this.setModelType(File);
+    }
+    upload(file, filename) {
+        const url = `${this.datastore.buildUrl(this.modelType)}/upload`;
+        const formData = new FormData();
+        const safeName = filename || file.name || `upload-${Date.now()}`;
+        formData.append('file', file, safeName);
+        return this.httpClient.post(url, formData, { withCredentials: true });
+    }
+    download(fileId, responseType = 'blob') {
+        const url = `${this.datastore.buildUrl(this.modelType)}/download`;
+        const params = new HttpParams().set('fileId', fileId);
+        return this.httpClient.get(url, {
+            params,
+            withCredentials: true,
+            responseType: responseType
+        });
+    }
+    fileUrl(fileId) {
+        const url = `${this.datastore.buildUrl(this.modelType)}/${fileId}/fileurl`;
+        return this.httpClient.get(url, { withCredentials: true });
+    }
+    putFileUrl(fileId) {
+        const url = `${this.datastore.buildUrl(this.modelType)}/putfileurl`;
+        const params = new HttpParams().set('fileId', fileId);
+        return this.httpClient.get(url, { params, withCredentials: true });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: FileService, deps: [{ token: DATASTORE_PORT }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: FileService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: FileService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DATASTORE_PORT]
+                }] }, { type: i1$1.HttpClient }] });
+
 class LocalFileService {
     constructor(http) {
         this.http = http;
@@ -1898,11 +1666,15 @@ class LocalFileService {
         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)
+            next: (data) => {
+                dataSubject.next(data);
+                dataSubject.complete();
+            },
+            error: (err) => {
+                this.cache.delete(jsonUrl);
+                dataSubject.error(err);
+            }
         });
         return dataSubject.asObservable(); // Return observable
     }
@@ -2206,5 +1978,5 @@ function getValueFromJsonData(jsonData, key) {
  * Generated bundle index. Do not edit.
  */
 
-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 };
+export { 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, File, FileService, 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