@netgrif/components-core 6.0.1

package/esm2015/lib/task-content/model/task-event-notification.js

@@ -0,0 +1,15 @@
+/**
+ * @param task affected Task object
+ * @param event the reported Task event
+ * @param success success state of the reported event
+ * @returns the notification informing about the event
+ */
+export function createTaskEventNotification(task, event, success) {
+    return {
+        taskId: task.stringId,
+        transitionId: task.transitionId,
+        event,
+        success
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1ldmVudC1ub3RpZmljYXRpb24uanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdGFzay1jb250ZW50L21vZGVsL3Rhc2stZXZlbnQtbm90aWZpY2F0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQTJCQTs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSwyQkFBMkIsQ0FBQyxJQUFVLEVBQUUsS0FBZ0IsRUFBRSxPQUFnQjtJQUN0RixPQUFPO1FBQ0gsTUFBTSxFQUFFLElBQUksQ0FBQyxRQUFRO1FBQ3JCLFlBQVksRUFBRSxJQUFJLENBQUMsWUFBWTtRQUMvQixLQUFLO1FBQ0wsT0FBTztLQUNWLENBQUM7QUFDTixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtUYXNrRXZlbnR9IGZyb20gJy4vdGFzay1ldmVudCc7XG5pbXBvcnQge1Rhc2t9IGZyb20gJy4uLy4uL3Jlc291cmNlcy9wdWJsaWMtYXBpJztcblxuLyoqXG4gKiBIb2xkcyB0aGUgaW5mb3JtYXRpb24gYWJvdXQgYW4gZXZlbnQgdGhhdCBvY2N1cnJlZCB0byBzb21lIHtAbGluayBUYXNrfSByZXNvdXJjZS5cbiAqXG4gKiBUYXNrIGV2ZW50cyBjb3JyZXNwb25kIG1vcmUgb3IgbGVzcyAxLXRvLTEgdG8gYmFja2VuZCBjYWxscyBhbmQgdGhlaXIgcmVzdWx0cy5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBUYXNrRXZlbnROb3RpZmljYXRpb24ge1xuICAgIC8qKlxuICAgICAqIFN0cmluZ0lkIG9mIHRoZSBhZmZlY3RlZCB7QGxpbmsgVGFza31cbiAgICAgKi9cbiAgICB0YXNrSWQ6IHN0cmluZztcbiAgICAvKipcbiAgICAgKiBTdHJpbmdJZCBvZiB0aGUgVHJhbnNpdGlvblxuICAgICAqL1xuICAgIHRyYW5zaXRpb25JZDogc3RyaW5nO1xuICAgIC8qKlxuICAgICAqIFRoZSBldmVudCB0aGF0IG9jY3VycmVkXG4gICAgICovXG4gICAgZXZlbnQ6IFRhc2tFdmVudDtcbiAgICAvKipcbiAgICAgKiBTdWNjZXNzIHN0YXRlIG9mIHRoZSBldmVudFxuICAgICAqL1xuICAgIHN1Y2Nlc3M6IGJvb2xlYW47XG59XG5cbi8qKlxuICogQHBhcmFtIHRhc2sgYWZmZWN0ZWQgVGFzayBvYmplY3RcbiAqIEBwYXJhbSBldmVudCB0aGUgcmVwb3J0ZWQgVGFzayBldmVudFxuICogQHBhcmFtIHN1Y2Nlc3Mgc3VjY2VzcyBzdGF0ZSBvZiB0aGUgcmVwb3J0ZWQgZXZlbnRcbiAqIEByZXR1cm5zIHRoZSBub3RpZmljYXRpb24gaW5mb3JtaW5nIGFib3V0IHRoZSBldmVudFxuICovXG5leHBvcnQgZnVuY3Rpb24gY3JlYXRlVGFza0V2ZW50Tm90aWZpY2F0aW9uKHRhc2s6IFRhc2ssIGV2ZW50OiBUYXNrRXZlbnQsIHN1Y2Nlc3M6IGJvb2xlYW4pOiBUYXNrRXZlbnROb3RpZmljYXRpb24ge1xuICAgIHJldHVybiB7XG4gICAgICAgIHRhc2tJZDogdGFzay5zdHJpbmdJZCxcbiAgICAgICAgdHJhbnNpdGlvbklkOiB0YXNrLnRyYW5zaXRpb25JZCxcbiAgICAgICAgZXZlbnQsXG4gICAgICAgIHN1Y2Nlc3NcbiAgICB9O1xufVxuIl19

package/esm2015/lib/task-content/model/task-event.js

@@ -0,0 +1,10 @@
+export var TaskEvent;
+(function (TaskEvent) {
+    TaskEvent["ASSIGN"] = "assign";
+    TaskEvent["FINISH"] = "finish";
+    TaskEvent["CANCEL"] = "cancel";
+    TaskEvent["DELEGATE"] = "delegate";
+    TaskEvent["SET_DATA"] = "set data";
+    TaskEvent["GET_DATA"] = "get data";
+})(TaskEvent || (TaskEvent = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1ldmVudC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi90YXNrLWNvbnRlbnQvbW9kZWwvdGFzay1ldmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxTQU9YO0FBUEQsV0FBWSxTQUFTO0lBQ2pCLDhCQUFpQixDQUFBO0lBQ2pCLDhCQUFpQixDQUFBO0lBQ2pCLDhCQUFpQixDQUFBO0lBQ2pCLGtDQUFxQixDQUFBO0lBQ3JCLGtDQUFxQixDQUFBO0lBQ3JCLGtDQUFxQixDQUFBO0FBQ3pCLENBQUMsRUFQVyxTQUFTLEtBQVQsU0FBUyxRQU9wQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIFRhc2tFdmVudCB7XG4gICAgQVNTSUdOID0gJ2Fzc2lnbicsXG4gICAgRklOSVNIID0gJ2ZpbmlzaCcsXG4gICAgQ0FOQ0VMID0gJ2NhbmNlbCcsXG4gICAgREVMRUdBVEUgPSAnZGVsZWdhdGUnLFxuICAgIFNFVF9EQVRBID0gJ3NldCBkYXRhJyxcbiAgICBHRVRfREFUQSA9ICdnZXQgZGF0YScsXG59XG4iXX0=

package/esm2015/lib/task-content/public-api.js

@@ -0,0 +1,21 @@
+/* SERVICES */
+export * from './services/task-event.service';
+export * from './services/field-converter.service';
+export * from './services/task-content.service';
+export * from './services/single-task-content.service';
+export * from './services/unlimited-task-content.service';
+/* MODELS */
+export * from './model/policy';
+export * from './model/task-event-notification';
+export * from './model/task-event';
+export * from './model/field-type-resource';
+export * from './model/task-content-element-type';
+export * from './model/datafield-grid-layout-element';
+export * from './model/async-rendering-configuration';
+export * from './model/async-rendering-configuration-injection-token';
+export * from './model/subgrid';
+export * from './model/split-data-group';
+/* MODULES */
+export * from './task-content/abstract-task-content.component';
+export * from './field-component-resolver/abstract-field-component-resolver.component';
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,348 @@
+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";
+export class FieldConverterService {
+    constructor() {
+    }
+    toClass(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*/
+                let 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:
+                let date;
+                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:
+                let dateTime;
+                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:
+                let user;
+                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*/
+                const 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);
+        }
+    }
+    resolveType(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*/
+    resolveButtonView(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;
+        }
+    }
+    formatValueForBackend(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;
+    }
+    resolveNumberComponent(numberField) {
+        let 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
+     */
+    resolveEnumField(enumField) {
+        const 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
+     */
+    resolveEnumViewType(enumField) {
+        let 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
+     */
+    resolveEnumChoices(enumField) {
+        const enumChoices = [];
+        if (enumField.choices instanceof Array) {
+            enumField.choices.forEach(it => {
+                enumChoices.push({ key: it, value: it });
+            });
+        }
+        else {
+            Object.keys(enumField.choices).forEach(key => {
+                enumChoices.push({ 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
+     */
+    resolveEnumOptions(enumField) {
+        return Object.entries(enumField.options).map(entry => ({ 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
+     */
+    resolveMultichoiceViewType(multiField) {
+        let 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
+     */
+    resolveMultichoiceChoices(multiField) {
+        const choicesMulti = [];
+        if (multiField.choices instanceof Array) {
+            multiField.choices.forEach(it => {
+                choicesMulti.push({ key: it, value: it });
+            });
+        }
+        else {
+            Object.keys(multiField.choices).forEach(key => {
+                choicesMulti.push({ 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
+     */
+    resolveMultichoiceOptions(multiField) {
+        return Object.entries(multiField.options).map(entry => ({ key: entry[0], value: entry[1] }));
+    }
+    formatValueFromBackend(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) {
+            const array = [];
+            value.forEach(v => {
+                if (v.defaultValue) {
+                    array.push(v.defaultValue);
+                }
+                else {
+                    array.push(v);
+                }
+            });
+            return array;
+        }
+        return value;
+    }
+    resolveTextValue(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 = () => [];
+//# 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/esm2015/lib/task-content/services/single-task-content.service.js

@@ -0,0 +1,72 @@
+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.
+ */
+export class SingleTaskContentService extends TaskContentService {
+    constructor(_fieldConverterService, _snackBarService, _translate, _logger) {
+        super(_fieldConverterService, _snackBarService, _translate, _logger);
+        this._task$ = new ReplaySubject(1);
+    }
+    /**
+     * @returns the Task object if set and `undefined` otherwise
+     */
+    get task() {
+        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 task(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');
+        }
+    }
+    /**
+     * Stream returns a single {@link Task} object and then completes.
+     *
+     * Use [task]{@link TaskContentService#task} setter method to set the Task.
+     */
+    get task$() {
+        return this._task$.asObservable();
+    }
+    /**
+     * Completes the underling stream.
+     */
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        if (!this._task$.closed) {
+            this._task$.complete();
+        }
+    }
+}
+SingleTaskContentService.ctorParameters = () => [
+    { type: FieldConverterService },
+    { type: SnackBarService },
+    { type: TranslateService },
+    { type: LoggerService }
+];
+SingleTaskContentService.decorators = [
+    { type: Injectable }
+];
+SingleTaskContentService.ctorParameters = () => [
+    { type: FieldConverterService },
+    { type: SnackBarService },
+    { type: TranslateService },
+    { type: LoggerService }
+];
+//# sourceMappingURL=data:application/json;base64,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