@netgrif/components-core 6.0.1

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

@@ -0,0 +1,314 @@
+import { __read, __spread, __values } from "tslib";
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, ReplaySubject, Subject, timer } from 'rxjs';
+import { LoggerService } from '../../logger/services/logger.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { TranslateService } from '@ngx-translate/core';
+import { FieldConverterService } from './field-converter.service';
+import { FieldTypeResource } from '../model/field-type-resource';
+import { DynamicEnumerationField } from '../../data-fields/enumeration-field/models/dynamic-enumeration-field';
+/**
+ * Acts as a communication interface between the Component that renders Task content and it's parent Component.
+ * Also provides some general functionality that is needed when working with task content.
+ *
+ * Notable example of a parent Component is the {@link AbstractTaskPanelComponent}.
+ *
+ * Notable example of a task content renderer is the {@link AbstractTaskContentComponent}.
+ */
+var TaskContentService = /** @class */ (function () {
+    function TaskContentService(_fieldConverterService, _snackBarService, _translate, _logger) {
+        this._fieldConverterService = _fieldConverterService;
+        this._snackBarService = _snackBarService;
+        this._translate = _translate;
+        this._logger = _logger;
+        this._taskFieldsIndex = {};
+        this._referencedTaskAndCaseIds = {};
+        this.$shouldCreate = new ReplaySubject(1);
+        this.$shouldCreateCounter = new BehaviorSubject(0);
+        this._isExpanding$ = new BehaviorSubject(false);
+        this._task = undefined;
+        this._taskDataReloadRequest$ = new Subject();
+    }
+    TaskContentService.prototype.ngOnDestroy = function () {
+        if (!this.$shouldCreate.closed) {
+            this.$shouldCreate.complete();
+        }
+        this._taskDataReloadRequest$.complete();
+        this._isExpanding$.complete();
+    };
+    Object.defineProperty(TaskContentService.prototype, "taskDataReloadRequest$", {
+        /**
+         * Stream that emits every time a data reload is requested.
+         */
+        get: function () {
+            return this._taskDataReloadRequest$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TaskContentService.prototype, "taskFieldsIndex", {
+        get: function () {
+            return this._taskFieldsIndex;
+        },
+        set: function (value) {
+            this._taskFieldsIndex = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TaskContentService.prototype, "referencedTaskAndCaseIds", {
+        get: function () {
+            return this._referencedTaskAndCaseIds;
+        },
+        set: function (value) {
+            this._referencedTaskAndCaseIds = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TaskContentService.prototype, "isExpanding", {
+        /**
+         * Whether the panel that the task content is contained in is currently expanding.
+         *
+         * If the task content is not contained in a panel, `isExpanding` will be always `false`.
+         */
+        get: function () {
+            return this._isExpanding$.value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Changes the state of the task content to `expanding`.
+     */
+    TaskContentService.prototype.expansionStarted = function () {
+        this._isExpanding$.next(true);
+    };
+    /**
+     * Changes the state of the task content to `not expanding`.
+     */
+    TaskContentService.prototype.expansionFinished = function () {
+        this._isExpanding$.next(false);
+    };
+    /**
+     * Checks the validity of all data fields in the managed {@link Task}.
+     *
+     * If some of the fields are invalid touches them so their validation errors will appear (if set).
+     * A snackbar will also be displayed to the user, informing them of the fact that the fields are invalid.
+     * @returns whether the task is valid or not
+     */
+    TaskContentService.prototype.validateTaskData = function () {
+        if (!this._task || !this._task.dataGroups) {
+            return false;
+        }
+        var valid = !this._task.dataGroups.some(function (group) { return group.fields.some(function (field) { return !field.valid && !field.disabled; }); });
+        var validDisabled = !this._task.dataGroups.some(function (group) { return group.fields.some(function (field) { return !field.validRequired && field.disabled; }); });
+        if (!valid) {
+            this._snackBarService.openErrorSnackBar(this._translate.instant('tasks.snackbar.invalidData'));
+            this._task.dataGroups.forEach(function (group) { return group.fields.forEach(function (field) { return field.touch = true; }); });
+        }
+        if (!validDisabled) {
+            this._snackBarService.openErrorSnackBar(this._translate.instant('tasks.snackbar.missingRequired'));
+        }
+        return valid && validDisabled;
+    };
+    /**
+     * Finds invalid data of task
+     *
+     * @returns array of invalid datafields
+     */
+    TaskContentService.prototype.getInvalidTaskData = function () {
+        var invalidFields = [];
+        this._task.dataGroups.forEach(function (group) { return invalidFields.push.apply(invalidFields, __spread(group.fields.filter(function (field) {
+            return (!field.valid && !field.disabled) || (!field.validRequired && !field.disabled);
+        }))); });
+        return invalidFields;
+    };
+    TaskContentService.prototype.validateDynamicEnumField = function () {
+        var e_1, _a, e_2, _b;
+        if (!this._task || !this._task.dataGroups) {
+            return false;
+        }
+        var exists = this._task.dataGroups.some(function (group) { return group.fields.some(function (field) { return field instanceof DynamicEnumerationField; }); });
+        if (!exists) {
+            return true;
+        }
+        var valid = true;
+        try {
+            for (var _c = __values(this._task.dataGroups), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var group = _d.value;
+                var _loop_1 = function (field) {
+                    if (field instanceof DynamicEnumerationField) {
+                        if (field.choices !== undefined && field.choices.length !== 0 && field.value !== '' && field.value !== undefined) {
+                            if (!field.choices.some(function (choice) { return choice.key === field.value; })) {
+                                field.value = '';
+                                if (field.behavior.required) {
+                                    valid = false;
+                                }
+                            }
+                        }
+                    }
+                };
+                try {
+                    for (var _e = (e_2 = void 0, __values(group.fields)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var field = _f.value;
+                        _loop_1(field);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (!valid) {
+            this._snackBarService.openErrorSnackBar(this._translate.instant('tasks.snackbar.missingRequired'));
+        }
+        return valid;
+    };
+    /**
+     * Changes the blocking state of all fields in the managed Task.
+     * @param blockingState whether the field should be blocked or not
+     */
+    TaskContentService.prototype.blockFields = function (blockingState) {
+        if (this._task && this._task.dataGroups) {
+            this._task.dataGroups.forEach(function (group) {
+                group.fields.forEach(function (field) {
+                    field.block = blockingState;
+                });
+            });
+        }
+    };
+    /**
+     * Clears the assignee, start date and finish date from the managed Task.
+     */
+    TaskContentService.prototype.updateStateData = function (eventOutcome) {
+        if (this._task) {
+            this._task.user = eventOutcome.task.user;
+            this._task.startDate = eventOutcome.task.startDate;
+            this._task.finishDate = eventOutcome.task.finishDate;
+        }
+    };
+    /**
+     * Updates the properties of fields in the managed task based on a delta of changes from previous state.
+     * @param chFields object containing the delta of the changes from the previous state
+     */
+    TaskContentService.prototype.updateFromChangedFields = function (chFields) {
+        var _this = this;
+        if (!this._task || !this._task.dataGroups) {
+            return;
+        }
+        // todo actions owner zbytočný?
+        var frontendActions = chFields.taskId === this.task.stringId && chFields[TaskContentService.FRONTEND_ACTIONS_KEY];
+        Object.keys(chFields).forEach(function (changedField) {
+            if (!!_this.taskFieldsIndex[chFields.taskId] && !!_this.taskFieldsIndex[chFields.taskId][changedField]) {
+                _this.updateField(chFields, _this.taskFieldsIndex[chFields.taskId][changedField], frontendActions);
+            }
+        });
+        this.$shouldCreate.next(this._task.dataGroups);
+        this.performFrontendAction(frontendActions);
+    };
+    TaskContentService.prototype.updateField = function (chFields, field, frontendActions) {
+        var _this = this;
+        if (this._fieldConverterService.resolveType(field) === FieldTypeResource.TASK_REF) {
+            this._taskDataReloadRequest$.next(frontendActions ? frontendActions : undefined);
+            return;
+        }
+        var updatedField = chFields[field.stringId];
+        Object.keys(updatedField).forEach(function (key) {
+            switch (key) {
+                case 'type':
+                    // type is just an information, not an update. A field cannot change its type
+                    return; // continue - the field does not need updating, since nothing changed
+                case 'value':
+                    field.valueWithoutChange(_this._fieldConverterService.formatValueFromBackend(field, updatedField[key]));
+                    break;
+                case 'behavior':
+                    if (updatedField.behavior[_this._task.transitionId]) {
+                        // TODO NGSD-489 fix behavior resolution
+                        field.behavior = updatedField.behavior[_this._task.transitionId];
+                    }
+                    else {
+                        // ignore the behavior update, since it does not affect this task
+                        return; // continue - the field does not need updating, since nothing changed
+                    }
+                    break;
+                case 'choices':
+                    var newChoices_1 = [];
+                    if (updatedField.choices instanceof Array) {
+                        updatedField.choices.forEach(function (it) {
+                            newChoices_1.push({ key: it, value: it });
+                        });
+                    }
+                    else {
+                        Object.keys(updatedField.choices).forEach(function (choiceKey) {
+                            newChoices_1.push({
+                                key: choiceKey,
+                                value: updatedField.choices[choiceKey]
+                            });
+                        });
+                    }
+                    field.choices = newChoices_1;
+                    break;
+                case 'options':
+                    var newOptions_1 = [];
+                    Object.keys(updatedField.options).forEach(function (optionKey) {
+                        newOptions_1.push({ key: optionKey, value: updatedField.options[optionKey] });
+                    });
+                    field.choices = newOptions_1;
+                    break;
+                case 'validations':
+                    field.replaceValidations(updatedField.validations.map(function (it) { return it; }));
+                    break;
+                default:
+                    field[key] = updatedField[key];
+            }
+            field.update();
+        });
+    };
+    /**
+     * Performs the specific frontend action.
+     *
+     * A prototype implementation of frontend actions.
+     *
+     * The specifics are subject to change. It is very likely that this method will be moved to a different service.
+     *
+     * @param frontendAction the action that should be performed.
+     */
+    TaskContentService.prototype.performFrontendAction = function (frontendAction) {
+        var _this = this;
+        if (frontendAction && frontendAction.type === TaskContentService.VALIDATE_FRONTEND_ACTION) {
+            timer().subscribe(function () { return _this.validateTaskData(); });
+        }
+    };
+    TaskContentService.FRONTEND_ACTIONS_KEY = '_frontend_actions';
+    TaskContentService.VALIDATE_FRONTEND_ACTION = 'validate';
+    TaskContentService.ctorParameters = function () { return [
+        { type: FieldConverterService },
+        { type: SnackBarService },
+        { type: TranslateService },
+        { type: LoggerService }
+    ]; };
+    TaskContentService.decorators = [
+        { type: Injectable }
+    ];
+    TaskContentService.ctorParameters = function () { return [
+        { type: FieldConverterService },
+        { type: SnackBarService },
+        { type: TranslateService },
+        { type: LoggerService }
+    ]; };
+    return TaskContentService;
+}());
+export { TaskContentService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-content.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/task-content/services/task-content.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\nimport {DataGroup} from '../../resources/interface/data-groups';\nimport {BehaviorSubject, Observable, ReplaySubject, Subject, timer} from 'rxjs';\nimport {Task} from '../../resources/interface/task';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {SnackBarService} from '../../snack-bar/services/snack-bar.service';\nimport {TranslateService} from '@ngx-translate/core';\nimport {EnumerationField, EnumerationFieldValue} from '../../data-fields/enumeration-field/models/enumeration-field';\nimport {MultichoiceField} from '../../data-fields/multichoice-field/models/multichoice-field';\nimport {Change, ChangedFields, FrontendActions} from '../../data-fields/models/changed-fields';\nimport {FieldConverterService} from './field-converter.service';\nimport {FieldTypeResource} from '../model/field-type-resource';\nimport {DynamicEnumerationField} from '../../data-fields/enumeration-field/models/dynamic-enumeration-field';\nimport {Validation} from '../../data-fields/models/validation';\nimport {TaskEventOutcome} from '../../event/model/event-outcomes/task-outcomes/task-event-outcome';\nimport {DataField} from '../../data-fields/models/abstract-data-field';\n\n/**\n * Acts as a communication interface between the Component that renders Task content and it's parent Component.\n * Also provides some general functionality that is needed when working with task content.\n *\n * Notable example of a parent Component is the {@link AbstractTaskPanelComponent}.\n *\n * Notable example of a task content renderer is the {@link AbstractTaskContentComponent}.\n */\n@Injectable()\nexport abstract class TaskContentService implements OnDestroy {\n\n    private static readonly FRONTEND_ACTIONS_KEY = '_frontend_actions';\n    private static readonly VALIDATE_FRONTEND_ACTION = 'validate';\n\n    $shouldCreate: ReplaySubject<Array<DataGroup>>;\n    $shouldCreateCounter: BehaviorSubject<number>;\n    protected _task: Task;\n    protected _taskDataReloadRequest$: Subject<FrontendActions>;\n    protected _isExpanding$: BehaviorSubject<boolean>;\n    private _taskFieldsIndex: {\n        [taskId: string]: {\n            [fieldId: string]: DataField<any>;\n        }\n    } = {};\n    private _referencedTaskAndCaseIds: { [caseId: string]: Array<string> } = {};\n\n    protected constructor(protected _fieldConverterService: FieldConverterService,\n                          protected _snackBarService: SnackBarService,\n                          protected _translate: TranslateService,\n                          protected _logger: LoggerService) {\n        this.$shouldCreate = new ReplaySubject<Array<DataGroup>>(1);\n        this.$shouldCreateCounter = new BehaviorSubject<number>(0);\n        this._isExpanding$ = new BehaviorSubject<boolean>(false);\n        this._task = undefined;\n        this._taskDataReloadRequest$ = new Subject<FrontendActions>();\n    }\n\n    ngOnDestroy(): void {\n        if (!this.$shouldCreate.closed) {\n            this.$shouldCreate.complete();\n        }\n        this._taskDataReloadRequest$.complete();\n        this._isExpanding$.complete();\n    }\n\n    /**\n     * @returns the Task object if set and `undefined` otherwise\n     */\n    public abstract get task(): Task | undefined;\n\n    /**\n     * Setting a Task also emits it into the stream accessible by the [task$]{@link TaskContentService#task$} getter method.\n     * @param task the Task that owns the content managed by this service\n     */\n    public abstract set task(task: Task);\n\n    /**\n     * Stream returns a {@link Task} object every time this object is set.\n     *\n     * Use [task]{@link TaskContentService#task} setter method to set the Task.\n     */\n    public abstract get task$(): Observable<Task>;\n\n    /**\n     * Stream that emits every time a data reload is requested.\n     */\n    public get taskDataReloadRequest$(): Observable<FrontendActions> {\n        return this._taskDataReloadRequest$.asObservable();\n    }\n\n\n    get taskFieldsIndex(): { [p: string]: { [p: string]: DataField<any> } } {\n        return this._taskFieldsIndex;\n    }\n\n    set taskFieldsIndex(value: { [p: string]: { [p: string]: DataField<any> } }) {\n        this._taskFieldsIndex = value;\n    }\n\n    get referencedTaskAndCaseIds(): { [p: string]: Array<string> } {\n        return this._referencedTaskAndCaseIds;\n    }\n\n    set referencedTaskAndCaseIds(value: { [p: string]: Array<string> }) {\n        this._referencedTaskAndCaseIds = value;\n    }\n\n    /**\n     * Whether the panel that the task content is contained in is currently expanding.\n     *\n     * If the task content is not contained in a panel, `isExpanding` will be always `false`.\n     */\n    public get isExpanding(): boolean {\n        return this._isExpanding$.value;\n    }\n\n    /**\n     * Changes the state of the task content to `expanding`.\n     */\n    public expansionStarted(): void {\n        this._isExpanding$.next(true);\n    }\n\n    /**\n     * Changes the state of the task content to `not expanding`.\n     */\n    public expansionFinished(): void {\n        this._isExpanding$.next(false);\n    }\n\n    /**\n     * Checks the validity of all data fields in the managed {@link Task}.\n     *\n     * If some of the fields are invalid touches them so their validation errors will appear (if set).\n     * A snackbar will also be displayed to the user, informing them of the fact that the fields are invalid.\n     * @returns whether the task is valid or not\n     */\n    public validateTaskData(): boolean {\n        if (!this._task || !this._task.dataGroups) {\n            return false;\n        }\n        const valid = !this._task.dataGroups.some(group => group.fields.some(field => !field.valid && !field.disabled));\n        const validDisabled = !this._task.dataGroups.some(group => group.fields.some(field => !field.validRequired && field.disabled));\n        if (!valid) {\n            this._snackBarService.openErrorSnackBar(this._translate.instant('tasks.snackbar.invalidData'));\n            this._task.dataGroups.forEach(group => group.fields.forEach(field => field.touch = true));\n        }\n        if (!validDisabled) {\n            this._snackBarService.openErrorSnackBar(this._translate.instant('tasks.snackbar.missingRequired'));\n        }\n        return valid && validDisabled;\n    }\n\n    /**\n     * Finds invalid data of task\n     *\n     * @returns array of invalid datafields\n     */\n    public getInvalidTaskData(): Array<DataField<any>> {\n        const invalidFields = [];\n        this._task.dataGroups.forEach(group => invalidFields.push(...group.fields.filter(field =>\n            (!field.valid && !field.disabled) || (!field.validRequired && !field.disabled))));\n        return invalidFields;\n    }\n\n    public validateDynamicEnumField(): boolean {\n        if (!this._task || !this._task.dataGroups) {\n            return false;\n        }\n        const exists = this._task.dataGroups.some(group => group.fields.some(field => field instanceof DynamicEnumerationField));\n        if (!exists) {\n            return true;\n        }\n        let valid = true;\n        for (const group of this._task.dataGroups) {\n            for (const field of group.fields) {\n                if (field instanceof DynamicEnumerationField) {\n                    if (field.choices !== undefined && field.choices.length !== 0 && field.value !== '' && field.value !== undefined) {\n                        if (!field.choices.some(choice => choice.key === field.value)) {\n                            field.value = '';\n                            if (field.behavior.required) {\n                                valid = false;\n                            }\n                        }\n                    }\n                }\n            }\n        }\n        if (!valid) {\n            this._snackBarService.openErrorSnackBar(this._translate.instant('tasks.snackbar.missingRequired'));\n        }\n        return valid;\n    }\n\n    /**\n     * Changes the blocking state of all fields in the managed Task.\n     * @param blockingState whether the field should be blocked or not\n     */\n    public blockFields(blockingState: boolean): void {\n        if (this._task && this._task.dataGroups) {\n            this._task.dataGroups.forEach(group => {\n                group.fields.forEach(field => {\n                    field.block = blockingState;\n                });\n            });\n        }\n    }\n\n    /**\n     * Clears the assignee, start date and finish date from the managed Task.\n     */\n    public updateStateData(eventOutcome: TaskEventOutcome): void {\n        if (this._task) {\n            this._task.user = eventOutcome.task.user;\n            this._task.startDate = eventOutcome.task.startDate;\n            this._task.finishDate = eventOutcome.task.finishDate;\n        }\n    }\n\n    /**\n     * Updates the properties of fields in the managed task based on a delta of changes from previous state.\n     * @param chFields object containing the delta of the changes from the previous state\n     */\n    public updateFromChangedFields(chFields: ChangedFields): void {\n        if (!this._task || !this._task.dataGroups) {\n            return;\n        }\n        // todo actions owner zbytočný?\n        const frontendActions = chFields.taskId === this.task.stringId && chFields[TaskContentService.FRONTEND_ACTIONS_KEY];\n\n        Object.keys(chFields).forEach(changedField => {\n            if (!!this.taskFieldsIndex[chFields.taskId] && !!this.taskFieldsIndex[chFields.taskId][changedField]) {\n                this.updateField(chFields, this.taskFieldsIndex[chFields.taskId][changedField], frontendActions);\n            }\n        });\n\n        this.$shouldCreate.next(this._task.dataGroups);\n        this.performFrontendAction(frontendActions);\n    }\n\n    private updateField(chFields: ChangedFields, field: DataField<any>, frontendActions: Change): void {\n        if (this._fieldConverterService.resolveType(field) === FieldTypeResource.TASK_REF) {\n            this._taskDataReloadRequest$.next(frontendActions ? frontendActions : undefined);\n            return;\n        }\n\n        const updatedField = chFields[field.stringId];\n        Object.keys(updatedField).forEach(key => {\n            switch (key) {\n                case 'type':\n                    // type is just an information, not an update. A field cannot change its type\n                    return; // continue - the field does not need updating, since nothing changed\n                case 'value':\n                    field.valueWithoutChange(this._fieldConverterService.formatValueFromBackend(field, updatedField[key]));\n                    break;\n                case 'behavior':\n                    if (updatedField.behavior[this._task.transitionId]) {\n                        // TODO NGSD-489 fix behavior resolution\n                        field.behavior = updatedField.behavior[this._task.transitionId];\n                    } else {\n                        // ignore the behavior update, since it does not affect this task\n                        return; // continue - the field does not need updating, since nothing changed\n                    }\n                    break;\n                case 'choices':\n                    const newChoices: Array<EnumerationFieldValue> = [];\n                    if (updatedField.choices instanceof Array) {\n                        updatedField.choices.forEach(it => {\n                            newChoices.push({key: it, value: it} as EnumerationFieldValue);\n                        });\n                    } else {\n                        Object.keys(updatedField.choices).forEach(choiceKey => {\n                            newChoices.push({\n                                key: choiceKey,\n                                value: updatedField.choices[choiceKey]\n                            } as EnumerationFieldValue);\n                        });\n                    }\n                    (field as EnumerationField | MultichoiceField).choices = newChoices;\n                    break;\n                case 'options':\n                    const newOptions = [];\n                    Object.keys(updatedField.options).forEach(optionKey => {\n                        newOptions.push({key: optionKey, value: updatedField.options[optionKey]});\n                    });\n                    (field as EnumerationField | MultichoiceField).choices = newOptions;\n                    break;\n                case 'validations':\n                    field.replaceValidations(updatedField.validations.map(it => (it as Validation)));\n                    break;\n                default:\n                    field[key] = updatedField[key];\n\n            }\n            field.update();\n        });\n    }\n\n    /**\n     * Performs the specific frontend action.\n     *\n     * A prototype implementation of frontend actions.\n     *\n     * The specifics are subject to change. It is very likely that this method will be moved to a different service.\n     *\n     * @param frontendAction the action that should be performed.\n     */\n    public performFrontendAction(frontendAction: FrontendActions): void {\n        if (frontendAction && frontendAction.type === TaskContentService.VALIDATE_FRONTEND_ACTION) {\n            timer().subscribe(() => this.validateTaskData());\n        }\n    }\n}\n"]}

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

@@ -0,0 +1,54 @@
+import { __extends } from "tslib";
+import { Injectable } from '@angular/core';
+import { TaskContentService } from './task-content.service';
+import { TaskHandlingService } from '../../task/services/task-handling-service';
+import { Subject } from 'rxjs';
+/**
+ * Holds logic about the available operations on a {@link Task} object based on it's state.
+ *
+ * Beware that it gets the Task from (@link TaskContentService) instance and thus the task might not be always initialized.
+ * If the task is not initialized this class cannot work properly.
+ */
+var TaskEventService = /** @class */ (function (_super) {
+    __extends(TaskEventService, _super);
+    function TaskEventService(_taskContentService) {
+        var _this = _super.call(this, _taskContentService) || this;
+        _this._taskEventNotifications$ = new Subject();
+        return _this;
+    }
+    /**
+     * Completes the stream
+     */
+    TaskEventService.prototype.ngOnDestroy = function () {
+        this._taskEventNotifications$.complete();
+    };
+    Object.defineProperty(TaskEventService.prototype, "taskEventNotifications$", {
+        /**
+         * Provides information about results of events executed on the managed {@link Task}
+         */
+        get: function () {
+            return this._taskEventNotifications$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Emits a new {@link TaskEventNotification} into the notifications stream
+     * @param event the event information that will be pushed into the stream
+     */
+    TaskEventService.prototype.publishTaskEvent = function (event) {
+        this._taskEventNotifications$.next(event);
+    };
+    TaskEventService.ctorParameters = function () { return [
+        { type: TaskContentService }
+    ]; };
+    TaskEventService.decorators = [
+        { type: Injectable }
+    ];
+    TaskEventService.ctorParameters = function () { return [
+        { type: TaskContentService }
+    ]; };
+    return TaskEventService;
+}(TaskHandlingService));
+export { TaskEventService };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,77 @@
+import { __extends } from "tslib";
+import { Injectable } from '@angular/core';
+import { TaskContentService } from './task-content.service';
+import { ReplaySubject } from 'rxjs';
+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';
+/**
+ * Provides an implementation of the {@link TaskContentService} abstract class that allows
+ * an unlimited number of calls to the setter of the managed Task object.
+ *
+ * If you want to limit the number of calls to 1 use {@link SingleTaskContentService} instead.
+ */
+var UnlimitedTaskContentService = /** @class */ (function (_super) {
+    __extends(UnlimitedTaskContentService, _super);
+    function UnlimitedTaskContentService(_fieldConverterService, _snackBarService, _translate, _logger) {
+        var _this = _super.call(this, _fieldConverterService, _snackBarService, _translate, _logger) || this;
+        _this._task$ = new ReplaySubject(1);
+        return _this;
+    }
+    Object.defineProperty(UnlimitedTaskContentService.prototype, "task", {
+        /**
+         * @returns the Task object if set and `undefined` otherwise
+         */
+        get: function () {
+            return this._task;
+        },
+        /**
+         * Setting a Task also emits it into the stream accessible by the [task$]{@link TaskContentService#task$} getter method.
+         * @param task the Task that owns the content managed by this service
+         */
+        set: function (task) {
+            this._task = task;
+            this._task$.next(task);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UnlimitedTaskContentService.prototype, "task$", {
+        /**
+         * Stream returns a {@link Task} object every time this object is set.
+         *
+         * 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.
+     */
+    UnlimitedTaskContentService.prototype.ngOnDestroy = function () {
+        _super.prototype.ngOnDestroy.call(this);
+        this._task$.complete();
+    };
+    UnlimitedTaskContentService.ctorParameters = function () { return [
+        { type: FieldConverterService },
+        { type: SnackBarService },
+        { type: TranslateService },
+        { type: LoggerService }
+    ]; };
+    UnlimitedTaskContentService.decorators = [
+        { type: Injectable }
+    ];
+    UnlimitedTaskContentService.ctorParameters = function () { return [
+        { type: FieldConverterService },
+        { type: SnackBarService },
+        { type: TranslateService },
+        { type: LoggerService }
+    ]; };
+    return UnlimitedTaskContentService;
+}(TaskContentService));
+export { UnlimitedTaskContentService };
+//# sourceMappingURL=data:application/json;base64,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