@netgrif/components-core 6.0.1

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

@@ -0,0 +1,597 @@
+import { __extends, __values } from "tslib";
+import { Inject, Injectable, Optional } from '@angular/core';
+import { Subject } from 'rxjs';
+import { TaskContentService } from '../../task-content/services/task-content.service';
+import { TaskRequestStateService } from './task-request-state.service';
+import { TranslateService } from '@ngx-translate/core';
+import { LoggerService } from '../../logger/services/logger.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { TaskResourceService } from '../../resources/engine-endpoint/task-resource.service';
+import { FieldConverterService } from '../../task-content/services/field-converter.service';
+import { TaskHandlingService } from './task-handling-service';
+import { NAE_TASK_OPERATIONS } from '../models/task-operations-injection-token';
+import { FileField } from '../../data-fields/file-field/models/file-field';
+import { SelectedCaseService } from './selected-case.service';
+import { FileListField } from '../../data-fields/file-list-field/models/file-list-field';
+import { createTaskEventNotification } from '../../task-content/model/task-event-notification';
+import { TaskEvent } from '../../task-content/model/task-event';
+import { TaskEventService } from '../../task-content/services/task-event.service';
+import { CallChainService } from '../../utility/call-chain/call-chain.service';
+import { take } from 'rxjs/operators';
+import { DynamicEnumerationField } from '../../data-fields/enumeration-field/models/dynamic-enumeration-field';
+import { EventQueueService } from '../../event-queue/services/event-queue.service';
+import { QueuedEvent } from '../../event-queue/model/queued-event';
+import { AfterAction } from '../../utility/call-chain/after-action';
+import { UserComparatorService } from '../../user/services/user-comparator.service';
+import { EventService } from '../../event/services/event.service';
+import { ChangedFieldsService } from '../../changed-fields/services/changed-fields.service';
+/**
+ * Handles the loading and updating of data fields and behaviour of
+ * a single Task object managed by a {@link TaskContentService} instance.
+ */
+var TaskDataService = /** @class */ (function (_super) {
+    __extends(TaskDataService, _super);
+    function TaskDataService(_taskState, _translate, _log, _snackBar, _taskResourceService, _fieldConverterService, _taskEvent, _taskOperations, _selectedCaseService, _taskContentService, _afterActionFactory, _eventQueue, _userComparator, _eventService, _changedFieldsService) {
+        var _this = _super.call(this, _taskContentService, _selectedCaseService) || this;
+        _this._taskState = _taskState;
+        _this._translate = _translate;
+        _this._log = _log;
+        _this._snackBar = _snackBar;
+        _this._taskResourceService = _taskResourceService;
+        _this._fieldConverterService = _fieldConverterService;
+        _this._taskEvent = _taskEvent;
+        _this._taskOperations = _taskOperations;
+        _this._afterActionFactory = _afterActionFactory;
+        _this._eventQueue = _eventQueue;
+        _this._userComparator = _userComparator;
+        _this._eventService = _eventService;
+        _this._changedFieldsService = _changedFieldsService;
+        _this._updateSuccess$ = new Subject();
+        _this._dataReloadSubscription = _this._taskContentService.taskDataReloadRequest$.subscribe(function (queuedFrontendAction) {
+            _this.initializeTaskDataFields(_this._afterActionFactory.create(function (success) {
+                if (success && queuedFrontendAction) {
+                    _this._taskContentService.performFrontendAction(queuedFrontendAction);
+                }
+            }), true);
+        });
+        return _this;
+    }
+    TaskDataService.prototype.ngOnDestroy = function () {
+        this._updateSuccess$.complete();
+        this._dataReloadSubscription.unsubscribe();
+        if (this.isTaskPresent() && this._safeTask.dataGroups) {
+            this._safeTask.dataGroups.forEach(function (group) {
+                if (group && group.fields) {
+                    group.fields.forEach(function (field) { return field.destroy(); });
+                }
+            });
+        }
+    };
+    Object.defineProperty(TaskDataService.prototype, "updateSuccess$", {
+        /**
+         * Contains information about the success or failure of backend
+         * calls in [updateTaskDataFields]{@link TaskDataService#updateTaskDataFields} method.
+         */
+        get: function () {
+            return this._updateSuccess$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Loads the Data Fields of an uninitialized Task from backend
+     * and populates the Task managed by {@link TaskContentService} with the appropriate objects.
+     *
+     * Beware that if the Task has some data already loaded this function does nothing
+     * and only passes `true` to the `afterAction` argument.
+     *
+     * If the task held within the {@link TaskContentService} changes before a response is received, the response will be ignored
+     * and the `afterAction` will not be executed.
+     *
+     * @param afterAction if the request completes successfully emits `true` into the Subject, otherwise `false` will be emitted
+     * @param force set to `true` if you need force reload of all task data
+     */
+    TaskDataService.prototype.initializeTaskDataFields = function (afterAction, force) {
+        var _this = this;
+        if (afterAction === void 0) { afterAction = new AfterAction(); }
+        if (force === void 0) { force = false; }
+        this._eventQueue.scheduleEvent(new QueuedEvent(function () {
+            return _this.isTaskPresent();
+        }, function (nextEvent) {
+            _this.performGetDataRequest(afterAction, force, nextEvent);
+        }, function (nextEvent) {
+            afterAction.resolve(false);
+            nextEvent.resolve(false);
+        }));
+    };
+    /**
+     * Performs a `getData` request on the task currently stored in the `taskContent` service
+     * @param afterAction the action that should be performed after the request is processed
+     * @param force set to `true` if you need force reload of all task data
+     * @param nextEvent indicates to the event queue that the next event can be processed
+     */
+    TaskDataService.prototype.performGetDataRequest = function (afterAction, force, nextEvent) {
+        var _this = this;
+        if (this._safeTask.dataSize > 0 && !force) {
+            this.sendNotification(TaskEvent.GET_DATA, true);
+            afterAction.resolve(true);
+            this._taskContentService.$shouldCreate.next(this._safeTask.dataGroups);
+            nextEvent.resolve(true);
+            return;
+        }
+        if (force) {
+            this._safeTask.dataSize = 0;
+        }
+        var gottenTaskId = this._safeTask.stringId;
+        this._taskState.startLoading(gottenTaskId);
+        this._taskResourceService.getData(gottenTaskId).pipe(take(1)).subscribe(function (dataGroups) {
+            _this.processSuccessfulGetDataRequest(gottenTaskId, dataGroups, afterAction, nextEvent);
+        }, function (error) {
+            _this.processErroneousGetDataRequest(gottenTaskId, error, afterAction, nextEvent);
+        });
+    };
+    /**
+     * Processes a successful outcome of a `getData` request
+     * @param gottenTaskId the Id of the task whose data was requested
+     * @param dataGroups the returned data groups of the task
+     * @param afterAction the action that should be performed after the request is processed
+     * @param nextEvent indicates to the event queue that the next event can be processed
+     */
+    TaskDataService.prototype.processSuccessfulGetDataRequest = function (gottenTaskId, dataGroups, afterAction, nextEvent) {
+        var _this = this;
+        if (!this.isTaskRelevant(gottenTaskId)) {
+            this._log.debug('current task changed before the get data response could be received, discarding...');
+            this._taskState.stopLoading(gottenTaskId);
+            afterAction.complete();
+            nextEvent.resolve(false);
+            return;
+        }
+        this._taskContentService.referencedTaskAndCaseIds = {};
+        this._taskContentService.taskFieldsIndex = {};
+        this._safeTask.dataGroups = dataGroups;
+        if (dataGroups.length === 0) {
+            this._log.info('Task has no data ' + this._safeTask);
+            this._safeTask.dataSize = 0;
+        }
+        else {
+            this._taskContentService.referencedTaskAndCaseIds[this._safeTask.caseId] = [this._safeTask.stringId];
+            dataGroups.forEach(function (group) {
+                var dataGroupParentCaseId = group.parentCaseId === undefined ? _this._safeTask.caseId : group.parentCaseId;
+                var parentTaskId = group.parentTaskId === undefined ? _this._safeTask.stringId : group.parentTaskId;
+                if (dataGroupParentCaseId !== _this._safeTask.caseId) {
+                    if (!_this._taskContentService.referencedTaskAndCaseIds[dataGroupParentCaseId]) {
+                        _this._taskContentService.referencedTaskAndCaseIds[dataGroupParentCaseId] = [group.parentTaskId];
+                    }
+                    else {
+                        _this._taskContentService.referencedTaskAndCaseIds[dataGroupParentCaseId].push(group.parentTaskId);
+                    }
+                }
+                else if (dataGroupParentCaseId === _this._safeTask.caseId
+                    && parentTaskId !== _this._safeTask.stringId
+                    && !_this._taskContentService.referencedTaskAndCaseIds[dataGroupParentCaseId].includes(parentTaskId)) {
+                    _this._taskContentService.referencedTaskAndCaseIds[dataGroupParentCaseId].push(group.parentTaskId);
+                }
+                if (group.fields.length > 0 && !_this._taskContentService.taskFieldsIndex[parentTaskId]) {
+                    _this._taskContentService.taskFieldsIndex[parentTaskId] = {};
+                }
+                group.fields.forEach(function (field) {
+                    _this._taskContentService.taskFieldsIndex[parentTaskId][field.stringId] = field;
+                    field.valueChanges().subscribe(function () {
+                        if (_this.wasFieldUpdated(field)) {
+                            if (field instanceof DynamicEnumerationField) {
+                                field.loading = true;
+                                _this.updateTaskDataFields(_this._afterActionFactory.create(function (bool) {
+                                    field.loading = false;
+                                }));
+                            }
+                            else {
+                                _this.updateTaskDataFields();
+                            }
+                        }
+                    });
+                    if (field instanceof FileField || field instanceof FileListField) {
+                        field.changedFields$.subscribe(function (change) {
+                            _this._changedFieldsService.emitChangedFields(change);
+                        });
+                    }
+                });
+                _this._safeTask.dataSize === undefined ?
+                    _this._safeTask.dataSize = group.fields.length :
+                    _this._safeTask.dataSize += group.fields.length;
+            });
+        }
+        this._taskState.stopLoading(gottenTaskId);
+        this.sendNotification(TaskEvent.GET_DATA, true);
+        afterAction.resolve(true);
+        nextEvent.resolve(true);
+        this._taskContentService.$shouldCreate.next(this._safeTask.dataGroups);
+        this._taskContentService.$shouldCreateCounter.next(this._taskContentService.$shouldCreateCounter.getValue() + 1);
+    };
+    /**
+     * Processes an erroneous outcome of a `getData` request
+     * @param gottenTaskId the Id of the task whose data was requested
+     * @param error the returned error
+     * @param afterAction the action that should be performed after the request is processed
+     * @param nextEvent indicates to the event queue that the next event can be processed
+     */
+    TaskDataService.prototype.processErroneousGetDataRequest = function (gottenTaskId, error, afterAction, nextEvent) {
+        this._taskState.stopLoading(gottenTaskId);
+        this._log.debug('getting task data failed', error);
+        if (!this.isTaskRelevant(gottenTaskId)) {
+            this._log.debug('current task changed before the get data error could be received');
+            afterAction.complete();
+            nextEvent.resolve(false);
+            return;
+        }
+        if (error.status === 500 && error.error.message && error.error.message.startsWith('Could not find task with id')) {
+            this._snackBar.openWarningSnackBar(this._translate.instant('tasks.snackbar.noLongerExists'));
+            this._taskOperations.reload();
+        }
+        else {
+            this._snackBar.openErrorSnackBar(this._translate.instant('tasks.snackbar.noGroup') + "\n                        " + this._taskContentService.task.title + " " + this._translate.instant('tasks.snackbar.failedToLoad'));
+        }
+        this.sendNotification(TaskEvent.GET_DATA, false);
+        afterAction.resolve(false);
+        nextEvent.resolve(false);
+    };
+    /**
+     * Collects all changed data fields and notifies the backend of the changes.
+     *
+     * If the request is successful clears the [changed]{@link DataField#changed} flag on all data fields that were a part of the request
+     * and emits a {@link ChangedFields} object into this object's [changedFields$]{@link TaskDataService#changedFields$} stream.
+     *
+     * If the task held within the {@link TaskContentService} changes before a response is received, the response will be ignored
+     * and the `afterAction` will not be executed.
+     *
+     * @param afterAction if the request completes successfully emits `true` into the Subject, otherwise `false` will be emitted
+     */
+    TaskDataService.prototype.updateTaskDataFields = function (afterAction) {
+        var _this = this;
+        if (afterAction === void 0) { afterAction = new AfterAction(); }
+        if (!this.isTaskPresent()) {
+            this._log.debug('Task is not present. Update request ignored.');
+            afterAction.resolve(false);
+            return;
+        }
+        if (this._safeTask.user === undefined) {
+            this._log.debug('current task is not assigned...');
+            afterAction.resolve(false);
+            return;
+        }
+        var setTaskId = this._safeTask.stringId;
+        if (this._safeTask.dataSize <= 0) {
+            afterAction.resolve(true);
+            return;
+        }
+        var requestContext = this.createUpdateRequestContext();
+        this._eventQueue.scheduleEvent(new QueuedEvent(function () { return _this.isSetDataRequestStillValid(requestContext.body); }, function (nextEvent) {
+            _this.performSetDataRequest(setTaskId, requestContext.body, afterAction, nextEvent);
+        }, function (nextEvent) {
+            _this.revertSetDataRequest(requestContext);
+            nextEvent.resolve(false);
+        }));
+    };
+    /**
+     * @ignore
+     * Goes over all the data fields in the managed Task and if they are valid and changed adds them to the set data request
+     */
+    TaskDataService.prototype.createUpdateRequestContext = function () {
+        var _this = this;
+        var context = {
+            body: {},
+            previousValues: {}
+        };
+        context.body[this._task.stringId] = {};
+        this._safeTask.dataGroups.filter(function (dataGroup) { return dataGroup.parentTaskId === undefined; }).forEach(function (dataGroup) {
+            dataGroup.fields.filter(function (field) { return _this.wasFieldUpdated(field); }).forEach(function (field) {
+                _this.addFieldToSetDataRequestBody(context, _this._task.stringId, field);
+            });
+        });
+        this._safeTask.dataGroups.filter(function (dataGroup) { return dataGroup.parentTaskId !== undefined; }).forEach(function (dataGroup) {
+            if (dataGroup.fields.some(function (field) { return _this.wasFieldUpdated(field); })) {
+                context.body[dataGroup.parentTaskId] = {};
+            }
+            else {
+                return;
+            }
+            dataGroup.fields.filter(function (field) { return _this.wasFieldUpdated(field); }).forEach(function (field) {
+                _this.addFieldToSetDataRequestBody(context, dataGroup.parentTaskId, field);
+            });
+        });
+        return context;
+    };
+    TaskDataService.prototype.addFieldToSetDataRequestBody = function (context, taskId, field) {
+        context.body[taskId][field.stringId] = {
+            type: this._fieldConverterService.resolveType(field),
+            value: this._fieldConverterService.formatValueForBackend(field, field.value)
+        };
+        context.previousValues[field.stringId] = field.previousValue;
+        field.changed = false;
+    };
+    /**
+     * @param field the checked field
+     * @returns whether the field was updated on frontend and thus the backend should be notified
+     */
+    TaskDataService.prototype.wasFieldUpdated = function (field) {
+        return field.initialized && field.changed && (field.valid || field.sendInvalidValues);
+    };
+    /**
+     * Checks whether the request could still be performed by the logged user
+     * @param request
+     */
+    TaskDataService.prototype.isSetDataRequestStillValid = function (request) {
+        var e_1, _a, e_2, _b;
+        if (!this.isTaskPresent()) {
+            return false;
+        }
+        if (this._safeTask.user === undefined) {
+            return false;
+        }
+        if (!this._userComparator.compareUsers(this._safeTask.user)) {
+            return false;
+        }
+        var taskIdsInRequest = Object.keys(request);
+        try {
+            for (var taskIdsInRequest_1 = __values(taskIdsInRequest), taskIdsInRequest_1_1 = taskIdsInRequest_1.next(); !taskIdsInRequest_1_1.done; taskIdsInRequest_1_1 = taskIdsInRequest_1.next()) {
+                var taskId = taskIdsInRequest_1_1.value;
+                if (!Object.keys(this._taskContentService.taskFieldsIndex).includes(taskId)) {
+                    this._log.error("Task id " + taskId + " is not present in task fields index");
+                    return false;
+                }
+                var fieldIdsOfRequest = Object.keys(request[taskId]);
+                try {
+                    for (var fieldIdsOfRequest_1 = (e_2 = void 0, __values(fieldIdsOfRequest)), fieldIdsOfRequest_1_1 = fieldIdsOfRequest_1.next(); !fieldIdsOfRequest_1_1.done; fieldIdsOfRequest_1_1 = fieldIdsOfRequest_1.next()) {
+                        var fieldId = fieldIdsOfRequest_1_1.value;
+                        var field = this._taskContentService.taskFieldsIndex[taskId][fieldId];
+                        if (field === undefined) {
+                            this._log.error("Unexpected state. Datafield " + fieldId + " of task " + taskId + " in setData request is not present in the task.");
+                            return false;
+                        }
+                        if (!field.behavior.editable) {
+                            this._log.debug("Field " + fieldId + ", was meant to be set to\n                    " + JSON.stringify(request[taskId][fieldId]) + ", but is no loner editable.");
+                            return false;
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (fieldIdsOfRequest_1_1 && !fieldIdsOfRequest_1_1.done && (_b = fieldIdsOfRequest_1.return)) _b.call(fieldIdsOfRequest_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (taskIdsInRequest_1_1 && !taskIdsInRequest_1_1.done && (_a = taskIdsInRequest_1.return)) _a.call(taskIdsInRequest_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return true;
+    };
+    /**
+     * Performs a `setData` request on the task currently stored in the `taskContent` service
+     * @param setTaskId id of the task
+     * @param body content of the `setData` request
+     * @param afterAction the action that should be performed after the request is processed
+     * @param nextEvent indicates to the event queue that the next event can be processed
+     */
+    TaskDataService.prototype.performSetDataRequest = function (setTaskId, body, afterAction, nextEvent) {
+        var _this = this;
+        if (Object.keys(body).length === 0) {
+            this.sendNotification(TaskEvent.SET_DATA, true);
+            afterAction.resolve(true);
+            nextEvent.resolve(true);
+            return;
+        }
+        this._taskState.startLoading(setTaskId);
+        this._taskState.startUpdating(setTaskId);
+        this._taskResourceService.setData(this._safeTask.stringId, body).pipe(take(1))
+            .subscribe(function (response) {
+            _this.processSuccessfulSetDataRequest(setTaskId, response.outcome, afterAction, nextEvent, body);
+        }, function (error) {
+            _this.processErroneousSetDataRequest(setTaskId, error, afterAction, nextEvent, body);
+        });
+    };
+    /**
+     * Processes a successful outcome of a `setData` request
+     * @param setTaskId the Id of the task whose data was set
+     * @param response the resulting Event outcome of the set data request
+     * @param afterAction the action that should be performed after the request is processed
+     * @param nextEvent indicates to the event queue that the next event can be processed
+     * @param body hold the data that was sent in request
+     */
+    TaskDataService.prototype.processSuccessfulSetDataRequest = function (setTaskId, response, afterAction, nextEvent, body) {
+        if (!this.isTaskRelevant(setTaskId)) {
+            this._log.debug('current task changed before the set data response could be received, discarding...');
+            this._taskState.stopLoading(setTaskId);
+            this._taskState.stopUpdating(setTaskId);
+            afterAction.complete();
+            nextEvent.resolve(false);
+            return;
+        }
+        var changedFieldsMap = this._eventService.parseChangedFieldsFromOutcomeTree(response);
+        if (Object.keys(changedFieldsMap).length > 0) {
+            this._changedFieldsService.emitChangedFields(changedFieldsMap);
+        }
+        this.clearWaitingForResponseFlag(body);
+        this._snackBar.openSuccessSnackBar(!!response.message ? response.message : this._translate.instant('tasks.snackbar.dataSaved'));
+        this.updateStateInfo(afterAction, true, setTaskId);
+        nextEvent.resolve(true);
+    };
+    /**
+     * Processes an erroneous outcome of a `setData` request
+     * @param setTaskId the Id of the task whose data was set
+     * @param error the returned error
+     * @param afterAction the action that should be performed after the request is processed
+     * @param nextEvent indicates to the event queue that the next event can be processed
+     * @param body hold the data that was sent in request
+     */
+    TaskDataService.prototype.processErroneousSetDataRequest = function (setTaskId, error, afterAction, nextEvent, body) {
+        this._log.debug('setting task data failed', error);
+        if (!this.isTaskRelevant(setTaskId)) {
+            this._log.debug('current task changed before the get data error could be received');
+            this._taskState.stopLoading(setTaskId);
+            this._taskState.stopUpdating(setTaskId);
+            afterAction.complete();
+            nextEvent.resolve(false);
+            return;
+        }
+        this.revertToPreviousValue();
+        this.clearWaitingForResponseFlag(body);
+        this._snackBar.openErrorSnackBar(this._translate.instant('tasks.snackbar.failedSave'));
+        this.updateStateInfo(afterAction, false, setTaskId);
+        nextEvent.resolve(false);
+        this._taskOperations.reload();
+    };
+    /**
+     * Reverts the effects of a failed `setData` request, so that the user sees current values.
+     * @param context the context of the failed request
+     */
+    TaskDataService.prototype.revertSetDataRequest = function (context) {
+        var e_3, _a, e_4, _b;
+        // this iteration could be improved if we had a map of all the data fields in a task
+        var totalCount = Object.keys(context.body).length;
+        var foundCount = 0;
+        try {
+            for (var _c = __values(this._safeTask.dataGroups), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var datagroup = _d.value;
+                try {
+                    for (var _e = (e_4 = void 0, __values(datagroup.fields)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var field = _f.value;
+                        if (!context.body[field.stringId]) {
+                            continue;
+                        }
+                        if (this.compareBackendFormattedFieldValues(this._fieldConverterService.formatValueForBackend(field, field.value), context.body[field.stringId].value)) {
+                            field.valueWithoutChange(context.previousValues[field.stringId]);
+                        }
+                        foundCount++;
+                        if (foundCount === totalCount) {
+                            return;
+                        }
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        this._log.error("Invalid state. Some data fields of task " + this._safeTask.stringId + ", are no longer present in it!");
+    };
+    /**
+     * Compares the values that are in the backend compatible format as given by the {@link FieldConverterService}
+     * and determines whether they are the same value, or not.
+     * @param current the current value (can also be called `value1` or `left`)
+     * @param old the new value (can also be called `value2` or `right`)
+     * @returns `true` if the values are the same and `false` otherwise
+     */
+    TaskDataService.prototype.compareBackendFormattedFieldValues = function (current, old) {
+        if (Array.isArray(current)) {
+            if (!Array.isArray(old)) {
+                throw new Error('Illegal arguments! Cannot compare array value to non-array value');
+            }
+            if (current.length !== old.length) {
+                return false;
+            }
+            return current.every(function (value, index) { return old[index] === value; });
+        }
+        return current === old;
+    };
+    /**
+     * @ignore
+     *
+     * stops loading and updating indicators, and emits the `result` value
+     * to both the `afterAction` and [_updateSuccess$]{@link TaskDataService#_updateSuccess$} streams.
+     *
+     * @param afterAction the call chain steam of the update data method
+     * @param result result of the update data request
+     * @param setTaskId the Id of the {@link Task}, who's state should be updated
+     */
+    TaskDataService.prototype.updateStateInfo = function (afterAction, result, setTaskId) {
+        this._taskState.stopLoading(setTaskId);
+        this._taskState.stopUpdating(setTaskId);
+        if (this._updateSuccess$.observers.length !== 0) {
+            this._updateSuccess$.next(result);
+        }
+        this.sendNotification(TaskEvent.SET_DATA, result);
+        afterAction.resolve(result);
+    };
+    /**
+     * Publishes a get/set data notification to the {@link TaskEventService}
+     * @param event the event that occurred to the task
+     * @param success whether the get/set data operation was successful or not
+     */
+    TaskDataService.prototype.sendNotification = function (event, success) {
+        this._taskEvent.publishTaskEvent(createTaskEventNotification(this._safeTask, event, success));
+    };
+    TaskDataService.prototype.revertToPreviousValue = function () {
+        this._safeTask.dataGroups.forEach(function (dataGroup) {
+            dataGroup.fields.forEach(function (field) {
+                if (field.initialized && field.valid && field.changed) {
+                    field.revertToPreviousValue();
+                }
+            });
+        });
+    };
+    TaskDataService.prototype.clearWaitingForResponseFlag = function (body) {
+        var _this = this;
+        Object.keys(body).forEach(function (taskId) {
+            Object.keys(body[taskId]).forEach(function (fieldId) {
+                _this._taskContentService.taskFieldsIndex[taskId][fieldId].waitingForResponse = false;
+            });
+        });
+    };
+    TaskDataService.ctorParameters = function () { return [
+        { type: TaskRequestStateService },
+        { type: TranslateService },
+        { type: LoggerService },
+        { type: SnackBarService },
+        { type: TaskResourceService },
+        { type: FieldConverterService },
+        { type: TaskEventService },
+        { type: undefined, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] },
+        { type: SelectedCaseService, decorators: [{ type: Optional }] },
+        { type: TaskContentService },
+        { type: CallChainService },
+        { type: EventQueueService },
+        { type: UserComparatorService },
+        { type: EventService },
+        { type: ChangedFieldsService }
+    ]; };
+    TaskDataService.decorators = [
+        { type: Injectable }
+    ];
+    TaskDataService.ctorParameters = function () { return [
+        { type: TaskRequestStateService },
+        { type: TranslateService },
+        { type: LoggerService },
+        { type: SnackBarService },
+        { type: TaskResourceService },
+        { type: FieldConverterService },
+        { type: TaskEventService },
+        { type: undefined, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] },
+        { type: SelectedCaseService, decorators: [{ type: Optional }] },
+        { type: TaskContentService },
+        { type: CallChainService },
+        { type: EventQueueService },
+        { type: UserComparatorService },
+        { type: EventService },
+        { type: ChangedFieldsService }
+    ]; };
+    return TaskDataService;
+}(TaskHandlingService));
+export { TaskDataService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-data.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/task/services/task-data.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, OnDestroy, Optional} from '@angular/core';\nimport {Observable, Subject, Subscription} from 'rxjs';\nimport {ChangedFields} from '../../data-fields/models/changed-fields';\nimport {TaskContentService} from '../../task-content/services/task-content.service';\nimport {TaskRequestStateService} from './task-request-state.service';\nimport {TranslateService} from '@ngx-translate/core';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {SnackBarService} from '../../snack-bar/services/snack-bar.service';\nimport {TaskResourceService} from '../../resources/engine-endpoint/task-resource.service';\nimport {FieldConverterService} from '../../task-content/services/field-converter.service';\nimport {TaskSetDataRequestBody} from '../../resources/interface/task-set-data-request-body';\nimport {TaskHandlingService} from './task-handling-service';\nimport {NAE_TASK_OPERATIONS} from '../models/task-operations-injection-token';\nimport {TaskOperations} from '../interfaces/task-operations';\nimport {HttpErrorResponse} from '@angular/common/http';\nimport {FileField} from '../../data-fields/file-field/models/file-field';\nimport {SelectedCaseService} from './selected-case.service';\nimport {FileListField} from '../../data-fields/file-list-field/models/file-list-field';\nimport {createTaskEventNotification} from '../../task-content/model/task-event-notification';\nimport {TaskEvent} from '../../task-content/model/task-event';\nimport {TaskEventService} from '../../task-content/services/task-event.service';\nimport {DataField} from '../../data-fields/models/abstract-data-field';\nimport {CallChainService} from '../../utility/call-chain/call-chain.service';\nimport {take} from 'rxjs/operators';\nimport {DynamicEnumerationField} from '../../data-fields/enumeration-field/models/dynamic-enumeration-field';\nimport {DataGroup} from '../../resources/interface/data-groups';\nimport {EventQueueService} from '../../event-queue/services/event-queue.service';\nimport {QueuedEvent} from '../../event-queue/model/queued-event';\nimport {AfterAction} from '../../utility/call-chain/after-action';\nimport {UserComparatorService} from '../../user/services/user-comparator.service';\nimport {TaskSetDataRequestContext} from '../models/task-set-data-request-context';\nimport {EventOutcomeMessageResource} from '../../resources/interface/message-resource';\nimport {EventService} from '../../event/services/event.service';\nimport {EventOutcome} from '../../resources/interface/event-outcome';\nimport {ChangedFieldsService} from '../../changed-fields/services/changed-fields.service';\nimport {ChangedFieldsMap} from '../../event/services/interfaces/changed-fields-map';\n\n/**\n * Handles the loading and updating of data fields and behaviour of\n * a single Task object managed by a {@link TaskContentService} instance.\n */\n@Injectable()\nexport class TaskDataService extends TaskHandlingService implements OnDestroy {\n\n    protected _updateSuccess$: Subject<boolean>;\n    protected _dataReloadSubscription: Subscription;\n\n    constructor(protected _taskState: TaskRequestStateService,\n                protected _translate: TranslateService,\n                protected _log: LoggerService,\n                protected _snackBar: SnackBarService,\n                protected _taskResourceService: TaskResourceService,\n                protected _fieldConverterService: FieldConverterService,\n                protected _taskEvent: TaskEventService,\n                @Inject(NAE_TASK_OPERATIONS) protected _taskOperations: TaskOperations,\n                @Optional() _selectedCaseService: SelectedCaseService,\n                _taskContentService: TaskContentService,\n                protected _afterActionFactory: CallChainService,\n                protected _eventQueue: EventQueueService,\n                protected _userComparator: UserComparatorService,\n                protected _eventService: EventService,\n                protected _changedFieldsService: ChangedFieldsService) {\n        super(_taskContentService, _selectedCaseService);\n        this._updateSuccess$ = new Subject<boolean>();\n        this._dataReloadSubscription = this._taskContentService.taskDataReloadRequest$.subscribe(queuedFrontendAction => {\n            this.initializeTaskDataFields(this._afterActionFactory.create(success => {\n                if (success && queuedFrontendAction) {\n                    this._taskContentService.performFrontendAction(queuedFrontendAction);\n                }\n            }), true);\n        });\n    }\n\n    ngOnDestroy(): void {\n        this._updateSuccess$.complete();\n        this._dataReloadSubscription.unsubscribe();\n        if (this.isTaskPresent() && this._safeTask.dataGroups) {\n            this._safeTask.dataGroups.forEach(group => {\n                if (group && group.fields) {\n                    group.fields.forEach(field => field.destroy());\n                }\n            });\n        }\n    }\n\n    /**\n     * Contains information about the success or failure of backend\n     * calls in [updateTaskDataFields]{@link TaskDataService#updateTaskDataFields} method.\n     */\n    public get updateSuccess$(): Observable<boolean> {\n        return this._updateSuccess$.asObservable();\n    }\n\n    /**\n     * Loads the Data Fields of an uninitialized Task from backend\n     * and populates the Task managed by {@link TaskContentService} with the appropriate objects.\n     *\n     * Beware that if the Task has some data already loaded this function does nothing\n     * and only passes `true` to the `afterAction` argument.\n     *\n     * If the task held within the {@link TaskContentService} changes before a response is received, the response will be ignored\n     * and the `afterAction` will not be executed.\n     *\n     * @param afterAction if the request completes successfully emits `true` into the Subject, otherwise `false` will be emitted\n     * @param force set to `true` if you need force reload of all task data\n     */\n    public initializeTaskDataFields(afterAction: AfterAction = new AfterAction(), force = false): void {\n        this._eventQueue.scheduleEvent(new QueuedEvent(\n            () => {\n                return this.isTaskPresent();\n            },\n            nextEvent => {\n                this.performGetDataRequest(afterAction, force, nextEvent);\n            }, nextEvent => {\n                afterAction.resolve(false);\n                nextEvent.resolve(false);\n            }\n        ));\n    }\n\n    /**\n     * Performs a `getData` request on the task currently stored in the `taskContent` service\n     * @param afterAction the action that should be performed after the request is processed\n     * @param force set to `true` if you need force reload of all task data\n     * @param nextEvent indicates to the event queue that the next event can be processed\n     */\n    protected performGetDataRequest(afterAction: AfterAction, force: boolean, nextEvent: AfterAction) {\n        if (this._safeTask.dataSize > 0 && !force) {\n            this.sendNotification(TaskEvent.GET_DATA, true);\n            afterAction.resolve(true);\n            this._taskContentService.$shouldCreate.next(this._safeTask.dataGroups);\n            nextEvent.resolve(true);\n            return;\n        }\n        if (force) {\n            this._safeTask.dataSize = 0;\n        }\n\n        const gottenTaskId = this._safeTask.stringId;\n        this._taskState.startLoading(gottenTaskId);\n\n        this._taskResourceService.getData(gottenTaskId).pipe(take(1)).subscribe(dataGroups => {\n            this.processSuccessfulGetDataRequest(gottenTaskId, dataGroups, afterAction, nextEvent);\n        }, error => {\n            this.processErroneousGetDataRequest(gottenTaskId, error, afterAction, nextEvent);\n        });\n    }\n\n    /**\n     * Processes a successful outcome of a `getData` request\n     * @param gottenTaskId the Id of the task whose data was requested\n     * @param dataGroups the returned data groups of the task\n     * @param afterAction the action that should be performed after the request is processed\n     * @param nextEvent indicates to the event queue that the next event can be processed\n     */\n    protected processSuccessfulGetDataRequest(gottenTaskId: string,\n                                              dataGroups: Array<DataGroup>,\n                                              afterAction: AfterAction,\n                                              nextEvent: AfterAction): void {\n        if (!this.isTaskRelevant(gottenTaskId)) {\n            this._log.debug('current task changed before the get data response could be received, discarding...');\n            this._taskState.stopLoading(gottenTaskId);\n            afterAction.complete();\n            nextEvent.resolve(false);\n            return;\n        }\n        this._taskContentService.referencedTaskAndCaseIds = {};\n        this._taskContentService.taskFieldsIndex = {};\n\n        this._safeTask.dataGroups = dataGroups;\n        if (dataGroups.length === 0) {\n            this._log.info('Task has no data ' + this._safeTask);\n            this._safeTask.dataSize = 0;\n        } else {\n            this._taskContentService.referencedTaskAndCaseIds[this._safeTask.caseId] = [this._safeTask.stringId];\n            dataGroups.forEach(group => {\n                const dataGroupParentCaseId: string = group.parentCaseId === undefined ? this._safeTask.caseId : group.parentCaseId;\n                const parentTaskId: string = group.parentTaskId === undefined ? this._safeTask.stringId : group.parentTaskId;\n                if (dataGroupParentCaseId !== this._safeTask.caseId) {\n                    if (!this._taskContentService.referencedTaskAndCaseIds[dataGroupParentCaseId]) {\n                        this._taskContentService.referencedTaskAndCaseIds[dataGroupParentCaseId] = [group.parentTaskId];\n                    } else {\n                        this._taskContentService.referencedTaskAndCaseIds[dataGroupParentCaseId].push(group.parentTaskId);\n                    }\n                } else if (dataGroupParentCaseId === this._safeTask.caseId\n                    && parentTaskId !== this._safeTask.stringId\n                    && !this._taskContentService.referencedTaskAndCaseIds[dataGroupParentCaseId].includes(parentTaskId)) {\n                    this._taskContentService.referencedTaskAndCaseIds[dataGroupParentCaseId].push(group.parentTaskId);\n                }\n                if (group.fields.length > 0 && !this._taskContentService.taskFieldsIndex[parentTaskId]) {\n                    this._taskContentService.taskFieldsIndex[parentTaskId] = {};\n                }\n                group.fields.forEach(field => {\n                    this._taskContentService.taskFieldsIndex[parentTaskId][field.stringId] = field;\n                    field.valueChanges().subscribe(() => {\n                        if (this.wasFieldUpdated(field)) {\n                            if (field instanceof DynamicEnumerationField) {\n                                field.loading = true;\n                                this.updateTaskDataFields(this._afterActionFactory.create(bool => {\n                                    field.loading = false;\n                                }));\n                            } else {\n                                this.updateTaskDataFields();\n                            }\n                        }\n                    });\n                    if (field instanceof FileField || field instanceof FileListField) {\n                        field.changedFields$.subscribe((change: ChangedFieldsMap) => {\n                            this._changedFieldsService.emitChangedFields(change);\n                        });\n                    }\n                });\n                this._safeTask.dataSize === undefined ?\n                    this._safeTask.dataSize = group.fields.length :\n                    this._safeTask.dataSize += group.fields.length;\n            });\n        }\n        this._taskState.stopLoading(gottenTaskId);\n        this.sendNotification(TaskEvent.GET_DATA, true);\n        afterAction.resolve(true);\n        nextEvent.resolve(true);\n        this._taskContentService.$shouldCreate.next(this._safeTask.dataGroups);\n        this._taskContentService.$shouldCreateCounter.next(this._taskContentService.$shouldCreateCounter.getValue() + 1);\n    }\n\n    /**\n     * Processes an erroneous outcome of a `getData` request\n     * @param gottenTaskId the Id of the task whose data was requested\n     * @param error the returned error\n     * @param afterAction the action that should be performed after the request is processed\n     * @param nextEvent indicates to the event queue that the next event can be processed\n     */\n    protected processErroneousGetDataRequest(gottenTaskId: string,\n                                             error: HttpErrorResponse,\n                                             afterAction: AfterAction,\n                                             nextEvent: AfterAction) {\n        this._taskState.stopLoading(gottenTaskId);\n        this._log.debug('getting task data failed', error);\n\n        if (!this.isTaskRelevant(gottenTaskId)) {\n            this._log.debug('current task changed before the get data error could be received');\n            afterAction.complete();\n            nextEvent.resolve(false);\n            return;\n        }\n\n        if (error.status === 500 && error.error.message && error.error.message.startsWith('Could not find task with id')) {\n            this._snackBar.openWarningSnackBar(this._translate.instant('tasks.snackbar.noLongerExists'));\n            this._taskOperations.reload();\n        } else {\n            this._snackBar.openErrorSnackBar(`${this._translate.instant('tasks.snackbar.noGroup')}\n                        ${this._taskContentService.task.title} ${this._translate.instant('tasks.snackbar.failedToLoad')}`);\n        }\n        this.sendNotification(TaskEvent.GET_DATA, false);\n        afterAction.resolve(false);\n        nextEvent.resolve(false);\n    }\n\n    /**\n     * Collects all changed data fields and notifies the backend of the changes.\n     *\n     * If the request is successful clears the [changed]{@link DataField#changed} flag on all data fields that were a part of the request\n     * and emits a {@link ChangedFields} object into this object's [changedFields$]{@link TaskDataService#changedFields$} stream.\n     *\n     * If the task held within the {@link TaskContentService} changes before a response is received, the response will be ignored\n     * and the `afterAction` will not be executed.\n     *\n     * @param afterAction if the request completes successfully emits `true` into the Subject, otherwise `false` will be emitted\n     */\n    public updateTaskDataFields(afterAction: AfterAction = new AfterAction()): void {\n        if (!this.isTaskPresent()) {\n            this._log.debug('Task is not present. Update request ignored.');\n            afterAction.resolve(false);\n            return;\n        }\n\n        if (this._safeTask.user === undefined) {\n            this._log.debug('current task is not assigned...');\n            afterAction.resolve(false);\n            return;\n        }\n\n        const setTaskId = this._safeTask.stringId;\n\n        if (this._safeTask.dataSize <= 0) {\n            afterAction.resolve(true);\n            return;\n        }\n\n        const requestContext = this.createUpdateRequestContext();\n\n        this._eventQueue.scheduleEvent(new QueuedEvent(\n            () => this.isSetDataRequestStillValid(requestContext.body),\n            nextEvent => {\n                this.performSetDataRequest(setTaskId, requestContext.body, afterAction, nextEvent);\n            },\n            nextEvent => {\n                this.revertSetDataRequest(requestContext);\n                nextEvent.resolve(false);\n            }\n        ));\n    }\n\n    /**\n     * @ignore\n     * Goes over all the data fields in the managed Task and if they are valid and changed adds them to the set data request\n     */\n    protected createUpdateRequestContext(): TaskSetDataRequestContext {\n        const context: TaskSetDataRequestContext = {\n            body: {},\n            previousValues: {}\n        };\n        context.body[this._task.stringId] = {};\n        this._safeTask.dataGroups.filter(dataGroup => dataGroup.parentTaskId === undefined).forEach(dataGroup => {\n            dataGroup.fields.filter(field => this.wasFieldUpdated(field)).forEach(field => {\n                this.addFieldToSetDataRequestBody(context, this._task.stringId, field);\n            });\n        });\n        this._safeTask.dataGroups.filter(dataGroup => dataGroup.parentTaskId !== undefined).forEach(dataGroup => {\n            if (dataGroup.fields.some(field => this.wasFieldUpdated(field))) {\n                context.body[dataGroup.parentTaskId] = {};\n            } else {\n                return;\n            }\n            dataGroup.fields.filter(field => this.wasFieldUpdated(field)).forEach(field => {\n                this.addFieldToSetDataRequestBody(context, dataGroup.parentTaskId, field);\n            });\n        });\n        return context;\n    }\n\n    protected addFieldToSetDataRequestBody(context: TaskSetDataRequestContext, taskId: string, field: DataField<any>): void {\n        context.body[taskId][field.stringId] = {\n            type: this._fieldConverterService.resolveType(field),\n            value: this._fieldConverterService.formatValueForBackend(field, field.value)\n        };\n        context.previousValues[field.stringId] = field.previousValue;\n        field.changed = false;\n    }\n\n    /**\n     * @param field the checked field\n     * @returns whether the field was updated on frontend and thus the backend should be notified\n     */\n    protected wasFieldUpdated(field: DataField<unknown>): boolean {\n        return field.initialized && field.changed && (field.valid || field.sendInvalidValues);\n    }\n\n    /**\n     * Checks whether the request could still be performed by the logged user\n     * @param request\n     */\n    protected isSetDataRequestStillValid(request: TaskSetDataRequestBody): boolean {\n        if (!this.isTaskPresent()) {\n            return false;\n        }\n        if (this._safeTask.user === undefined) {\n            return false;\n        }\n        if (!this._userComparator.compareUsers(this._safeTask.user)) {\n            return false;\n        }\n        const taskIdsInRequest: Array<string> = Object.keys(request);\n        for (const taskId of taskIdsInRequest) {\n            if (!Object.keys(this._taskContentService.taskFieldsIndex).includes(taskId)) {\n                this._log.error(`Task id ${taskId} is not present in task fields index`);\n                return false;\n            }\n            const fieldIdsOfRequest = Object.keys(request[taskId]);\n            for (const fieldId of fieldIdsOfRequest) {\n                const field = this._taskContentService.taskFieldsIndex[taskId][fieldId];\n                if (field === undefined) {\n                    this._log.error(`Unexpected state. Datafield ${fieldId} of task ${taskId\n                    } in setData request is not present in the task.`);\n                    return false;\n                }\n                if (!field.behavior.editable) {\n                    this._log.debug(`Field ${fieldId}, was meant to be set to\n                    ${JSON.stringify(request[taskId][fieldId])\n                    }, but is no loner editable.`);\n                    return false;\n                }\n            }\n        }\n        return true;\n    }\n\n    /**\n     * Performs a `setData` request on the task currently stored in the `taskContent` service\n     * @param setTaskId id of the task\n     * @param body content of the `setData` request\n     * @param afterAction the action that should be performed after the request is processed\n     * @param nextEvent indicates to the event queue that the next event can be processed\n     */\n    protected performSetDataRequest(setTaskId: string, body: TaskSetDataRequestBody, afterAction: AfterAction, nextEvent: AfterAction) {\n        if (Object.keys(body).length === 0) {\n            this.sendNotification(TaskEvent.SET_DATA, true);\n            afterAction.resolve(true);\n            nextEvent.resolve(true);\n            return;\n        }\n\n        this._taskState.startLoading(setTaskId);\n        this._taskState.startUpdating(setTaskId);\n\n        this._taskResourceService.setData(this._safeTask.stringId, body).pipe(take(1))\n            .subscribe((response: EventOutcomeMessageResource) => {\n                this.processSuccessfulSetDataRequest(setTaskId, response.outcome, afterAction, nextEvent, body);\n            }, error => {\n                this.processErroneousSetDataRequest(setTaskId, error, afterAction, nextEvent, body);\n            });\n    }\n\n    /**\n     * Processes a successful outcome of a `setData` request\n     * @param setTaskId the Id of the task whose data was set\n     * @param response the resulting Event outcome of the set data request\n     * @param afterAction the action that should be performed after the request is processed\n     * @param nextEvent indicates to the event queue that the next event can be processed\n     * @param body hold the data that was sent in request\n     */\n    protected processSuccessfulSetDataRequest(setTaskId: string,\n                                              response: EventOutcome,\n                                              afterAction: AfterAction,\n                                              nextEvent: AfterAction,\n                                              body: TaskSetDataRequestBody) {\n        if (!this.isTaskRelevant(setTaskId)) {\n            this._log.debug('current task changed before the set data response could be received, discarding...');\n            this._taskState.stopLoading(setTaskId);\n            this._taskState.stopUpdating(setTaskId);\n            afterAction.complete();\n            nextEvent.resolve(false);\n            return;\n        }\n\n        const changedFieldsMap: ChangedFieldsMap = this._eventService.parseChangedFieldsFromOutcomeTree(response);\n\n        if (Object.keys(changedFieldsMap).length > 0) {\n            this._changedFieldsService.emitChangedFields(changedFieldsMap);\n        }\n        this.clearWaitingForResponseFlag(body);\n        this._snackBar.openSuccessSnackBar(!!response.message ? response.message : this._translate.instant('tasks.snackbar.dataSaved'));\n        this.updateStateInfo(afterAction, true, setTaskId);\n        nextEvent.resolve(true);\n    }\n\n    /**\n     * Processes an erroneous outcome of a `setData` request\n     * @param setTaskId the Id of the task whose data was set\n     * @param error the returned error\n     * @param afterAction the action that should be performed after the request is processed\n     * @param nextEvent indicates to the event queue that the next event can be processed\n     * @param body hold the data that was sent in request\n     */\n    protected processErroneousSetDataRequest(setTaskId: string,\n                                             error: HttpErrorResponse,\n                                             afterAction: AfterAction,\n                                             nextEvent: AfterAction,\n                                             body: TaskSetDataRequestBody) {\n        this._log.debug('setting task data failed', error);\n\n        if (!this.isTaskRelevant(setTaskId)) {\n            this._log.debug('current task changed before the get data error could be received');\n            this._taskState.stopLoading(setTaskId);\n            this._taskState.stopUpdating(setTaskId);\n            afterAction.complete();\n            nextEvent.resolve(false);\n            return;\n        }\n\n        this.revertToPreviousValue();\n        this.clearWaitingForResponseFlag(body);\n        this._snackBar.openErrorSnackBar(this._translate.instant('tasks.snackbar.failedSave'));\n        this.updateStateInfo(afterAction, false, setTaskId);\n        nextEvent.resolve(false);\n        this._taskOperations.reload();\n    }\n\n    /**\n     * Reverts the effects of a failed `setData` request, so that the user sees current values.\n     * @param context the context of the failed request\n     */\n    protected revertSetDataRequest(context: TaskSetDataRequestContext) {\n        // this iteration could be improved if we had a map of all the data fields in a task\n        const totalCount = Object.keys(context.body).length;\n        let foundCount = 0;\n\n        for (const datagroup of this._safeTask.dataGroups) {\n            for (const field of datagroup.fields) {\n                if (!context.body[field.stringId]) {\n                    continue;\n                }\n\n                if (this.compareBackendFormattedFieldValues(\n                    this._fieldConverterService.formatValueForBackend(field, field.value),\n                    context.body[field.stringId].value)\n                ) {\n                    field.valueWithoutChange(context.previousValues[field.stringId]);\n                }\n\n                foundCount++;\n                if (foundCount === totalCount) {\n                    return;\n                }\n            }\n        }\n\n        this._log.error(`Invalid state. Some data fields of task ${this._safeTask.stringId}, are no longer present in it!`);\n    }\n\n    /**\n     * Compares the values that are in the backend compatible format as given by the {@link FieldConverterService}\n     * and determines whether they are the same value, or not.\n     * @param current the current value (can also be called `value1` or `left`)\n     * @param old the new value (can also be called `value2` or `right`)\n     * @returns `true` if the values are the same and `false` otherwise\n     */\n    protected compareBackendFormattedFieldValues(current, old): boolean {\n        if (Array.isArray(current)) {\n            if (!Array.isArray(old)) {\n                throw new Error('Illegal arguments! Cannot compare array value to non-array value');\n            }\n\n            if (current.length !== old.length) {\n                return false;\n            }\n\n            return current.every((value, index) => old[index] === value);\n        }\n\n        return current === old;\n    }\n\n    /**\n     * @ignore\n     *\n     * stops loading and updating indicators, and emits the `result` value\n     * to both the `afterAction` and [_updateSuccess$]{@link TaskDataService#_updateSuccess$} streams.\n     *\n     * @param afterAction the call chain steam of the update data method\n     * @param result result of the update data request\n     * @param setTaskId the Id of the {@link Task}, who's state should be updated\n     */\n    protected updateStateInfo(afterAction: AfterAction, result: boolean, setTaskId: string): void {\n        this._taskState.stopLoading(setTaskId);\n        this._taskState.stopUpdating(setTaskId);\n        if (this._updateSuccess$.observers.length !== 0) {\n            this._updateSuccess$.next(result);\n        }\n        this.sendNotification(TaskEvent.SET_DATA, result);\n        afterAction.resolve(result);\n    }\n\n    /**\n     * Publishes a get/set data notification to the {@link TaskEventService}\n     * @param event the event that occurred to the task\n     * @param success whether the get/set data operation was successful or not\n     */\n    protected sendNotification(event: TaskEvent.GET_DATA | TaskEvent.SET_DATA, success: boolean): void {\n        this._taskEvent.publishTaskEvent(createTaskEventNotification(this._safeTask, event, success));\n    }\n\n    private revertToPreviousValue(): void {\n        this._safeTask.dataGroups.forEach(dataGroup => {\n            dataGroup.fields.forEach(field => {\n                if (field.initialized && field.valid && field.changed) {\n                    field.revertToPreviousValue();\n                }\n            });\n        });\n    }\n\n    private clearWaitingForResponseFlag(body: TaskSetDataRequestBody) {\n        Object.keys(body).forEach(taskId => {\n            Object.keys(body[taskId]).forEach(fieldId => {\n                this._taskContentService.taskFieldsIndex[taskId][fieldId].waitingForResponse = false;\n            });\n        });\n    }\n}\n"]}