@netgrif/components-core 6.0.1

package/esm5/lib/task-content/services/field-converter.service.js

@@ -0,0 +1,350 @@
+import { Injectable } from '@angular/core';
+import { BooleanField } from '../../data-fields/boolean-field/models/boolean-field';
+import { TextField, TextFieldView } from '../../data-fields/text-field/models/text-field';
+import { NumberField } from '../../data-fields/number-field/models/number-field';
+import { EnumerationField, EnumerationFieldView } from '../../data-fields/enumeration-field/models/enumeration-field';
+import { MultichoiceField, MultichoiceFieldView } from '../../data-fields/multichoice-field/models/multichoice-field';
+import { DateField } from '../../data-fields/date-field/models/date-field';
+import { DateTimeField } from '../../data-fields/date-time-field/models/date-time-field';
+import { UserField } from '../../data-fields/user-field/models/user-field';
+import { ButtonField, ButtonFieldView } from '../../data-fields/button-field/models/button-field';
+import { FileField } from '../../data-fields/file-field/models/file-field';
+import moment from 'moment';
+import { UserValue } from '../../data-fields/user-field/models/user-value';
+import { FieldTypeResource } from '../model/field-type-resource';
+import { FileListField } from '../../data-fields/file-list-field/models/file-list-field';
+import { TextAreaField } from '../../data-fields/text-field/models/text-area-field';
+import { TaskRefField } from '../../data-fields/task-ref-field/model/task-ref-field';
+import { DynamicEnumerationField } from '../../data-fields/enumeration-field/models/dynamic-enumeration-field';
+import { FilterField } from '../../data-fields/filter-field/models/filter-field';
+import { I18nField } from '../../data-fields/i18n-field/models/i18n-field';
+import * as i0 from "@angular/core";
+var FieldConverterService = /** @class */ (function () {
+    function FieldConverterService() {
+    }
+    FieldConverterService.prototype.toClass = function (item) {
+        var _a, _b;
+        switch (item.type) {
+            case FieldTypeResource.BOOLEAN:
+                return new BooleanField(item.stringId, item.name, item.value, item.behavior, item.placeholder, item.description, item.layout, item.validations, item.component, item.parentTaskId);
+            case FieldTypeResource.TEXT:
+                /*@deprecated in 4.3.0*/
+                var type = TextFieldView.DEFAULT;
+                if (item.subType !== undefined && item.subType === 'area') {
+                    type = TextFieldView.TEXTAREA;
+                }
+                if (item.view !== undefined && item.view.value !== undefined && item.view.value === 'editor') {
+                    type = TextFieldView.RICHTEXTAREA;
+                    return new TextAreaField(item.stringId, item.name, item.value, item.behavior, item.placeholder, item.description, item.layout, item.validations, type);
+                }
+                else if (item.view !== undefined && item.view.value !== undefined && item.view.value === 'area') {
+                    type = TextFieldView.TEXTAREA;
+                }
+                else if (item.view !== undefined && item.view.value !== undefined && item.view.value === 'htmlEditor') {
+                    type = TextFieldView.HTMLTEXTAREA;
+                    return new TextAreaField(item.stringId, item.name, item.value, item.behavior, item.placeholder, item.description, item.layout, item.validations, type);
+                }
+                if (item.component !== undefined && item.component.name !== undefined && (item.component.name === 'editor' ||
+                    item.component.name === 'htmltextarea')) {
+                    return new TextAreaField(item.stringId, item.name, this.resolveTextValue(item, item.value), item.behavior, item.placeholder, item.description, item.layout, item.validations, type, item.component, item.parentTaskId);
+                }
+                return new TextField(item.stringId, item.name, this.resolveTextValue(item, item.value), item.behavior, item.placeholder, item.description, item.layout, item.validations, type, item.component, item.parentTaskId);
+            case FieldTypeResource.NUMBER:
+                return new NumberField(item.stringId, item.name, item.value, item.behavior, item.validations, item.placeholder, item.description, item.layout, item.formatFilter, this.resolveNumberComponent(item), item.parentTaskId);
+            case FieldTypeResource.ENUMERATION:
+            case FieldTypeResource.ENUMERATION_MAP:
+                return this.resolveEnumField(item);
+            case FieldTypeResource.MULTICHOICE:
+                return new MultichoiceField(item.stringId, item.name, item.value, this.resolveMultichoiceChoices(item), item.behavior, item.placeholder, item.description, item.layout, this.resolveMultichoiceViewType(item), item.type, item.validations, item.component, item.parentTaskId);
+            case FieldTypeResource.MULTICHOICE_MAP:
+                return new MultichoiceField(item.stringId, item.name, item.value, this.resolveMultichoiceOptions(item), item.behavior, item.placeholder, item.description, item.layout, this.resolveMultichoiceViewType(item), item.type, item.validations, item.component, item.parentTaskId);
+            case FieldTypeResource.DATE:
+                var date = void 0;
+                if (item.value) {
+                    date = moment(new Date(item.value[0], item.value[1] - 1, item.value[2]));
+                }
+                return new DateField(item.stringId, item.name, date, item.behavior, item.placeholder, item.description, item.layout, item.validations, item.component, item.parentTaskId);
+            case FieldTypeResource.DATE_TIME:
+                var dateTime = void 0;
+                if (item.value) {
+                    dateTime = moment(new Date(item.value[0], item.value[1] - 1, item.value[2], item.value[3], item.value[4]));
+                }
+                return new DateTimeField(item.stringId, item.name, dateTime, item.behavior, item.placeholder, item.description, item.layout, item.validations, item.component, item.parentTaskId);
+            case FieldTypeResource.USER:
+                var user = void 0;
+                if (item.value) {
+                    user = new UserValue(item.value.id, item.value.name, item.value.surname, item.value.email);
+                }
+                return new UserField(item.stringId, item.name, item.behavior, user, item.roles, item.placeholder, item.description, item.layout, item.validations, item.component, item.parentTaskId);
+            case FieldTypeResource.BUTTON:
+                /*@deprecated in 4.3.0*/
+                var typeBtn = this.resolveButtonView(item);
+                return new ButtonField(item.stringId, item.name, item.behavior, item.value, item.placeholder, item.description, item.layout, typeBtn, item.validations, item.component, item.parentTaskId);
+            case FieldTypeResource.FILE:
+                return new FileField(item.stringId, item.name, item.behavior, item.value ? item.value : {}, item.placeholder, item.description, item.layout, null, null, item.validations, item.component, item.parentTaskId);
+            case FieldTypeResource.FILE_LIST:
+                return new FileListField(item.stringId, item.name, item.behavior, item.value ? item.value : {}, item.placeholder, item.description, item.layout, item.validations, null, null, item.component, item.parentTaskId);
+            case FieldTypeResource.TASK_REF:
+                return new TaskRefField(item.stringId, item.name, item.value ? item.value : [], item.behavior, item.placeholder, item.description, item.layout, item.validations, item.component, item.parentTaskId);
+            case FieldTypeResource.FILTER:
+                return new FilterField(item.stringId, item.name, (_a = item.value) !== null && _a !== void 0 ? _a : '', item.filterMetadata, item.allowedNets, item.behavior, item.placeholder, item.description, item.layout, item.validations, item.component, item.parentTaskId);
+            case FieldTypeResource.I18N:
+                return new I18nField(item.stringId, item.name, (_b = item.value) !== null && _b !== void 0 ? _b : { defaultValue: '' }, item.behavior, item.placeholder, item.description, item.layout, item.validations, item.component);
+        }
+    };
+    FieldConverterService.prototype.resolveType = function (item) {
+        if (item instanceof BooleanField) {
+            return FieldTypeResource.BOOLEAN;
+        }
+        else if (item instanceof ButtonField) {
+            return FieldTypeResource.BUTTON;
+        }
+        else if (item instanceof TextField) {
+            return FieldTypeResource.TEXT;
+        }
+        else if (item instanceof NumberField) {
+            return FieldTypeResource.NUMBER;
+        }
+        else if (item instanceof DateField) {
+            return FieldTypeResource.DATE;
+        }
+        else if (item instanceof DateTimeField) {
+            return FieldTypeResource.DATE_TIME;
+        }
+        else if (item instanceof FileField) {
+            return FieldTypeResource.FILE;
+        }
+        else if (item instanceof FileListField) {
+            return FieldTypeResource.FILE_LIST;
+        }
+        else if (item instanceof UserField) {
+            return FieldTypeResource.USER;
+        }
+        else if (item instanceof TaskRefField) {
+            return FieldTypeResource.TASK_REF;
+        }
+        else if (item instanceof EnumerationField || item instanceof MultichoiceField) {
+            return item.fieldType;
+        }
+        else if (item instanceof FilterField) {
+            return FieldTypeResource.FILTER;
+        }
+        else if (item instanceof I18nField) {
+            return FieldTypeResource.I18N;
+        }
+    };
+    /*@deprecated in 4.3.0*/
+    FieldConverterService.prototype.resolveButtonView = function (item) {
+        if (item.view !== undefined && item.view.value !== undefined) {
+            switch (item.view.value) {
+                case ButtonFieldView.STROKED:
+                    return ButtonFieldView.STROKED;
+                case ButtonFieldView.RAISED:
+                    return ButtonFieldView.RAISED;
+                case ButtonFieldView.FAB:
+                    return ButtonFieldView.FAB;
+                case ButtonFieldView.FLAT:
+                    return ButtonFieldView.FLAT;
+                case ButtonFieldView.ICON:
+                    return ButtonFieldView.ICON;
+                case ButtonFieldView.MINIFAB:
+                    return ButtonFieldView.MINIFAB;
+                default:
+                    return ButtonFieldView.STANDARD;
+            }
+        }
+        else if (item instanceof ButtonField) {
+            return ButtonFieldView.STANDARD;
+        }
+    };
+    FieldConverterService.prototype.formatValueForBackend = function (field, value) {
+        if (this.resolveType(field) === FieldTypeResource.TEXT && value === null) {
+            return null;
+        }
+        if (this.resolveType(field) === FieldTypeResource.TEXT && field.component && field.component.name === 'password') {
+            return btoa(value);
+        }
+        if (value === undefined || value === null) {
+            return;
+        }
+        if (this.resolveType(field) === FieldTypeResource.DATE) {
+            if (moment.isMoment(value)) {
+                return value.format('YYYY-MM-DD');
+            }
+        }
+        if (this.resolveType(field) === FieldTypeResource.USER) {
+            return value.id;
+        }
+        if (this.resolveType(field) === FieldTypeResource.DATE_TIME) {
+            if (moment.isMoment(value)) {
+                return value.format('DD.MM.YYYY HH:mm:ss');
+            }
+        }
+        return value;
+    };
+    FieldConverterService.prototype.resolveNumberComponent = function (numberField) {
+        var numberComponent = { name: 'default', properties: undefined };
+        if (numberField.component !== undefined) {
+            numberComponent = {
+                name: numberField.component.name,
+                properties: numberField.component.properties
+            };
+        }
+        return numberComponent;
+    };
+    /**
+     * Resolves `enumeration` and `eunumeration_map` fields into their appropriate class instances
+     * @param enumField enumeration field resource
+     */
+    FieldConverterService.prototype.resolveEnumField = function (enumField) {
+        var options = enumField.type === FieldTypeResource.ENUMERATION
+            ? this.resolveEnumChoices(enumField)
+            : this.resolveEnumOptions(enumField);
+        if (enumField.component && enumField.component.name === 'autocomplete_dynamic') {
+            return new DynamicEnumerationField(enumField.stringId, enumField.name, enumField.value, options, enumField.behavior, enumField.placeholder, enumField.description, enumField.layout, this.resolveEnumViewType(enumField), enumField.type, enumField.validations, enumField.component, enumField.parentTaskId);
+        }
+        else {
+            return new EnumerationField(enumField.stringId, enumField.name, enumField.value, options, enumField.behavior, enumField.placeholder, enumField.description, enumField.layout, this.resolveEnumViewType(enumField), enumField.type, enumField.validations, enumField.component, enumField.parentTaskId);
+        }
+    };
+    /**
+     * @param enumField enumeration field resource object who's view type we want to resolve
+     * @returns the view type defined in the field object, or default if none, or invalid type is defined
+     * @deprecated in 4.3.0
+     */
+    FieldConverterService.prototype.resolveEnumViewType = function (enumField) {
+        var typeEnum = EnumerationFieldView.DEFAULT;
+        if (enumField.view && enumField.view.value !== undefined) {
+            if (enumField.view.value === 'list') {
+                typeEnum = EnumerationFieldView.LIST;
+            }
+            else if (enumField.view.value === 'autocomplete') {
+                typeEnum = EnumerationFieldView.AUTOCOMPLETE;
+            }
+            else if (enumField.view.value === 'stepper') {
+                typeEnum = EnumerationFieldView.STEPPER;
+            }
+        }
+        return typeEnum;
+    };
+    /**
+     * This function is used to parse enumeration options from the `choices` attribute
+     * @param enumField enumeration field resource object who's choices we want to resolve
+     * @returns the options for the enumeration field
+     */
+    FieldConverterService.prototype.resolveEnumChoices = function (enumField) {
+        var enumChoices = [];
+        if (enumField.choices instanceof Array) {
+            enumField.choices.forEach(function (it) {
+                enumChoices.push({ key: it, value: it });
+            });
+        }
+        else {
+            Object.keys(enumField.choices).forEach(function (key) {
+                enumChoices.push({ key: key, value: enumField.choices[key] });
+            });
+        }
+        return enumChoices;
+    };
+    /**
+     * This function is used to parse enumeration options from the `options` attribute
+     * @param enumField enumeration field resource object who's options we want to resolve
+     * @returns the options for the enumeration field
+     */
+    FieldConverterService.prototype.resolveEnumOptions = function (enumField) {
+        return Object.entries(enumField.options).map(function (entry) { return ({ key: entry[0], value: entry[1] }); });
+    };
+    /**
+     * @param multiField multichoice field resource object who's view type we want to resolve
+     * @returns the view type defined in the field object, or default if none, or invalid type is defined
+     * @deprecated in 4.3.0
+     */
+    FieldConverterService.prototype.resolveMultichoiceViewType = function (multiField) {
+        var typeMulti = MultichoiceFieldView.DEFAULT;
+        if (multiField.view && multiField.view.value !== undefined) {
+            if (multiField.view.value === 'list') {
+                typeMulti = MultichoiceFieldView.LIST;
+            }
+        }
+        return typeMulti;
+    };
+    /**
+     * This function is used to parse multichoice options from the `choices` attribute
+     * @param multiField multichoice field resource object who's options we want to resolve
+     * @returns the options for the multichoice field
+     */
+    FieldConverterService.prototype.resolveMultichoiceChoices = function (multiField) {
+        var choicesMulti = [];
+        if (multiField.choices instanceof Array) {
+            multiField.choices.forEach(function (it) {
+                choicesMulti.push({ key: it, value: it });
+            });
+        }
+        else {
+            Object.keys(multiField.choices).forEach(function (key) {
+                choicesMulti.push({ key: key, value: multiField.choices[key] });
+            });
+        }
+        return choicesMulti;
+    };
+    /**
+     * This function is used to parse enumeration options from the `options` attribute
+     * @param multiField multichoice field resource object who's options we want to resolve
+     * @returns the options for the multichoice field
+     */
+    FieldConverterService.prototype.resolveMultichoiceOptions = function (multiField) {
+        return Object.entries(multiField.options).map(function (entry) { return ({ key: entry[0], value: entry[1] }); });
+    };
+    FieldConverterService.prototype.formatValueFromBackend = function (field, value) {
+        if (value === null) {
+            return null;
+        }
+        if (value === undefined) {
+            return;
+        }
+        if (this.resolveType(field) === FieldTypeResource.TEXT && value === null) {
+            return null;
+        }
+        if (this.resolveType(field) === FieldTypeResource.TEXT && field.component && field.component.name === 'password') {
+            return atob(value);
+        }
+        if (this.resolveType(field) === FieldTypeResource.DATE) {
+            return moment(new Date(value[0], value[1] - 1, value[2]));
+        }
+        if (this.resolveType(field) === FieldTypeResource.USER) {
+            return new UserValue(value.id, value.name, value.surname, value.email);
+        }
+        if (this.resolveType(field) === FieldTypeResource.DATE_TIME) {
+            return moment(new Date(value[0], value[1] - 1, value[2], value[3], value[4]));
+        }
+        if (this.resolveType(field) === FieldTypeResource.MULTICHOICE) {
+            var array_1 = [];
+            value.forEach(function (v) {
+                if (v.defaultValue) {
+                    array_1.push(v.defaultValue);
+                }
+                else {
+                    array_1.push(v);
+                }
+            });
+            return array_1;
+        }
+        return value;
+    };
+    FieldConverterService.prototype.resolveTextValue = function (field, value) {
+        if (field.component !== undefined && field.component.name === 'password' && value !== '' && value !== undefined) {
+            return atob(value);
+        }
+        return value;
+    };
+    FieldConverterService.ɵprov = i0.ɵɵdefineInjectable({ factory: function FieldConverterService_Factory() { return new FieldConverterService(); }, token: FieldConverterService, providedIn: "root" });
+    FieldConverterService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    FieldConverterService.ctorParameters = function () { return []; };
+    return FieldConverterService;
+}());
+export { FieldConverterService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field-converter.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/task-content/services/field-converter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {DataFieldResource} from '../model/resource-interface';\nimport {DataField} from '../../data-fields/models/abstract-data-field';\nimport {BooleanField} from '../../data-fields/boolean-field/models/boolean-field';\nimport {TextField, TextFieldView} from '../../data-fields/text-field/models/text-field';\nimport {NumberField} from '../../data-fields/number-field/models/number-field';\nimport {EnumerationField, EnumerationFieldValue, EnumerationFieldView} from '../../data-fields/enumeration-field/models/enumeration-field';\nimport {MultichoiceField, MultichoiceFieldValue, MultichoiceFieldView} from '../../data-fields/multichoice-field/models/multichoice-field';\nimport {DateField} from '../../data-fields/date-field/models/date-field';\nimport {DateTimeField} from '../../data-fields/date-time-field/models/date-time-field';\nimport {UserField} from '../../data-fields/user-field/models/user-field';\nimport {ButtonField, ButtonFieldView} from '../../data-fields/button-field/models/button-field';\nimport {FileField} from '../../data-fields/file-field/models/file-field';\nimport moment from 'moment';\nimport {UserValue} from '../../data-fields/user-field/models/user-value';\nimport {FieldTypeResource} from '../model/field-type-resource';\nimport {FileListField} from '../../data-fields/file-list-field/models/file-list-field';\nimport {TextAreaField} from '../../data-fields/text-field/models/text-area-field';\nimport {Component} from '../../data-fields/models/component';\nimport {TaskRefField} from '../../data-fields/task-ref-field/model/task-ref-field';\nimport {DynamicEnumerationField} from '../../data-fields/enumeration-field/models/dynamic-enumeration-field';\nimport {FilterField} from '../../data-fields/filter-field/models/filter-field';\nimport {I18nField} from '../../data-fields/i18n-field/models/i18n-field';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class FieldConverterService {\n\n    constructor() {\n    }\n\n    public toClass(item: DataFieldResource): DataField<any> {\n        switch (item.type) {\n            case FieldTypeResource.BOOLEAN:\n                return new BooleanField(item.stringId, item.name, item.value as boolean, item.behavior,\n                    item.placeholder, item.description, item.layout, item.validations, item.component, item.parentTaskId);\n            case FieldTypeResource.TEXT:\n                /*@deprecated in 4.3.0*/\n                let type = TextFieldView.DEFAULT;\n                if (item.subType !== undefined && item.subType === 'area') {\n                    type = TextFieldView.TEXTAREA;\n                }\n                if (item.view !== undefined && item.view.value !== undefined && item.view.value === 'editor') {\n                    type = TextFieldView.RICHTEXTAREA;\n                    return new TextAreaField(item.stringId, item.name, item.value as string, item.behavior, item.placeholder,\n                        item.description, item.layout, item.validations, type);\n                } else if (item.view !== undefined && item.view.value !== undefined && item.view.value === 'area') {\n                    type = TextFieldView.TEXTAREA;\n                } else if (item.view !== undefined && item.view.value !== undefined && item.view.value === 'htmlEditor') {\n                    type = TextFieldView.HTMLTEXTAREA;\n                    return new TextAreaField(item.stringId, item.name, item.value as string, item.behavior, item.placeholder,\n                        item.description, item.layout, item.validations, type);\n                }\n                if (item.component !== undefined && item.component.name !== undefined && (item.component.name === 'editor' ||\n                    item.component.name === 'htmltextarea')) {\n                    return new TextAreaField(item.stringId, item.name, this.resolveTextValue(item, item.value),\n                        item.behavior, item.placeholder, item.description, item.layout, item.validations, type, item.component,\n                        item.parentTaskId);\n                }\n                return new TextField(item.stringId, item.name, this.resolveTextValue(item, item.value), item.behavior, item.placeholder,\n                    item.description, item.layout, item.validations, type, item.component, item.parentTaskId);\n            case FieldTypeResource.NUMBER:\n                return new NumberField(item.stringId, item.name, item.value as number, item.behavior, item.validations, item.placeholder,\n                    item.description, item.layout, item.formatFilter, this.resolveNumberComponent(item), item.parentTaskId);\n            case FieldTypeResource.ENUMERATION:\n            case FieldTypeResource.ENUMERATION_MAP:\n                return this.resolveEnumField(item);\n            case FieldTypeResource.MULTICHOICE:\n                return new MultichoiceField(item.stringId, item.name, item.value, this.resolveMultichoiceChoices(item),\n                    item.behavior, item.placeholder, item.description, item.layout, this.resolveMultichoiceViewType(item),\n                    item.type, item.validations, item.component, item.parentTaskId);\n            case FieldTypeResource.MULTICHOICE_MAP:\n                return new MultichoiceField(item.stringId, item.name, item.value, this.resolveMultichoiceOptions(item),\n                    item.behavior, item.placeholder, item.description, item.layout, this.resolveMultichoiceViewType(item),\n                    item.type, item.validations, item.component, item.parentTaskId);\n            case FieldTypeResource.DATE:\n                let date;\n                if (item.value) {\n                    date = moment(new Date(item.value[0], item.value[1] - 1, item.value[2]));\n                }\n                return new DateField(item.stringId, item.name, date, item.behavior, item.placeholder,\n                    item.description, item.layout, item.validations, item.component, item.parentTaskId);\n            case FieldTypeResource.DATE_TIME:\n                let dateTime;\n                if (item.value) {\n                    dateTime = moment(new Date(item.value[0], item.value[1] - 1, item.value[2], item.value[3], item.value[4]));\n                }\n                return new DateTimeField(item.stringId, item.name, dateTime, item.behavior,\n                    item.placeholder, item.description, item.layout, item.validations, item.component, item.parentTaskId);\n            case FieldTypeResource.USER:\n                let user;\n                if (item.value) {\n                    user = new UserValue(item.value.id, item.value.name, item.value.surname, item.value.email);\n                }\n                return new UserField(item.stringId, item.name, item.behavior, user,\n                    item.roles, item.placeholder, item.description, item.layout, item.validations, item.component, item.parentTaskId);\n            case FieldTypeResource.BUTTON:\n                /*@deprecated in 4.3.0*/\n                const typeBtn = this.resolveButtonView(item);\n                return new ButtonField(item.stringId, item.name, item.behavior, item.value as number,\n                    item.placeholder, item.description, item.layout, typeBtn, item.validations, item.component, item.parentTaskId);\n            case FieldTypeResource.FILE:\n                return new FileField(item.stringId, item.name, item.behavior, item.value ? item.value : {},\n                    item.placeholder, item.description, item.layout, null, null, item.validations, item.component,\n                    item.parentTaskId);\n            case FieldTypeResource.FILE_LIST:\n                return new FileListField(item.stringId, item.name, item.behavior, item.value ? item.value : {},\n                    item.placeholder, item.description, item.layout, item.validations, null, null, item.component,\n                    item.parentTaskId);\n            case FieldTypeResource.TASK_REF:\n                return new TaskRefField(item.stringId, item.name, item.value ? item.value : [], item.behavior,\n                    item.placeholder, item.description, item.layout, item.validations, item.component, item.parentTaskId);\n            case FieldTypeResource.FILTER:\n                return new FilterField(item.stringId, item.name, item.value ?? '', item.filterMetadata, item.allowedNets,\n                    item.behavior, item.placeholder, item.description, item.layout, item.validations, item.component, item.parentTaskId);\n            case FieldTypeResource.I18N:\n                return new I18nField(item.stringId, item.name, item.value ?? {defaultValue: ''}, item.behavior, item.placeholder,\n                    item.description, item.layout, item.validations, item.component);\n        }\n    }\n\n    public resolveType(item: DataField<any>): FieldTypeResource {\n        if (item instanceof BooleanField) {\n            return FieldTypeResource.BOOLEAN;\n        } else if (item instanceof ButtonField) {\n            return FieldTypeResource.BUTTON;\n        } else if (item instanceof TextField) {\n            return FieldTypeResource.TEXT;\n        } else if (item instanceof NumberField) {\n            return FieldTypeResource.NUMBER;\n        } else if (item instanceof DateField) {\n            return FieldTypeResource.DATE;\n        } else if (item instanceof DateTimeField) {\n            return FieldTypeResource.DATE_TIME;\n        } else if (item instanceof FileField) {\n            return FieldTypeResource.FILE;\n        } else if (item instanceof FileListField) {\n            return FieldTypeResource.FILE_LIST;\n        } else if (item instanceof UserField) {\n            return FieldTypeResource.USER;\n        } else if (item instanceof TaskRefField) {\n            return FieldTypeResource.TASK_REF;\n        } else if (item instanceof EnumerationField || item instanceof MultichoiceField) {\n            return item.fieldType;\n        } else if (item instanceof FilterField) {\n            return FieldTypeResource.FILTER;\n        } else if (item instanceof I18nField) {\n            return FieldTypeResource.I18N;\n        }\n    }\n\n    /*@deprecated in 4.3.0*/\n    public resolveButtonView(item: DataFieldResource): ButtonFieldView {\n        if (item.view !== undefined && item.view.value !== undefined) {\n            switch (item.view.value) {\n                case ButtonFieldView.STROKED:\n                    return ButtonFieldView.STROKED;\n                case ButtonFieldView.RAISED:\n                    return ButtonFieldView.RAISED;\n                case ButtonFieldView.FAB:\n                    return ButtonFieldView.FAB;\n                case ButtonFieldView.FLAT:\n                    return ButtonFieldView.FLAT;\n                case ButtonFieldView.ICON:\n                    return ButtonFieldView.ICON;\n                case ButtonFieldView.MINIFAB:\n                    return ButtonFieldView.MINIFAB;\n                default:\n                    return ButtonFieldView.STANDARD;\n            }\n        } else if (item instanceof ButtonField) {\n            return ButtonFieldView.STANDARD;\n        }\n    }\n\n    public formatValueForBackend(field: DataField<any>, value: any): any {\n        if (this.resolveType(field) === FieldTypeResource.TEXT && value === null) {\n            return null;\n        }\n        if (this.resolveType(field) === FieldTypeResource.TEXT && field.component && field.component.name === 'password') {\n            return btoa(value);\n        }\n        if (value === undefined || value === null) {\n            return;\n        }\n        if (this.resolveType(field) === FieldTypeResource.DATE) {\n            if (moment.isMoment(value)) {\n                return value.format('YYYY-MM-DD');\n            }\n        }\n        if (this.resolveType(field) === FieldTypeResource.USER) {\n            return value.id;\n        }\n        if (this.resolveType(field) === FieldTypeResource.DATE_TIME) {\n            if (moment.isMoment(value)) {\n                return value.format('DD.MM.YYYY HH:mm:ss');\n            }\n        }\n        return value;\n    }\n\n    protected resolveNumberComponent(numberField: DataFieldResource): Component {\n        let numberComponent = {name: 'default', properties: undefined};\n        if (numberField.component !== undefined) {\n            numberComponent = {\n                name: numberField.component.name,\n                properties: numberField.component.properties\n            };\n        }\n        return numberComponent;\n    }\n\n    /**\n     * Resolves `enumeration` and `eunumeration_map` fields into their appropriate class instances\n     * @param enumField enumeration field resource\n     */\n    protected resolveEnumField(enumField: DataFieldResource): EnumerationField {\n        const options = enumField.type === FieldTypeResource.ENUMERATION\n            ? this.resolveEnumChoices(enumField)\n            : this.resolveEnumOptions(enumField);\n        if (enumField.component && enumField.component.name === 'autocomplete_dynamic') {\n            return new DynamicEnumerationField(enumField.stringId, enumField.name, enumField.value, options,\n                enumField.behavior, enumField.placeholder, enumField.description, enumField.layout, this.resolveEnumViewType(enumField),\n                enumField.type, enumField.validations, enumField.component, enumField.parentTaskId);\n        } else {\n            return new EnumerationField(enumField.stringId, enumField.name, enumField.value, options,\n                enumField.behavior, enumField.placeholder, enumField.description, enumField.layout, this.resolveEnumViewType(enumField),\n                enumField.type, enumField.validations, enumField.component, enumField.parentTaskId);\n        }\n    }\n\n    /**\n     * @param enumField enumeration field resource object who's view type we want to resolve\n     * @returns the view type defined in the field object, or default if none, or invalid type is defined\n     * @deprecated in 4.3.0\n     */\n    protected resolveEnumViewType(enumField: DataFieldResource): EnumerationFieldView {\n        let typeEnum = EnumerationFieldView.DEFAULT;\n        if (enumField.view && enumField.view.value !== undefined) {\n            if (enumField.view.value === 'list') {\n                typeEnum = EnumerationFieldView.LIST;\n            } else if (enumField.view.value === 'autocomplete') {\n                typeEnum = EnumerationFieldView.AUTOCOMPLETE;\n            } else if (enumField.view.value === 'stepper') {\n                typeEnum = EnumerationFieldView.STEPPER;\n            }\n        }\n        return typeEnum;\n    }\n\n    /**\n     * This function is used to parse enumeration options from the `choices` attribute\n     * @param enumField enumeration field resource object who's choices we want to resolve\n     * @returns the options for the enumeration field\n     */\n    protected resolveEnumChoices(enumField: DataFieldResource): Array<EnumerationFieldValue> {\n        const enumChoices = [];\n        if (enumField.choices instanceof Array) {\n            enumField.choices.forEach(it => {\n                enumChoices.push({key: it, value: it} as EnumerationFieldValue);\n            });\n        } else {\n            Object.keys(enumField.choices).forEach(key => {\n                enumChoices.push({key, value: enumField.choices[key]} as EnumerationFieldValue);\n            });\n        }\n        return enumChoices;\n    }\n\n    /**\n     * This function is used to parse enumeration options from the `options` attribute\n     * @param enumField enumeration field resource object who's options we want to resolve\n     * @returns the options for the enumeration field\n     */\n    protected resolveEnumOptions(enumField: DataFieldResource): Array<EnumerationFieldValue> {\n        return Object.entries(enumField.options).map(entry => ({key: entry[0], value: entry[1]}));\n    }\n\n    /**\n     * @param multiField multichoice field resource object who's view type we want to resolve\n     * @returns the view type defined in the field object, or default if none, or invalid type is defined\n     * @deprecated in 4.3.0\n     */\n    protected resolveMultichoiceViewType(multiField: DataFieldResource): MultichoiceFieldView {\n        let typeMulti = MultichoiceFieldView.DEFAULT;\n        if (multiField.view && multiField.view.value !== undefined) {\n            if (multiField.view.value === 'list') {\n                typeMulti = MultichoiceFieldView.LIST;\n            }\n        }\n        return typeMulti;\n    }\n\n    /**\n     * This function is used to parse multichoice options from the `choices` attribute\n     * @param multiField multichoice field resource object who's options we want to resolve\n     * @returns the options for the multichoice field\n     */\n    protected resolveMultichoiceChoices(multiField: DataFieldResource): Array<MultichoiceFieldValue> {\n        const choicesMulti: Array<MultichoiceFieldValue> = [];\n        if (multiField.choices instanceof Array) {\n            multiField.choices.forEach(it => {\n                choicesMulti.push({key: it, value: it} as MultichoiceFieldValue);\n            });\n        } else {\n            Object.keys(multiField.choices).forEach(key => {\n                choicesMulti.push({key, value: multiField.choices[key]} as MultichoiceFieldValue);\n            });\n        }\n        return choicesMulti;\n    }\n\n    /**\n     * This function is used to parse enumeration options from the `options` attribute\n     * @param multiField multichoice field resource object who's options we want to resolve\n     * @returns the options for the multichoice field\n     */\n    protected resolveMultichoiceOptions(multiField: DataFieldResource): Array<MultichoiceFieldValue> {\n        return Object.entries(multiField.options).map(entry => ({key: entry[0], value: entry[1]}));\n    }\n\n    public formatValueFromBackend(field: DataField<any>, value: any): any {\n        if (value === null) {\n            return null;\n        }\n        if (value === undefined) {\n            return;\n        }\n        if (this.resolveType(field) === FieldTypeResource.TEXT && value === null) {\n            return null;\n        }\n        if (this.resolveType(field) === FieldTypeResource.TEXT && field.component && field.component.name === 'password') {\n            return atob(value);\n        }\n        if (this.resolveType(field) === FieldTypeResource.DATE) {\n            return moment(new Date(value[0], value[1] - 1, value[2]));\n        }\n        if (this.resolveType(field) === FieldTypeResource.USER) {\n            return new UserValue(value.id, value.name, value.surname, value.email);\n        }\n        if (this.resolveType(field) === FieldTypeResource.DATE_TIME) {\n            return moment(new Date(value[0], value[1] - 1, value[2], value[3], value[4]));\n        }\n        if (this.resolveType(field) === FieldTypeResource.MULTICHOICE) {\n            const array = [];\n            value.forEach(v => {\n                if (v.defaultValue) {\n                    array.push(v.defaultValue);\n                } else {\n                    array.push(v);\n                }\n            });\n            return array;\n        }\n        return value;\n    }\n\n    protected resolveTextValue(field: DataFieldResource, value: string): string {\n        if (field.component !== undefined && field.component.name === 'password' && value !== '' && value !== undefined) {\n            return atob(value);\n        }\n        return value;\n    }\n}\n"]}

package/esm5/lib/task-content/services/single-task-content.service.js

@@ -0,0 +1,85 @@
+import { __extends } from "tslib";
+import { Injectable } from '@angular/core';
+import { TaskContentService } from './task-content.service';
+import { FieldConverterService } from './field-converter.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { TranslateService } from '@ngx-translate/core';
+import { LoggerService } from '../../logger/services/logger.service';
+import { ReplaySubject } from 'rxjs';
+/**
+ * Provides an implementation of the {@link TaskContentService} abstract class that allows only a
+ * single call to the setter of the managed Task object.
+ *
+ * If you want to use an unlimited number of calls use {@link UnlimitedTaskContentService} instead.
+ */
+var SingleTaskContentService = /** @class */ (function (_super) {
+    __extends(SingleTaskContentService, _super);
+    function SingleTaskContentService(_fieldConverterService, _snackBarService, _translate, _logger) {
+        var _this = _super.call(this, _fieldConverterService, _snackBarService, _translate, _logger) || this;
+        _this._task$ = new ReplaySubject(1);
+        return _this;
+    }
+    Object.defineProperty(SingleTaskContentService.prototype, "task", {
+        /**
+         * @returns the Task object if set and `undefined` otherwise
+         */
+        get: function () {
+            return this._task;
+        },
+        /**
+         * The task can be only set once. All other call do nothing and log an error.
+         * @param task the Task that owns the content managed by this service
+         */
+        set: function (task) {
+            if (!this._task$.closed) {
+                this._task = task;
+                this._task$.next(task);
+                this._task$.complete();
+            }
+            else {
+                this._logger.error('TaskContentService can have it\'s task set only once');
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SingleTaskContentService.prototype, "task$", {
+        /**
+         * Stream returns a single {@link Task} object and then completes.
+         *
+         * Use [task]{@link TaskContentService#task} setter method to set the Task.
+         */
+        get: function () {
+            return this._task$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Completes the underling stream.
+     */
+    SingleTaskContentService.prototype.ngOnDestroy = function () {
+        _super.prototype.ngOnDestroy.call(this);
+        if (!this._task$.closed) {
+            this._task$.complete();
+        }
+    };
+    SingleTaskContentService.ctorParameters = function () { return [
+        { type: FieldConverterService },
+        { type: SnackBarService },
+        { type: TranslateService },
+        { type: LoggerService }
+    ]; };
+    SingleTaskContentService.decorators = [
+        { type: Injectable }
+    ];
+    SingleTaskContentService.ctorParameters = function () { return [
+        { type: FieldConverterService },
+        { type: SnackBarService },
+        { type: TranslateService },
+        { type: LoggerService }
+    ]; };
+    return SingleTaskContentService;
+}(TaskContentService));
+export { SingleTaskContentService };
+//# sourceMappingURL=data:application/json;base64,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