@yuuvis/client-core 0.6.5

package/esm2022/lib/service/system/system.service.mjs

@@ -0,0 +1,597 @@
+import { inject, Injectable } from '@angular/core';
+import { forkJoin, of, ReplaySubject } from 'rxjs';
+import { catchError, map, switchMap, tap } from 'rxjs/operators';
+import { Utils } from '../../util/utils';
+import { ApiBase } from '../backend/api.enum';
+import { BackendService } from '../backend/backend.service';
+import { AppCacheService } from '../cache/app-cache.service';
+import { Logger } from '../logger/logger';
+import { BaseObjectTypeField, Classification, ContentStreamAllowed, InternalFieldType, ObjectTypeClassification, SystemType } from './system.enum';
+import * as i0 from "@angular/core";
+/**
+ * Providing system definitions.
+ */
+export class SystemService {
+    constructor() {
+        this.#backend = inject(BackendService);
+        this.#appCache = inject(AppCacheService);
+        this.#logger = inject(Logger);
+        this.#STORAGE_KEY = 'yuv.core.system.definition';
+        this.#STORAGE_KEY_AUTH_DATA = 'yuv.core.auth.data';
+        // cached icons to avoid backend calls (session cache)
+        this.#iconCache = {};
+        this.#resolvedClassificationsCache = {};
+        this.#systemSource = new ReplaySubject();
+        this.system$ = this.#systemSource.asObservable();
+        // cache for resolved visible tags because they are used in lists and therefore should not be re-evaluated all the time
+        this.#visibleTagsCache = {};
+    }
+    #backend;
+    #appCache;
+    #logger;
+    #STORAGE_KEY;
+    #STORAGE_KEY_AUTH_DATA;
+    // cached icons to avoid backend calls (session cache)
+    #iconCache;
+    #resolvedClassificationsCache;
+    #systemSource;
+    // cache for resolved visible tags because they are used in lists and therefore should not be re-evaluated all the time
+    #visibleTagsCache;
+    #permissions;
+    /**
+     * Get all object types
+     * @param withLabels Whether or not to also add the types labels
+     */
+    getObjectTypes(withLabels, situation) {
+        // Filter by user permissions based on situation
+        const objectTypes = this.#filterByPermissions([...this.system.objectTypes, ...this.system.secondaryObjectTypes.map((sot) => this.#sotToGenericType(sot))], situation);
+        return withLabels ? objectTypes.map((t) => ({ ...t, label: this.getLocalizedResource(`${t.id}_label`) })) : objectTypes;
+    }
+    #sotToGenericType(sot) {
+        return {
+            ...sot,
+            isFolder: false,
+            creatable: true,
+            secondaryObjectTypes: [],
+            isSot: true
+        };
+    }
+    /**
+     * Get all secondary object types
+     * @param withLabels Whether or not to also add the types labels
+     */
+    getSecondaryObjectTypes(withLabels, situation) {
+        const sots = this.#filterByPermissions(this.system.secondaryObjectTypes.map((sot) => this.#sotToGenericType(sot)), situation);
+        return ((withLabels ? sots.map((t) => ({ ...t, label: this.getLocalizedResource(`${t.id}_label`) })) : sots)
+            // ignore
+            .filter((t) => t.id !== t.baseId && !t.id.startsWith('system:') && t.id !== 'appClientsystem:leadingType'));
+    }
+    #filterByPermissions(types, situation) {
+        if (!situation)
+            return types;
+        const allowedTypes = situation === 'search' ? this.#permissions.searchableObjectTypes : this.#permissions.createableObjectTypes;
+        return types.filter((t) => allowedTypes.includes(t.id));
+    }
+    /**
+     * Get a particular object type
+     * @param objectTypeId ID of the object type
+     * @param withLabel Whether or not to also add the types label
+     */
+    getObjectType(objectTypeId, withLabel) {
+        let objectType = objectTypeId === SystemType.OBJECT ? this.getBaseType() : this.system.objectTypes.find((ot) => ot.id === objectTypeId);
+        if (objectType && withLabel) {
+            objectType.label = this.getLocalizedResource(`${objectType.id}_label`) || objectTypeId;
+        }
+        if (!objectType) {
+            // no 'real' object type found. Try to find a matching SOT and treat it like a real type
+            // by filling up the missing properties
+            const sot = this.getSecondaryObjectType(objectTypeId, withLabel);
+            if (sot) {
+                objectType = this.#sotToGenericType(sot);
+            }
+        }
+        return objectType;
+    }
+    /**
+     * Get a particular secondary object type
+     * @param objectTypeId ID of the object type
+     * @param withLabel Whether or not to also add the types label
+     */
+    getSecondaryObjectType(objectTypeId, withLabel) {
+        const objectType = this.system.secondaryObjectTypes.find((ot) => ot.id === objectTypeId);
+        if (objectType && withLabel) {
+            objectType.label = this.getLocalizedResource(`${objectType.id}_label`) || objectType.id;
+        }
+        return objectType;
+    }
+    /**
+     * Get the base document type all documents belong to
+     * @param withLabel Whether or not to also add the types label
+     */
+    getBaseDocumentType(withLabel) {
+        return this.getObjectType(SystemType.DOCUMENT, withLabel);
+    }
+    /**
+     * Get the base folder type all folders belong to
+     * @param withLabel Whether or not to also add the types label
+     */
+    getBaseFolderType(withLabel) {
+        return this.getObjectType(SystemType.FOLDER, withLabel);
+    }
+    /**
+     * Get the base object type all dms objects belong to
+     */
+    getBaseType() {
+        const sysFolder = this.getBaseFolderType();
+        const sysDocument = this.getBaseDocumentType();
+        // base type contains only fields that are shared by base document and base folder ...
+        const folderTypeFieldIDs = sysFolder.fields.map((f) => f.id);
+        const baseTypeFields = sysDocument.fields.filter((f) => folderTypeFieldIDs.includes(f.id));
+        return {
+            id: SystemType.OBJECT,
+            creatable: false,
+            isFolder: false,
+            secondaryObjectTypes: [],
+            fields: baseTypeFields
+            // rawFields: baseTypeFields
+        };
+    }
+    /**
+     * Get the resolved object type with all fields ( including fields from related secondary types )
+     */
+    getResolvedType(objectTypeId) {
+        const abstractTypes = Object.values(SystemType);
+        if (!objectTypeId || abstractTypes.includes(objectTypeId)) {
+            const baseType = this.getBaseType();
+            return { id: baseType.id, fields: baseType.fields };
+        }
+        const ot = this.getObjectType(objectTypeId);
+        if (!ot) {
+            const sot = this.getSecondaryObjectType(objectTypeId) || { id: objectTypeId, fields: [] };
+            const baseType = this.getBaseType();
+            return {
+                id: sot.id,
+                fields: [...sot.fields, ...baseType.fields]
+            };
+        }
+        return {
+            id: ot.id,
+            fields: ot.fields
+        };
+    }
+    /**
+     * Get the resolved object tags
+     */
+    getResolvedTags(objectTypeId) {
+        const vTags = this.getVisibleTags(objectTypeId);
+        return Object.keys(vTags).map((k) => ({
+            id: objectTypeId,
+            tagName: k,
+            tagValues: vTags[k],
+            fields: this.getBaseType().fields.filter((f) => f.id === BaseObjectTypeField.TAGS)
+        }));
+    }
+    /**
+     * Get a list of classifications for a given object type including the
+     * classifications of its static secondary object types
+     * @param objectTypeId ID of the object type
+     */
+    getResolvedClassifications(objectTypeId) {
+        return this.#resolvedClassificationsCache[objectTypeId] || this.#resolveClassifications(objectTypeId);
+    }
+    #resolveClassifications(objectTypeId) {
+        let classifications = [];
+        const ot = this.getObjectType(objectTypeId);
+        if (ot) {
+            classifications = ot.classification || [];
+            const staticSOTs = ot.secondaryObjectTypes ? ot.secondaryObjectTypes.filter((sot) => sot.static).map((sot) => sot.id) : [];
+            staticSOTs.forEach((id) => {
+                const sot = this.getSecondaryObjectType(id);
+                classifications = sot?.classification
+                    ? [
+                        ...classifications,
+                        ...sot.classification.filter((c) => {
+                            // also filter classifications that should not be inherited
+                            return c !== ObjectTypeClassification.CREATE_FALSE && c !== ObjectTypeClassification.SEARCH_FALSE;
+                        })
+                    ]
+                    : classifications;
+            });
+            this.#resolvedClassificationsCache[objectTypeId] = classifications;
+        }
+        return classifications;
+    }
+    /**
+     * Visible tags are defined by a classification on the object type (e.g. 'tag[tenkolibri:process,1,2,3]').
+     *
+     * The example will only return tags with the name 'tenkolibri:process'
+     * and values of either 1, 2 or 3. All other tags will be ignored.
+     *
+     * @param objectTypeId ID of the object type to get the visible tags for
+     * @returns object where the property name is the name of the tag and its value are the visible values
+     * for that tag (if values is emoty all values are allowed)
+     */
+    getVisibleTags(objectTypeId) {
+        return this.#visibleTagsCache[objectTypeId] || this.fetchVisibleTags(objectTypeId);
+    }
+    fetchVisibleTags(objectTypeId) {
+        const ot = this.getObjectType(objectTypeId) || this.getSecondaryObjectType(objectTypeId);
+        const tagClassifications = this.getResolvedClassifications(objectTypeId).filter((t) => t.startsWith('tag['));
+        const parentType = ot && ot.id;
+        const to = {};
+        (tagClassifications || []).forEach((tag) => {
+            const m = tag.match(/\[(.*)\]/i)[1].split(',');
+            const tagName = m.splice(0, 1)[0];
+            const tagValues = m.map((v) => parseInt(v.trim()));
+            to[tagName] = tagValues;
+        });
+        this.#visibleTagsCache[objectTypeId] = parentType ? { ...this.getVisibleTags(parentType), ...to } : to;
+        return this.#visibleTagsCache[objectTypeId];
+    }
+    filterVisibleTags(objectTypeId, tagsValue) {
+        if (!tagsValue)
+            return [];
+        const vTags = this.getVisibleTags(objectTypeId);
+        // Tag value looks like this: [tagName: string, state: number, date: Date, traceId: string]
+        return tagsValue.filter((v) => !!vTags[v[0]] && vTags[v[0]].includes(v[1]));
+    }
+    /**
+     * Get the icon for an object type. This will return an SVG as a string.
+     * @param objectTypeId ID of the object type
+     * @param fallback ID of a fallback icon that should be used if the given object type has no icon yet
+     */
+    getObjectTypeIcon(objectTypeId, fallback) {
+        if (this.#iconCache[objectTypeId] && this.#iconCache[objectTypeId].icon) {
+            return of(this.#iconCache[objectTypeId].icon);
+        }
+        else {
+            const iconUri = this.getObjectTypeIconUri(objectTypeId, fallback);
+            return this.#backend.get(iconUri).pipe(tap((icon) => (this.#iconCache[objectTypeId] = { uri: iconUri, icon })));
+        }
+    }
+    /**
+     * Get the URI of an object type icon.
+     * @param objectTypeId ID of the object type
+     * @param fallback ID of a fallback icon that should be used if the given object type has no icon yet
+     */
+    getObjectTypeIconUri(objectTypeId, fallback) {
+        if (this.#iconCache[objectTypeId]) {
+            return this.#iconCache[objectTypeId].uri;
+        }
+        else {
+            const ci = this.#getIconFromClassification(objectTypeId);
+            const fb = this.getFallbackIcon(objectTypeId, fallback);
+            const uri = `/resources/icons/${encodeURIComponent(ci || objectTypeId)}${fb ? `?fallback=${encodeURIComponent(fb)}` : ''}`;
+            this.#iconCache[objectTypeId] = { uri: `${this.#backend.getApiBase(ApiBase.apiWeb)}${uri}` };
+            return this.#iconCache[objectTypeId].uri;
+        }
+    }
+    getFallbackIcon(objectTypeId, fallback) {
+        const ot = this.getObjectType(objectTypeId);
+        if (ot && !fallback) {
+            // add default fallbacks for system:document and system:folder if now other fallback has been provided
+            fallback = ot.isFolder ? 'system:folder' : 'system:document';
+            // if (this.isFloatingObjectType(ot)) {
+            //   // types that do not have no object type assigned to them (primary FSOTs)
+            //   fallback = 'system:dlm';
+            // }
+        }
+        return fallback;
+    }
+    #getIconFromClassification(objectTypeId) {
+        const ce = this.getClassifications(this.getResolvedClassifications(objectTypeId));
+        return ce.has(ObjectTypeClassification.OBJECT_TYPE_ICON) ? ce.get(ObjectTypeClassification.OBJECT_TYPE_ICON).options[0] : null;
+    }
+    getLocalizedResource(key) {
+        return this.system.i18n[key];
+    }
+    getLocalizedLabel(id) {
+        return this.getLocalizedResource(`${id}_label`);
+    }
+    getLocalizedDescription(id) {
+        return this.getLocalizedResource(`${id}_description`);
+    }
+    /**
+     * Determine whether or not the given object type field is a system field
+     * @param field Object type field to be checked
+     */
+    isSystemProperty(field) {
+        return field.id.startsWith('system:');
+    }
+    /**
+     * Fetches the backends system definition and updates system$ Observable.
+     * Subscribe to the system$ observable instead of calling this function, otherwise you'll trigger fetching the
+     * system definition every time.
+     *
+     * @param user The user to load the system definition for
+     */
+    getSystemDefinition(authData) {
+        // TODO: Supposed to return 304 if nothing changes
+        return this.#fetchSystemDefinition(authData);
+        // TODO: remove when 304 is there???
+        // // try to fetch system definition from cache first
+        // return this.appCache.getItem(this.STORAGE_KEY).pipe(
+        //   switchMap(res => {
+        //     if (res) {
+        //       // check if the system definition from the cache is up to date
+        //       this.system = res;
+        //       this.systemSource.next(this.system);
+        //       return of(true);
+        //     } else {
+        //       // nothing cached so far
+        //       return this.fetchSystemDefinition();
+        //     }
+        //   })
+        // );
+    }
+    /**
+     * Actually fetch the system definition from the backend.
+     * @param user User to fetch definition for
+     */
+    #fetchSystemDefinition(authData) {
+        return (authData ? of(authData) : this.#appCache.getItem(this.#STORAGE_KEY_AUTH_DATA)).pipe(switchMap((data) => {
+            this.updateAuthData(data).subscribe();
+            const fetchTasks = [this.#backend.get('/dms/schema/native.json', ApiBase.core), this.#fetchLocalizations()];
+            return forkJoin(fetchTasks);
+        }), catchError((error) => {
+            this.#logger.error('Error fetching recent version of system definition from server.', error);
+            this.#systemSource.error('Error fetching recent version of system definition from server.');
+            return of(null);
+        }), map((data) => {
+            if (data?.length) {
+                this.setSchema(data[0], data[1]);
+            }
+            return !!data;
+        }));
+    }
+    setPermissions(p) {
+        this.#permissions = p;
+    }
+    /**
+     * Create the schema from the servers schema response
+     * @param schemaResponse Response from the backend
+     */
+    setSchema(schemaResponse, localizedResource = {}) {
+        // prepare a quick access object for the fields
+        const propertiesQA = {};
+        const orgTypeFields = [BaseObjectTypeField.MODIFIED_BY, BaseObjectTypeField.CREATED_BY];
+        schemaResponse.propertyDefinition.forEach((p) => {
+            p.classifications = p.classification;
+            // TODO: Remove once schema supports organization classification for base params
+            // map certain fields to organization type (fake it until you make it ;-)
+            if (orgTypeFields.includes(p.id)) {
+                p.classifications = [Classification.STRING_ORGANIZATION];
+            }
+            propertiesQA[p.id] = p;
+        });
+        // prepare a quick access object for object types (including secondary objects)
+        const objectTypesQA = {};
+        schemaResponse.typeFolderDefinition.forEach((ot) => {
+            objectTypesQA[ot.id] = ot;
+        });
+        schemaResponse.typeDocumentDefinition.forEach((ot) => {
+            objectTypesQA[ot.id] = ot;
+        });
+        schemaResponse.typeSecondaryDefinition.forEach((sot) => {
+            objectTypesQA[sot.id] = sot;
+        });
+        const objectTypes = [
+            // folder types
+            ...schemaResponse.typeFolderDefinition.map((fd) => ({
+                id: fd.id,
+                description: fd.description,
+                classification: fd.classification,
+                baseId: fd.baseId,
+                creatable: this.#isCreatable(fd.id),
+                contentStreamAllowed: ContentStreamAllowed.NOT_ALLOWED,
+                isFolder: true,
+                secondaryObjectTypes: fd.secondaryObjectTypeId ? fd.secondaryObjectTypeId.map((t) => ({ id: t.value, static: t.static })) : [],
+                fields: this.#resolveObjectTypeFields(fd, propertiesQA, objectTypesQA)
+                // rawFields: this.resolveObjectTypeFields(fd, propertiesQA, objectTypesQA, true),
+            })),
+            // document types
+            ...schemaResponse.typeDocumentDefinition.map((dd) => ({
+                id: dd.id,
+                description: dd.description,
+                classification: dd.classification,
+                baseId: dd.baseId,
+                creatable: this.#isCreatable(dd.id),
+                contentStreamAllowed: dd.contentStreamAllowed,
+                isFolder: false,
+                secondaryObjectTypes: dd.secondaryObjectTypeId ? dd.secondaryObjectTypeId.map((t) => ({ id: t.value, static: t.static })) : [],
+                fields: this.#resolveObjectTypeFields(dd, propertiesQA, objectTypesQA)
+                // rawFields: this.resolveObjectTypeFields(dd, propertiesQA, objectTypesQA, true),
+            }))
+        ];
+        const secondaryObjectTypes = schemaResponse.typeSecondaryDefinition.map((std) => ({
+            id: std.id,
+            description: std.description,
+            classification: std.classification,
+            contentStreamAllowed: std.contentStreamAllowed,
+            baseId: std.baseId,
+            // TODO: Could a SOT be a folder too?
+            isFolder: false,
+            fields: this.#resolveObjectTypeFields(std, propertiesQA, objectTypesQA)
+        }));
+        this.system = {
+            version: schemaResponse.version,
+            lastModificationDate: schemaResponse.lastModificationDate,
+            objectTypes,
+            secondaryObjectTypes,
+            i18n: localizedResource,
+            allFields: propertiesQA
+        };
+        this.#appCache.setItem(this.#STORAGE_KEY, this.system).subscribe();
+        this.#systemSource.next(this.system);
+    }
+    /**
+     * Resolve all the fields for an object type. This also includes secondary object types and the fields inherited from
+     * the base type (... and of course the base type (and its secondary object types) of the base type and so on)
+     * @param schemaTypeDefinition object type definition from the native schema
+     * @param propertiesQA Quick access object of all properties
+     * @param objectTypesQA Quick access object of all object types
+     * @param raw If set to 'true' only the properties of the object type itself will be returned (without SOTs)
+     */
+    #resolveObjectTypeFields(schemaTypeDefinition, propertiesQA, objectTypesQA) {
+        const objectTypeFieldIDs = schemaTypeDefinition.propertyReference.map((pr) => pr.value);
+        if (schemaTypeDefinition.secondaryObjectTypeId) {
+            schemaTypeDefinition.secondaryObjectTypeId
+                .filter((sot) => sot.static)
+                .map((sot) => sot.value)
+                .forEach((sotID) => objectTypesQA[sotID].propertyReference.forEach((pr) => objectTypeFieldIDs.push(pr.value)));
+        }
+        let fields = objectTypeFieldIDs.map((id) => ({
+            ...propertiesQA[id],
+            _internalType: this.getInternalFormElementType(propertiesQA[id].propertyType, propertiesQA[id].classifications)
+        }));
+        // also resolve properties of the base type
+        if (schemaTypeDefinition.baseId !== schemaTypeDefinition.id && !!objectTypesQA[schemaTypeDefinition.baseId]) {
+            fields = fields.concat(this.#resolveObjectTypeFields(objectTypesQA[schemaTypeDefinition.baseId], propertiesQA, objectTypesQA));
+        }
+        return fields;
+    }
+    #isCreatable(objectTypeId) {
+        return ![SystemType.FOLDER, SystemType.DOCUMENT].includes(objectTypeId);
+    }
+    /**
+     * Fetch a collection of form models.
+     * @param objectTypeIDs Object type IDs to fetch form model for
+     * @param situation Form situation
+     * @returns Object where the object type id is key and the form model is the value
+     */
+    getObjectTypeForms(objectTypeIDs, situation) {
+        return forkJoin(objectTypeIDs.map((o) => this.getObjectTypeForm(o, situation).pipe(catchError((e) => of(null)), map((res) => ({
+            id: o,
+            formModel: res
+        }))))).pipe(map((res) => {
+            const resMap = {};
+            res.filter((r) => this.#formHasElements(r.formModel)).forEach((r) => (resMap[r.id] = r.formModel));
+            return resMap;
+        }));
+    }
+    /**
+     * Get the form model of an object type.
+     *
+     * @param objectTypeId ID of the object type to fetch the form for
+     * @param situation The form situation to be fetched
+     * @returns Form model
+     */
+    getObjectTypeForm(objectTypeId, situation) {
+        return this.#backend.get(Utils.buildUri(`/dms/forms/${objectTypeId}`, { situation }));
+    }
+    /**
+     * Check whether or not the model has at least one form element. Recursive.
+     * @param element Form element to check child elements for
+     */
+    #formHasElements(element) {
+        let hasElement = false;
+        element.elements?.forEach((e) => {
+            if (!['o2mGroup', 'o2mGroupStack'].includes(e.type)) {
+                hasElement = true;
+            }
+            else if (!hasElement) {
+                hasElement = this.#formHasElements(e);
+            }
+        });
+        return hasElement;
+    }
+    /**
+     * Generates an internal type for a given object type field.
+     * Adding this to a form element or object type field enables us to render forms
+     * based on object type fields in a more performant way. Otherwise we would
+     * have to evaluate the conditions for every form element on every digest cycle.
+     * @param type propertyType of the ObjectTypeField
+     * @param classifications classifications of the ObjectTypeField
+     */
+    getInternalFormElementType(type, classifications) {
+        const _classifications = this.getClassifications(classifications || []);
+        if (type === 'string' && _classifications.has(Classification.STRING_REFERENCE)) {
+            return InternalFieldType.STRING_REFERENCE;
+        }
+        else if (type === 'string' && _classifications.has(Classification.STRING_ORGANIZATION)) {
+            return InternalFieldType.STRING_ORGANIZATION;
+        }
+        else if (type === 'string' && _classifications.has(Classification.STRING_ORGANIZATION_SET)) {
+            return InternalFieldType.STRING_ORGANIZATION_SET;
+        }
+        else if (type === 'string' && _classifications.has(Classification.STRING_CATALOG)) {
+            return InternalFieldType.STRING_CATALOG;
+        }
+        else if (type === 'boolean' && _classifications.has(Classification.BOOLEAN_SWITCH)) {
+            return InternalFieldType.BOOLEAN_SWITCH;
+        }
+        else if (type === 'string' &&
+            (_classifications.has(Classification.STRING_CATALOG_DYNAMIC) || _classifications.has(Classification.STRING_CATALOG_CUSTOM))) {
+            return InternalFieldType.STRING_DYNAMIC_CATALOG;
+        }
+        else {
+            // if there are no matching conditions just return the original type
+            return type;
+        }
+    }
+    getObjectTypeField(id) {
+        const f = this.system?.allFields[id];
+        return f ? { ...f, _internalType: this.getInternalFormElementType(f.propertyType, f.classifications) } : undefined;
+    }
+    /**
+     * Extract classifications from object type fields classification
+     * string. This string may contain more than one classification entry.
+     *
+     * Classification is a comma separated string that may contain additional
+     * properties related to on classification entry. Example:
+     *
+     * `id:reference[system:folder], email`
+     *
+     * @param classifications Object type fields classification property (schema)
+     */
+    getClassifications(classifications) {
+        const res = new Map();
+        if (classifications) {
+            classifications.forEach((c) => {
+                const matches = c.match(/^([^\[]*)(\[(.*)\])?$/);
+                if (matches && matches.length) {
+                    res.set(matches[1], {
+                        classification: matches[1],
+                        options: matches[3] ? matches[3].split(',').map((o) => o.trim()) : []
+                    });
+                }
+            });
+        }
+        return res;
+    }
+    toFormElement(field) {
+        return { ...field, label: this.getLocalizedLabel(field.id), name: field.id, type: field.propertyType };
+    }
+    updateAuthData(data) {
+        this.authData = { ...this.authData, ...data };
+        this.#backend.setHeader('Accept-Language', this.authData.language);
+        return this.#appCache.setItem(this.#STORAGE_KEY_AUTH_DATA, this.authData);
+    }
+    updateLocalizations(iso) {
+        return this.updateAuthData({ language: iso }).pipe(switchMap(() => this.#fetchLocalizations()), tap((res) => {
+            this.system.i18n = res;
+            this.#appCache.setItem(this.#STORAGE_KEY, this.system).subscribe();
+            this.#systemSource.next(this.system);
+        }));
+    }
+    #fetchLocalizations() {
+        return this.#backend.get('/resources/text');
+    }
+    fetchResources(id) {
+        return this.#backend
+            .batch([
+            { uri: `/system/resources/${id}`, base: ApiBase.core },
+            { uri: `/admin/resources/${id}`, base: ApiBase.core }
+        ])
+            .pipe(map(([global, tenant]) => ({ global, tenant })));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SystemService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SystemService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SystemService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"system.service.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-core/src/lib/service/system/system.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { forkJoin, Observable, of, ReplaySubject } from 'rxjs';\nimport { catchError, map, switchMap, tap } from 'rxjs/operators';\nimport { Utils } from '../../util/utils';\nimport { ApiBase } from '../backend/api.enum';\nimport { BackendService } from '../backend/backend.service';\nimport { AppCacheService } from '../cache/app-cache.service';\nimport { Logger } from '../logger/logger';\nimport { AuthData } from './../auth/auth.service';\nimport { ObjectTypeFieldInternalType, ObjectTypeFieldType } from './object-form.interface';\nimport { BaseObjectTypeField, Classification, ContentStreamAllowed, InternalFieldType, ObjectTypeClassification, SystemType } from './system.enum';\nimport {\n  ClassificationEntry,\n  GenericObjectType,\n  Localization,\n  ObjectType,\n  ObjectTypeField,\n  ObjectTypePermissions,\n  SchemaResponse,\n  SchemaResponseFieldDefinition,\n  SchemaResponseTypeDefinition,\n  SecondaryObjectType,\n  SystemDefinition\n} from './system.interface';\n\n/**\n * Providing system definitions.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class SystemService {\n  #backend = inject(BackendService);\n  #appCache = inject(AppCacheService);\n  #logger = inject(Logger);\n\n  #STORAGE_KEY = 'yuv.core.system.definition';\n  #STORAGE_KEY_AUTH_DATA = 'yuv.core.auth.data';\n  // cached icons to avoid backend calls (session cache)\n  #iconCache: {\n    [objectTypeId: string]: {\n      uri: string;\n      icon?: string;\n    };\n  } = {};\n  #resolvedClassificationsCache: { [objectTypeId: string]: any } = {};\n\n  system?: SystemDefinition;\n  #systemSource = new ReplaySubject<SystemDefinition>();\n  system$: Observable<SystemDefinition> = this.#systemSource.asObservable();\n\n  // cache for resolved visible tags because they are used in lists and therefore should not be re-evaluated all the time\n  #visibleTagsCache: { [objectId: string]: { [tagName: string]: any[] } } = {};\n  #permissions?: ObjectTypePermissions;\n  authData?: AuthData;\n\n  /**\n   * Get all object types\n   * @param withLabels Whether or not to also add the types labels\n   */\n  getObjectTypes(withLabels?: boolean, situation?: 'search' | 'create'): GenericObjectType[] {\n    // Filter by user permissions based on situation\n    const objectTypes = this.#filterByPermissions(\n      [...this.system!.objectTypes, ...this.system!.secondaryObjectTypes.map((sot) => this.#sotToGenericType(sot))],\n      situation\n    ) as GenericObjectType[];\n    return withLabels ? objectTypes.map((t) => ({ ...t, label: this.getLocalizedResource(`${t.id}_label`) })) : objectTypes;\n  }\n\n  #sotToGenericType(sot: SecondaryObjectType): GenericObjectType {\n    return {\n      ...sot,\n      isFolder: false,\n      creatable: true,\n      secondaryObjectTypes: [],\n      isSot: true\n    };\n  }\n\n  /**\n   * Get all secondary object types\n   * @param withLabels Whether or not to also add the types labels\n   */\n  getSecondaryObjectTypes(withLabels?: boolean, situation?: 'search' | 'create'): SecondaryObjectType[] {\n    const sots = this.#filterByPermissions(\n      this.system!.secondaryObjectTypes.map((sot) => this.#sotToGenericType(sot)),\n      situation\n    ) as SecondaryObjectType[];\n\n    return (\n      (withLabels ? sots.map((t) => ({ ...t, label: this.getLocalizedResource(`${t.id}_label`) })) : sots)\n        // ignore\n        .filter((t) => t.id !== t.baseId && !t.id.startsWith('system:') && t.id !== 'appClientsystem:leadingType')\n    );\n  }\n\n  #filterByPermissions(types: GenericObjectType[], situation?: 'search' | 'create'): GenericObjectType[] {\n    if (!situation) return types;\n    const allowedTypes = situation === 'search' ? this.#permissions!.searchableObjectTypes : this.#permissions!.createableObjectTypes;\n    return types.filter((t) => allowedTypes.includes(t.id));\n  }\n\n  /**\n   * Get a particular object type\n   * @param objectTypeId ID of the object type\n   * @param withLabel Whether or not to also add the types label\n   */\n  getObjectType(objectTypeId: string, withLabel?: boolean): GenericObjectType | undefined {\n    let objectType: GenericObjectType | undefined =\n      objectTypeId === SystemType.OBJECT ? this.getBaseType() : this.system!.objectTypes.find((ot) => ot.id === objectTypeId);\n\n    if (objectType && withLabel) {\n      objectType.label = this.getLocalizedResource(`${objectType.id}_label`) || objectTypeId;\n    }\n\n    if (!objectType) {\n      // no 'real' object type found. Try to find a matching SOT and treat it like a real type\n      // by filling up the missing properties\n      const sot = this.getSecondaryObjectType(objectTypeId, withLabel);\n      if (sot) {\n        objectType = this.#sotToGenericType(sot);\n      }\n    }\n    return objectType;\n  }\n  /**\n   * Get a particular secondary object type\n   * @param objectTypeId ID of the object type\n   * @param withLabel Whether or not to also add the types label\n   */\n  getSecondaryObjectType(objectTypeId: string, withLabel?: boolean): SecondaryObjectType | undefined {\n    const objectType: SecondaryObjectType | undefined = this.system!.secondaryObjectTypes.find((ot) => ot.id === objectTypeId);\n    if (objectType && withLabel) {\n      objectType.label = this.getLocalizedResource(`${objectType.id}_label`) || objectType.id;\n    }\n    return objectType;\n  }\n\n  /**\n   * Get the base document type all documents belong to\n   * @param withLabel Whether or not to also add the types label\n   */\n  getBaseDocumentType(withLabel?: boolean): ObjectType {\n    return this.getObjectType(SystemType.DOCUMENT, withLabel)!;\n  }\n\n  /**\n   * Get the base folder type all folders belong to\n   * @param withLabel Whether or not to also add the types label\n   */\n  getBaseFolderType(withLabel?: boolean): ObjectType {\n    return this.getObjectType(SystemType.FOLDER, withLabel)!;\n  }\n\n  /**\n   * Get the base object type all dms objects belong to\n   */\n  getBaseType(): ObjectType {\n    const sysFolder = this.getBaseFolderType();\n    const sysDocument = this.getBaseDocumentType();\n\n    // base type contains only fields that are shared by base document and base folder ...\n    const folderTypeFieldIDs = sysFolder.fields.map((f) => f.id);\n    const baseTypeFields: ObjectTypeField[] = sysDocument.fields.filter((f) => folderTypeFieldIDs.includes(f.id));\n\n    return {\n      id: SystemType.OBJECT,\n      creatable: false,\n      isFolder: false,\n      secondaryObjectTypes: [],\n      fields: baseTypeFields\n      // rawFields: baseTypeFields\n    };\n  }\n\n  /**\n   * Get the resolved object type with all fields ( including fields from related secondary types )\n   */\n  getResolvedType(objectTypeId?: string): { id: string; fields: ObjectTypeField[] } {\n    const abstractTypes = Object.values(SystemType);\n    if (!objectTypeId || abstractTypes.includes(objectTypeId)) {\n      const baseType = this.getBaseType();\n      return { id: baseType.id, fields: baseType.fields };\n    }\n\n    const ot = this.getObjectType(objectTypeId);\n    if (!ot) {\n      const sot = this.getSecondaryObjectType(objectTypeId) || { id: objectTypeId, fields: [] };\n      const baseType = this.getBaseType();\n      return {\n        id: sot.id,\n        fields: [...sot.fields, ...baseType.fields]\n      };\n    }\n\n    return {\n      id: ot.id,\n      fields: ot.fields\n    };\n  }\n\n  /**\n   * Get the resolved object tags\n   */\n  getResolvedTags(objectTypeId: string): { id: string; tagName: string; tagValues: any; fields: ObjectTypeField[] }[] {\n    const vTags = this.getVisibleTags(objectTypeId);\n    return Object.keys(vTags).map((k) => ({\n      id: objectTypeId,\n      tagName: k,\n      tagValues: vTags[k],\n      fields: this.getBaseType().fields.filter((f) => f.id === BaseObjectTypeField.TAGS)\n    }));\n  }\n\n  /**\n   * Get a list of classifications for a given object type including the\n   * classifications of its static secondary object types\n   * @param objectTypeId ID of the object type\n   */\n  getResolvedClassifications(objectTypeId: string): string[] {\n    return this.#resolvedClassificationsCache[objectTypeId] || this.#resolveClassifications(objectTypeId);\n  }\n\n  #resolveClassifications(objectTypeId: string): string[] {\n    let classifications: string[] = [];\n    const ot = this.getObjectType(objectTypeId);\n    if (ot) {\n      classifications = ot.classification || [];\n      const staticSOTs: string[] = ot.secondaryObjectTypes ? ot.secondaryObjectTypes.filter((sot) => sot.static).map((sot) => sot.id) : [];\n      staticSOTs.forEach((id) => {\n        const sot = this.getSecondaryObjectType(id);\n        classifications = sot?.classification\n          ? [\n              ...classifications,\n              ...sot.classification.filter((c) => {\n                // also filter classifications that should not be inherited\n                return c !== ObjectTypeClassification.CREATE_FALSE && c !== ObjectTypeClassification.SEARCH_FALSE;\n              })\n            ]\n          : classifications;\n      });\n      this.#resolvedClassificationsCache[objectTypeId] = classifications;\n    }\n    return classifications;\n  }\n\n  /**\n   * Visible tags are defined by a classification on the object type (e.g. 'tag[tenkolibri:process,1,2,3]').\n   *\n   * The example will only return tags with the name 'tenkolibri:process'\n   * and values of either 1, 2 or 3. All other tags will be ignored.\n   *\n   * @param objectTypeId ID of the object type to get the visible tags for\n   * @returns object where the property name is the name of the tag and its value are the visible values\n   * for that tag (if values is emoty all values are allowed)\n   */\n  getVisibleTags(objectTypeId: string): { [tagName: string]: any[] } {\n    return this.#visibleTagsCache[objectTypeId] || this.fetchVisibleTags(objectTypeId);\n  }\n\n  private fetchVisibleTags(objectTypeId: string): { [tagName: string]: any[] } {\n    const ot = this.getObjectType(objectTypeId) || this.getSecondaryObjectType(objectTypeId);\n    const tagClassifications = this.getResolvedClassifications(objectTypeId).filter((t) => t.startsWith('tag['));\n    const parentType = ot && (ot as ObjectType).id;\n\n    const to: { [tagName: string]: any[] } = {};\n    (tagClassifications || []).forEach((tag) => {\n      const m = tag.match(/\\[(.*)\\]/i)![1].split(',');\n      const tagName = m.splice(0, 1)[0];\n      const tagValues = m.map((v) => parseInt(v.trim()));\n      to[tagName] = tagValues;\n    });\n\n    this.#visibleTagsCache[objectTypeId] = parentType ? { ...this.getVisibleTags(parentType), ...to } : to;\n    return this.#visibleTagsCache[objectTypeId];\n  }\n\n  filterVisibleTags(objectTypeId: string, tagsValue: Array<Array<any>>): Array<Array<any>> {\n    if (!tagsValue) return [];\n    const vTags: { [tagName: string]: any[] } = this.getVisibleTags(objectTypeId);\n    // Tag value looks like this: [tagName: string, state: number, date: Date, traceId: string]\n    return tagsValue.filter((v: any[]) => !!vTags[v[0]] && vTags[v[0]].includes(v[1]));\n  }\n\n  /**\n   * Get the icon for an object type. This will return an SVG as a string.\n   * @param objectTypeId ID of the object type\n   * @param fallback ID of a fallback icon that should be used if the given object type has no icon yet\n   */\n  getObjectTypeIcon(objectTypeId: string, fallback?: string): Observable<string> {\n    if (this.#iconCache[objectTypeId] && this.#iconCache[objectTypeId].icon) {\n      return of(this.#iconCache[objectTypeId].icon!);\n    } else {\n      const iconUri = this.getObjectTypeIconUri(objectTypeId, fallback);\n      return this.#backend.get(iconUri).pipe(tap((icon) => (this.#iconCache[objectTypeId] = { uri: iconUri, icon })));\n    }\n  }\n\n  /**\n   * Get the URI of an object type icon.\n   * @param objectTypeId ID of the object type\n   * @param fallback ID of a fallback icon that should be used if the given object type has no icon yet\n   */\n  getObjectTypeIconUri(objectTypeId: string, fallback?: string): string {\n    if (this.#iconCache[objectTypeId]) {\n      return this.#iconCache[objectTypeId].uri;\n    } else {\n      const ci = this.#getIconFromClassification(objectTypeId);\n      const fb = this.getFallbackIcon(objectTypeId, fallback);\n      const uri = `/resources/icons/${encodeURIComponent(ci || objectTypeId)}${fb ? `?fallback=${encodeURIComponent(fb)}` : ''}`;\n      this.#iconCache[objectTypeId] = { uri: `${this.#backend.getApiBase(ApiBase.apiWeb)}${uri}` };\n      return this.#iconCache[objectTypeId].uri;\n    }\n  }\n\n  private getFallbackIcon(objectTypeId: string, fallback?: string): string {\n    const ot = this.getObjectType(objectTypeId);\n    if (ot && !fallback) {\n      // add default fallbacks for system:document and system:folder if now other fallback has been provided\n      fallback = ot.isFolder ? 'system:folder' : 'system:document';\n      // if (this.isFloatingObjectType(ot)) {\n      //   // types that do not have no object type assigned to them (primary FSOTs)\n      //   fallback = 'system:dlm';\n      // }\n    }\n    return fallback!;\n  }\n\n  #getIconFromClassification(objectTypeId: string) {\n    const ce: Map<string, ClassificationEntry> = this.getClassifications(this.getResolvedClassifications(objectTypeId));\n    return ce.has(ObjectTypeClassification.OBJECT_TYPE_ICON) ? ce.get(ObjectTypeClassification.OBJECT_TYPE_ICON)!.options[0] : null;\n  }\n\n  getLocalizedResource(key: string): string {\n    return this.system!.i18n[key];\n  }\n\n  getLocalizedLabel(id: string) {\n    return this.getLocalizedResource(`${id}_label`);\n  }\n\n  getLocalizedDescription(id: string) {\n    return this.getLocalizedResource(`${id}_description`);\n  }\n\n  /**\n   * Determine whether or not the given object type field is a system field\n   * @param field Object type field to be checked\n   */\n  isSystemProperty(field: ObjectTypeField): boolean {\n    return field.id.startsWith('system:');\n  }\n\n  /**\n   * Fetches the backends system definition and updates system$ Observable.\n   * Subscribe to the system$ observable instead of calling this function, otherwise you'll trigger fetching the\n   * system definition every time.\n   *\n   * @param user The user to load the system definition for\n   */\n  getSystemDefinition(authData?: AuthData): Observable<boolean> {\n    // TODO: Supposed to return 304 if nothing changes\n    return this.#fetchSystemDefinition(authData);\n\n    // TODO: remove when 304 is there???\n    // // try to fetch system definition from cache first\n    // return this.appCache.getItem(this.STORAGE_KEY).pipe(\n    //   switchMap(res => {\n    //     if (res) {\n    //       // check if the system definition from the cache is up to date\n    //       this.system = res;\n    //       this.systemSource.next(this.system);\n    //       return of(true);\n    //     } else {\n    //       // nothing cached so far\n    //       return this.fetchSystemDefinition();\n    //     }\n    //   })\n    // );\n  }\n\n  /**\n   * Actually fetch the system definition from the backend.\n   * @param user User to fetch definition for\n   */\n  #fetchSystemDefinition(authData?: AuthData): Observable<boolean> {\n    return (authData ? of(authData) : this.#appCache.getItem(this.#STORAGE_KEY_AUTH_DATA)).pipe(\n      switchMap((data: AuthData) => {\n        this.updateAuthData(data).subscribe();\n        const fetchTasks = [this.#backend.get('/dms/schema/native.json', ApiBase.core), this.#fetchLocalizations()];\n        return forkJoin(fetchTasks);\n      }),\n      catchError((error) => {\n        this.#logger.error('Error fetching recent version of system definition from server.', error);\n        this.#systemSource.error('Error fetching recent version of system definition from server.');\n        return of(null);\n      }),\n      map((data) => {\n        if (data?.length) {\n          this.setSchema(data[0], data[1]);\n        }\n        return !!data;\n      })\n    );\n  }\n\n  setPermissions(p: ObjectTypePermissions) {\n    this.#permissions = p;\n  }\n\n  /**\n   * Create the schema from the servers schema response\n   * @param schemaResponse Response from the backend\n   */\n  setSchema(schemaResponse: SchemaResponse, localizedResource: Localization = {}) {\n    // prepare a quick access object for the fields\n    const propertiesQA: Record<string, SchemaResponseFieldDefinition> = {};\n    const orgTypeFields = [BaseObjectTypeField.MODIFIED_BY, BaseObjectTypeField.CREATED_BY];\n    schemaResponse.propertyDefinition.forEach((p: any) => {\n      p.classifications = p.classification;\n      // TODO: Remove once schema supports organization classification for base params\n      // map certain fields to organization type (fake it until you make it ;-)\n      if (orgTypeFields.includes(p.id)) {\n        p.classifications = [Classification.STRING_ORGANIZATION];\n      }\n      propertiesQA[p.id] = p;\n    });\n    // prepare a quick access object for object types (including secondary objects)\n    const objectTypesQA: { [id: string]: SchemaResponseTypeDefinition } = {};\n    schemaResponse.typeFolderDefinition.forEach((ot: any) => {\n      objectTypesQA[ot.id] = ot;\n    });\n    schemaResponse.typeDocumentDefinition.forEach((ot: any) => {\n      objectTypesQA[ot.id] = ot;\n    });\n    schemaResponse.typeSecondaryDefinition.forEach((sot: any) => {\n      objectTypesQA[sot.id] = sot;\n    });\n\n    const objectTypes: ObjectType[] = [\n      // folder types\n      ...schemaResponse.typeFolderDefinition.map((fd) => ({\n        id: fd.id,\n        description: fd.description,\n        classification: fd.classification,\n        baseId: fd.baseId,\n        creatable: this.#isCreatable(fd.id),\n        contentStreamAllowed: ContentStreamAllowed.NOT_ALLOWED,\n        isFolder: true,\n        secondaryObjectTypes: fd.secondaryObjectTypeId ? fd.secondaryObjectTypeId.map((t) => ({ id: t.value, static: t.static })) : [],\n        fields: this.#resolveObjectTypeFields(fd, propertiesQA, objectTypesQA)\n        // rawFields: this.resolveObjectTypeFields(fd, propertiesQA, objectTypesQA, true),\n      })),\n      // document types\n      ...schemaResponse.typeDocumentDefinition.map((dd) => ({\n        id: dd.id,\n        description: dd.description,\n        classification: dd.classification,\n        baseId: dd.baseId,\n        creatable: this.#isCreatable(dd.id),\n        contentStreamAllowed: dd.contentStreamAllowed,\n        isFolder: false,\n        secondaryObjectTypes: dd.secondaryObjectTypeId ? dd.secondaryObjectTypeId.map((t) => ({ id: t.value, static: t.static })) : [],\n        fields: this.#resolveObjectTypeFields(dd, propertiesQA, objectTypesQA)\n        // rawFields: this.resolveObjectTypeFields(dd, propertiesQA, objectTypesQA, true),\n      }))\n    ];\n\n    const secondaryObjectTypes: SecondaryObjectType[] = schemaResponse.typeSecondaryDefinition.map((std) => ({\n      id: std.id,\n      description: std.description,\n      classification: std.classification,\n      contentStreamAllowed: std.contentStreamAllowed,\n      baseId: std.baseId,\n      // TODO: Could a SOT be a folder too?\n      isFolder: false,\n      fields: this.#resolveObjectTypeFields(std, propertiesQA, objectTypesQA)\n    }));\n\n    this.system = {\n      version: schemaResponse.version,\n      lastModificationDate: schemaResponse.lastModificationDate,\n      objectTypes,\n      secondaryObjectTypes,\n      i18n: localizedResource,\n      allFields: propertiesQA\n    };\n    this.#appCache.setItem(this.#STORAGE_KEY, this.system).subscribe();\n    this.#systemSource.next(this.system);\n  }\n\n  /**\n   * Resolve all the fields for an object type. This also includes secondary object types and the fields inherited from\n   * the base type (... and of course the base type (and its secondary object types) of the base type and so on)\n   * @param schemaTypeDefinition object type definition from the native schema\n   * @param propertiesQA Quick access object of all properties\n   * @param objectTypesQA Quick access object of all object types\n   * @param raw If set to 'true' only the properties of the object type itself will be returned (without SOTs)\n   */\n  #resolveObjectTypeFields(\n    schemaTypeDefinition: SchemaResponseTypeDefinition,\n    propertiesQA: { [id: string]: SchemaResponseFieldDefinition },\n    objectTypesQA: { [id: string]: SchemaResponseTypeDefinition }\n  ): ObjectTypeField[] {\n    const objectTypeFieldIDs = schemaTypeDefinition.propertyReference.map((pr) => pr.value);\n    if (schemaTypeDefinition.secondaryObjectTypeId) {\n      schemaTypeDefinition.secondaryObjectTypeId\n        .filter((sot) => sot.static)\n        .map((sot) => sot.value)\n        .forEach((sotID) => objectTypesQA[sotID].propertyReference.forEach((pr: { value: string }) => objectTypeFieldIDs.push(pr.value)));\n    }\n\n    let fields: ObjectTypeField[] = objectTypeFieldIDs.map((id) => ({\n      ...propertiesQA[id],\n      _internalType: this.getInternalFormElementType(propertiesQA[id].propertyType, propertiesQA[id].classifications)\n    }));\n\n    // also resolve properties of the base type\n    if (schemaTypeDefinition.baseId !== schemaTypeDefinition.id && !!objectTypesQA[schemaTypeDefinition.baseId]) {\n      fields = fields.concat(this.#resolveObjectTypeFields(objectTypesQA[schemaTypeDefinition.baseId], propertiesQA, objectTypesQA));\n    }\n    return fields;\n  }\n\n  #isCreatable(objectTypeId: string) {\n    return ![SystemType.FOLDER, SystemType.DOCUMENT].includes(objectTypeId);\n  }\n\n  /**\n   * Fetch a collection of form models.\n   * @param objectTypeIDs Object type IDs to fetch form model for\n   * @param situation Form situation\n   * @returns Object where the object type id is key and the form model is the value\n   */\n  getObjectTypeForms(objectTypeIDs: string[], situation: string): Observable<Record<string, any>> {\n    return forkJoin(\n      objectTypeIDs.map((o) =>\n        this.getObjectTypeForm(o, situation).pipe(\n          catchError((e) => of(null)),\n          map((res) => ({\n            id: o,\n            formModel: res\n          }))\n        )\n      )\n    ).pipe(\n      map((res) => {\n        const resMap: Record<string, any> = {};\n        res.filter((r) => this.#formHasElements(r.formModel)).forEach((r: any) => (resMap[r.id] = r.formModel));\n        return resMap;\n      })\n    );\n  }\n\n  /**\n   * Get the form model of an object type.\n   *\n   * @param objectTypeId ID of the object type to fetch the form for\n   * @param situation The form situation to be fetched\n   * @returns Form model\n   */\n  getObjectTypeForm(objectTypeId: string, situation: string): Observable<any> {\n    return this.#backend.get(Utils.buildUri(`/dms/forms/${objectTypeId}`, { situation }));\n  }\n\n  /**\n   * Check whether or not the model has at least one form element. Recursive.\n   * @param element Form element to check child elements for\n   */\n  #formHasElements(element: any): boolean {\n    let hasElement = false;\n    element.elements?.forEach((e: any) => {\n      if (!['o2mGroup', 'o2mGroupStack'].includes(e.type)) {\n        hasElement = true;\n      } else if (!hasElement) {\n        hasElement = this.#formHasElements(e);\n      }\n    });\n    return hasElement;\n  }\n\n  /**\n   * Generates an internal type for a given object type field.\n   * Adding this to a form element or object type field enables us to render forms\n   * based on object type fields in a more performant way. Otherwise we would\n   * have to evaluate the conditions for every form element on every digest cycle.\n   * @param type propertyType of the ObjectTypeField\n   * @param classifications classifications of the ObjectTypeField\n   */\n  getInternalFormElementType(type: string, classifications?: string[]): ObjectTypeFieldInternalType {\n    const _classifications = this.getClassifications(classifications || []);\n\n    if (type === 'string' && _classifications.has(Classification.STRING_REFERENCE)) {\n      return InternalFieldType.STRING_REFERENCE;\n    } else if (type === 'string' && _classifications.has(Classification.STRING_ORGANIZATION)) {\n      return InternalFieldType.STRING_ORGANIZATION;\n    } else if (type === 'string' && _classifications.has(Classification.STRING_ORGANIZATION_SET)) {\n      return InternalFieldType.STRING_ORGANIZATION_SET;\n    } else if (type === 'string' && _classifications.has(Classification.STRING_CATALOG)) {\n      return InternalFieldType.STRING_CATALOG;\n    } else if (type === 'boolean' && _classifications.has(Classification.BOOLEAN_SWITCH)) {\n      return InternalFieldType.BOOLEAN_SWITCH;\n    } else if (\n      type === 'string' &&\n      (_classifications.has(Classification.STRING_CATALOG_DYNAMIC) || _classifications.has(Classification.STRING_CATALOG_CUSTOM))\n    ) {\n      return InternalFieldType.STRING_DYNAMIC_CATALOG;\n    } else {\n      // if there are no matching conditions just return the original type\n      return type as ObjectTypeFieldType;\n    }\n  }\n\n  getObjectTypeField(id: string): ObjectTypeField | undefined {\n    const f = this.system?.allFields[id];\n    return f ? { ...f, _internalType: this.getInternalFormElementType(f.propertyType, f.classifications) } : undefined;\n  }\n\n  /**\n   * Extract classifications from object type fields classification\n   * string. This string may contain more than one classification entry.\n   *\n   * Classification is a comma separated string that may contain additional\n   * properties related to on classification entry. Example:\n   *\n   * `id:reference[system:folder], email`\n   *\n   * @param classifications Object type fields classification property (schema)\n   */\n  getClassifications(classifications: string[]): Map<string, ClassificationEntry> {\n    const res = new Map<string, ClassificationEntry>();\n    if (classifications) {\n      classifications.forEach((c) => {\n        const matches: RegExpMatchArray | null = c.match(/^([^\\[]*)(\\[(.*)\\])?$/);\n        if (matches && matches.length) {\n          res.set(matches[1], {\n            classification: matches[1],\n            options: matches[3] ? matches[3].split(',').map((o) => o.trim()) : []\n          });\n        }\n      });\n    }\n    return res;\n  }\n\n  toFormElement(field: ObjectTypeField): any {\n    return { ...field, label: this.getLocalizedLabel(field.id), name: field.id, type: field.propertyType };\n  }\n\n  updateAuthData(data: Partial<AuthData>) {\n    this.authData = { ...this.authData!, ...data };\n    this.#backend.setHeader('Accept-Language', this.authData.language);\n    return this.#appCache.setItem(this.#STORAGE_KEY_AUTH_DATA, this.authData);\n  }\n\n  updateLocalizations(iso: string): Observable<any> {\n    return this.updateAuthData({ language: iso }).pipe(\n      switchMap(() => this.#fetchLocalizations()),\n      tap((res) => {\n        this.system!.i18n = res;\n        this.#appCache.setItem(this.#STORAGE_KEY, this.system).subscribe();\n        this.#systemSource.next(this.system!);\n      })\n    );\n  }\n\n  #fetchLocalizations(): Observable<Localization> {\n    return this.#backend.get('/resources/text');\n  }\n\n  fetchResources(id: string): Observable<{ global: any; tenant: any }> {\n    return this.#backend\n      .batch([\n        { uri: `/system/resources/${id}`, base: ApiBase.core },\n        { uri: `/admin/resources/${id}`, base: ApiBase.core }\n      ])\n      .pipe(map(([global, tenant]) => ({ global, tenant })));\n  }\n}\n"]}