@netgrif/components-core 6.0.1

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

@@ -0,0 +1,200 @@
+import { __extends } from "tslib";
+import { Inject, Injectable, Optional } from '@angular/core';
+import { LoggerService } from '../../logger/services/logger.service';
+import { TaskContentService } from '../../task-content/services/task-content.service';
+import { TaskResourceService } from '../../resources/engine-endpoint/task-resource.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { TranslateService } from '@ngx-translate/core';
+import { TaskRequestStateService } from './task-request-state.service';
+import { TaskHandlingService } from './task-handling-service';
+import { NAE_TASK_OPERATIONS } from '../models/task-operations-injection-token';
+import { SelectedCaseService } from './selected-case.service';
+import { TaskEventService } from '../../task-content/services/task-event.service';
+import { createTaskEventNotification } from '../../task-content/model/task-event-notification';
+import { TaskEvent } from '../../task-content/model/task-event';
+import { TaskDataService } from './task-data.service';
+import { take } from 'rxjs/operators';
+import { TaskViewService } from '../../view/task-view/service/task-view.service';
+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 { ChangedFieldsService } from '../../changed-fields/services/changed-fields.service';
+import { EventService } from '../../event/services/event.service';
+/**
+ * Service that handles the logic of assigning a task.
+ */
+var AssignTaskService = /** @class */ (function (_super) {
+    __extends(AssignTaskService, _super);
+    function AssignTaskService(_log, _taskResourceService, _snackBar, _translate, _taskState, _taskEvent, _taskDataService, _eventQueue, _eventService, _changedFieldsService, _taskOperations, _selectedCaseService, _taskViewService, _taskContentService) {
+        var _this = _super.call(this, _taskContentService, _selectedCaseService) || this;
+        _this._log = _log;
+        _this._taskResourceService = _taskResourceService;
+        _this._snackBar = _snackBar;
+        _this._translate = _translate;
+        _this._taskState = _taskState;
+        _this._taskEvent = _taskEvent;
+        _this._taskDataService = _taskDataService;
+        _this._eventQueue = _eventQueue;
+        _this._eventService = _eventService;
+        _this._changedFieldsService = _changedFieldsService;
+        _this._taskOperations = _taskOperations;
+        _this._taskViewService = _taskViewService;
+        return _this;
+    }
+    /**
+     * Performs the 'assign' operation on the task held by {@link TaskContentService}.
+     *
+     * Doesn't send any requests if the loading indicator is in it's active state.
+     * Otherwise sets the indicator to the active state and disables it once the request response is received.
+     *
+     * The argument can be used to chain operations together,
+     * or to execute code conditionally based on the success state of the assign operation.
+     *
+     * 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 assign completes successfully `true` will be emitted into this Subject, otherwise `false` will be emitted
+     */
+    AssignTaskService.prototype.assign = function (afterAction) {
+        var _this = this;
+        if (afterAction === void 0) { afterAction = new AfterAction(); }
+        this._eventQueue.scheduleEvent(new QueuedEvent(function () {
+            return !_this._safeTask.user;
+        }, function (nextEvent) {
+            _this.performAssignRequest(afterAction, nextEvent, _this._taskViewService !== null && !_this._taskViewService.allowMultiOpen);
+        }, function (nextEvent) {
+            _this.completeSuccess(afterAction, nextEvent);
+        }));
+    };
+    /**
+     * Performs an `assign` request on the task currently stored in the `taskContent` service
+     * @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 forceReload whether a force reload of the task data should be performed after assign.
+     * If set to `false` a regular reload is performed instead.
+     */
+    AssignTaskService.prototype.performAssignRequest = function (afterAction, nextEvent, forceReload) {
+        var assignedTaskId = this._safeTask.stringId;
+        // this is probably no longer necessary because of the event queue
+        if (this._taskState.isLoading(assignedTaskId)) {
+            nextEvent.resolve(true);
+            return;
+        }
+        this._taskState.startLoading(assignedTaskId);
+        this.assignRequest(afterAction, assignedTaskId, nextEvent, forceReload);
+    };
+    /**
+     * Calls the endpoint and processes the possible responses.
+     * @param afterAction the action that should be performed after the request is processed
+     * @param assignedTaskId the id of the task that is being assigned
+     * @param nextEvent indicates to the event queue that the next event can be processed
+     * @param forceReload whether a force reload of the task data should be performed after assign.
+     * If set to `false` a regular reload is performed instead.
+     */
+    AssignTaskService.prototype.assignRequest = function (afterAction, assignedTaskId, nextEvent, forceReload) {
+        var _this = this;
+        if (afterAction === void 0) { afterAction = new AfterAction(); }
+        if (nextEvent === void 0) { nextEvent = new AfterAction(); }
+        this._taskResourceService.assignTask(this._safeTask.stringId).pipe(take(1))
+            .subscribe(function (outcomeResource) {
+            _this._taskState.stopLoading(assignedTaskId);
+            if (!_this.isTaskRelevant(assignedTaskId)) {
+                _this._log.debug('current task changed before the assign response could be received, discarding...');
+                nextEvent.resolve(false);
+                return;
+            }
+            if (outcomeResource.success) {
+                _this._taskContentService.updateStateData(outcomeResource.outcome);
+                var changedFieldsMap = _this._eventService
+                    .parseChangedFieldsFromOutcomeTree(outcomeResource.outcome);
+                if (!!changedFieldsMap) {
+                    _this._changedFieldsService.emitChangedFields(changedFieldsMap);
+                }
+                forceReload ? _this._taskOperations.forceReload() : _this._taskOperations.reload();
+                _this.completeActions(afterAction, nextEvent, true);
+                _this._snackBar.openSuccessSnackBar(!!outcomeResource.outcome.message
+                    ? outcomeResource.outcome.message
+                    : _this._translate.instant('tasks.snackbar.assignTaskSuccess'));
+            }
+            else if (outcomeResource.error) {
+                if (outcomeResource.error !== '') {
+                    _this._snackBar.openErrorSnackBar(outcomeResource.error);
+                }
+                if (outcomeResource.outcome !== undefined) {
+                    var changedFieldsMap = _this._eventService.parseChangedFieldsFromOutcomeTree(outcomeResource.outcome);
+                    _this._changedFieldsService.emitChangedFields(changedFieldsMap);
+                }
+                _this.completeActions(afterAction, nextEvent, false);
+            }
+        }, function (error) {
+            _this._taskState.stopLoading(assignedTaskId);
+            _this._log.debug('assigning task failed', error);
+            if (!_this.isTaskRelevant(assignedTaskId)) {
+                _this._log.debug('current task changed before the assign error could be received');
+                nextEvent.resolve(false);
+                return;
+            }
+            _this._snackBar.openErrorSnackBar(_this._translate.instant('tasks.snackbar.assignTask') + "\n             " + _this._taskContentService.task + " " + _this._translate.instant('tasks.snackbar.failed'));
+            _this.completeActions(afterAction, nextEvent, false);
+        });
+    };
+    /**
+     * Reloads the task and emits `true` to the `afterAction` stream
+     */
+    AssignTaskService.prototype.completeSuccess = function (afterAction, nextEvent) {
+        this._taskOperations.reload();
+        this.completeActions(afterAction, nextEvent, true);
+    };
+    /**
+     * complete all action streams and send notification with selected boolean
+     */
+    AssignTaskService.prototype.completeActions = function (afterAction, nextEvent, bool) {
+        this.sendNotification(bool);
+        afterAction.resolve(bool);
+        nextEvent.resolve(bool);
+    };
+    /**
+     * Publishes an assign notification to the {@link TaskEventService}
+     * @param success whether the assign operation was successful or not
+     */
+    AssignTaskService.prototype.sendNotification = function (success) {
+        this._taskEvent.publishTaskEvent(createTaskEventNotification(this._safeTask, TaskEvent.ASSIGN, success));
+    };
+    AssignTaskService.ctorParameters = function () { return [
+        { type: LoggerService },
+        { type: TaskResourceService },
+        { type: SnackBarService },
+        { type: TranslateService },
+        { type: TaskRequestStateService },
+        { type: TaskEventService },
+        { type: TaskDataService },
+        { type: EventQueueService },
+        { type: EventService },
+        { type: ChangedFieldsService },
+        { type: undefined, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] },
+        { type: SelectedCaseService, decorators: [{ type: Optional }] },
+        { type: TaskViewService, decorators: [{ type: Optional }] },
+        { type: TaskContentService }
+    ]; };
+    AssignTaskService.decorators = [
+        { type: Injectable }
+    ];
+    AssignTaskService.ctorParameters = function () { return [
+        { type: LoggerService },
+        { type: TaskResourceService },
+        { type: SnackBarService },
+        { type: TranslateService },
+        { type: TaskRequestStateService },
+        { type: TaskEventService },
+        { type: TaskDataService },
+        { type: EventQueueService },
+        { type: EventService },
+        { type: ChangedFieldsService },
+        { type: undefined, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] },
+        { type: SelectedCaseService, decorators: [{ type: Optional }] },
+        { type: TaskViewService, decorators: [{ type: Optional }] },
+        { type: TaskContentService }
+    ]; };
+    return AssignTaskService;
+}(TaskHandlingService));
+export { AssignTaskService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assign-task.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/task/services/assign-task.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, Optional} from '@angular/core';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {TaskContentService} from '../../task-content/services/task-content.service';\nimport {TaskResourceService} from '../../resources/engine-endpoint/task-resource.service';\nimport {SnackBarService} from '../../snack-bar/services/snack-bar.service';\nimport {TranslateService} from '@ngx-translate/core';\nimport {TaskRequestStateService} from './task-request-state.service';\nimport {TaskHandlingService} from './task-handling-service';\nimport {NAE_TASK_OPERATIONS} from '../models/task-operations-injection-token';\nimport {TaskOperations} from '../interfaces/task-operations';\nimport {SelectedCaseService} from './selected-case.service';\nimport {TaskEventService} from '../../task-content/services/task-event.service';\nimport {createTaskEventNotification} from '../../task-content/model/task-event-notification';\nimport {TaskEvent} from '../../task-content/model/task-event';\nimport {TaskDataService} from './task-data.service';\nimport {take} from 'rxjs/operators';\nimport {TaskViewService} from '../../view/task-view/service/task-view.service';\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 {AssignTaskEventOutcome} from '../../event/model/event-outcomes/task-outcomes/assign-task-event-outcome';\nimport {EventOutcomeMessageResource} from '../../resources/interface/message-resource';\nimport {ChangedFieldsService} from '../../changed-fields/services/changed-fields.service';\nimport {EventService} from '../../event/services/event.service';\nimport {ChangedFieldsMap} from '../../event/services/interfaces/changed-fields-map';\n\n\n/**\n * Service that handles the logic of assigning a task.\n */\n@Injectable()\nexport class AssignTaskService extends TaskHandlingService {\n\n    constructor(protected _log: LoggerService,\n                protected _taskResourceService: TaskResourceService,\n                protected _snackBar: SnackBarService,\n                protected _translate: TranslateService,\n                protected _taskState: TaskRequestStateService,\n                protected _taskEvent: TaskEventService,\n                protected _taskDataService: TaskDataService,\n                protected _eventQueue: EventQueueService,\n                protected _eventService: EventService,\n                protected _changedFieldsService: ChangedFieldsService,\n                @Inject(NAE_TASK_OPERATIONS) protected _taskOperations: TaskOperations,\n                @Optional() _selectedCaseService: SelectedCaseService,\n                @Optional() protected _taskViewService: TaskViewService,\n                _taskContentService: TaskContentService) {\n        super(_taskContentService, _selectedCaseService);\n    }\n\n    /**\n     * Performs the 'assign' operation on the task held by {@link TaskContentService}.\n     *\n     * Doesn't send any requests if the loading indicator is in it's active state.\n     * Otherwise sets the indicator to the active state and disables it once the request response is received.\n     *\n     * The argument can be used to chain operations together,\n     * or to execute code conditionally based on the success state of the assign operation.\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     * @param afterAction if assign completes successfully `true` will be emitted into this Subject, otherwise `false` will be emitted\n     */\n    public assign(afterAction: AfterAction = new AfterAction()): void {\n        this._eventQueue.scheduleEvent(new QueuedEvent(\n            () => {\n                return !this._safeTask.user;\n            },\n            nextEvent => {\n                this.performAssignRequest(afterAction, nextEvent, this._taskViewService !== null && !this._taskViewService.allowMultiOpen);\n            },\n            nextEvent => {\n                this.completeSuccess(afterAction, nextEvent);\n            }\n        ));\n    }\n\n    /**\n     * Performs an `assign` 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 nextEvent indicates to the event queue that the next event can be processed\n     * @param forceReload whether a force reload of the task data should be performed after assign.\n     * If set to `false` a regular reload is performed instead.\n     */\n    protected performAssignRequest(afterAction: AfterAction, nextEvent: AfterAction, forceReload: boolean) {\n        const assignedTaskId = this._safeTask.stringId;\n\n        // this is probably no longer necessary because of the event queue\n        if (this._taskState.isLoading(assignedTaskId)) {\n            nextEvent.resolve(true);\n            return;\n        }\n\n        this._taskState.startLoading(assignedTaskId);\n        this.assignRequest(afterAction, assignedTaskId, nextEvent, forceReload);\n    }\n\n    /**\n     * Calls the endpoint and processes the possible responses.\n     * @param afterAction the action that should be performed after the request is processed\n     * @param assignedTaskId the id of the task that is being assigned\n     * @param nextEvent indicates to the event queue that the next event can be processed\n     * @param forceReload whether a force reload of the task data should be performed after assign.\n     * If set to `false` a regular reload is performed instead.\n     */\n    protected assignRequest(afterAction: AfterAction = new AfterAction(),\n                            assignedTaskId: string,\n                            nextEvent: AfterAction = new AfterAction(),\n                            forceReload: boolean) {\n        this._taskResourceService.assignTask(this._safeTask.stringId).pipe(take(1))\n            .subscribe((outcomeResource: EventOutcomeMessageResource) => {\n                this._taskState.stopLoading(assignedTaskId);\n                if (!this.isTaskRelevant(assignedTaskId)) {\n                    this._log.debug('current task changed before the assign response could be received, discarding...');\n                    nextEvent.resolve(false);\n                    return;\n                }\n\n                if (outcomeResource.success) {\n                    this._taskContentService.updateStateData(outcomeResource.outcome as AssignTaskEventOutcome);\n                    const changedFieldsMap: ChangedFieldsMap = this._eventService\n                        .parseChangedFieldsFromOutcomeTree(outcomeResource.outcome);\n                    if (!!changedFieldsMap) {\n                        this._changedFieldsService.emitChangedFields(changedFieldsMap);\n                    }\n                    forceReload ? this._taskOperations.forceReload() : this._taskOperations.reload();\n                    this.completeActions(afterAction, nextEvent, true);\n                    this._snackBar.openSuccessSnackBar(!!outcomeResource.outcome.message\n                        ? outcomeResource.outcome.message\n                        : this._translate.instant('tasks.snackbar.assignTaskSuccess'));\n                } else if (outcomeResource.error) {\n                    if (outcomeResource.error !== '') {\n                        this._snackBar.openErrorSnackBar(outcomeResource.error);\n                    }\n                    if (outcomeResource.outcome !== undefined) {\n                        const changedFieldsMap = this._eventService.parseChangedFieldsFromOutcomeTree(outcomeResource.outcome);\n                        this._changedFieldsService.emitChangedFields(changedFieldsMap);\n                    }\n                    this.completeActions(afterAction, nextEvent, false);\n                }\n            }, error => {\n                this._taskState.stopLoading(assignedTaskId);\n                this._log.debug('assigning task failed', error);\n\n                if (!this.isTaskRelevant(assignedTaskId)) {\n                    this._log.debug('current task changed before the assign error could be received');\n                    nextEvent.resolve(false);\n                    return;\n                }\n\n                this._snackBar.openErrorSnackBar(`${this._translate.instant('tasks.snackbar.assignTask')}\n             ${this._taskContentService.task} ${this._translate.instant('tasks.snackbar.failed')}`);\n                this.completeActions(afterAction, nextEvent, false);\n            });\n    }\n\n    /**\n     * Reloads the task and emits `true` to the `afterAction` stream\n     */\n    protected completeSuccess(afterAction: AfterAction, nextEvent: AfterAction): void {\n        this._taskOperations.reload();\n        this.completeActions(afterAction, nextEvent, true);\n    }\n\n    /**\n     * complete all action streams and send notification with selected boolean\n     */\n    protected completeActions(afterAction: AfterAction, nextEvent: AfterAction, bool: boolean): void {\n        this.sendNotification(bool);\n        afterAction.resolve(bool);\n        nextEvent.resolve(bool);\n    }\n\n    /**\n     * Publishes an assign notification to the {@link TaskEventService}\n     * @param success whether the assign operation was successful or not\n     */\n    protected sendNotification(success: boolean): void {\n        this._taskEvent.publishTaskEvent(createTaskEventNotification(this._safeTask, TaskEvent.ASSIGN, success));\n    }\n}\n"]}

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

@@ -0,0 +1,198 @@
+import { __extends } from "tslib";
+import { Inject, Injectable, Optional } from '@angular/core';
+import { LoggerService } from '../../logger/services/logger.service';
+import { TaskContentService } from '../../task-content/services/task-content.service';
+import { TaskEventService } from '../../task-content/services/task-event.service';
+import { TaskResourceService } from '../../resources/engine-endpoint/task-resource.service';
+import { TranslateService } from '@ngx-translate/core';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { TaskRequestStateService } from './task-request-state.service';
+import { TaskHandlingService } from './task-handling-service';
+import { NAE_TASK_OPERATIONS } from '../models/task-operations-injection-token';
+import { UserComparatorService } from '../../user/services/user-comparator.service';
+import { SelectedCaseService } from './selected-case.service';
+import { createTaskEventNotification } from '../../task-content/model/task-event-notification';
+import { TaskEvent } from '../../task-content/model/task-event';
+import { TaskDataService } from './task-data.service';
+import { take } from 'rxjs/operators';
+import { TaskViewService } from '../../view/task-view/service/task-view.service';
+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 { PermissionService } from '../../authorization/permission/permission.service';
+import { ChangedFieldsService } from '../../changed-fields/services/changed-fields.service';
+import { EventService } from '../../event/services/event.service';
+/**
+ * Service that handles the logic of canceling a task.
+ */
+var CancelTaskService = /** @class */ (function (_super) {
+    __extends(CancelTaskService, _super);
+    function CancelTaskService(_log, _taskEventService, _taskResourceService, _translate, _snackBar, _taskState, _userComparator, _taskEvent, _taskDataService, _eventQueue, _eventService, _changedFieldsService, _taskOperations, _selectedCaseService, _taskViewService, _taskContentService, permissionService) {
+        var _this = _super.call(this, _taskContentService, _selectedCaseService) || this;
+        _this._log = _log;
+        _this._taskEventService = _taskEventService;
+        _this._taskResourceService = _taskResourceService;
+        _this._translate = _translate;
+        _this._snackBar = _snackBar;
+        _this._taskState = _taskState;
+        _this._userComparator = _userComparator;
+        _this._taskEvent = _taskEvent;
+        _this._taskDataService = _taskDataService;
+        _this._eventQueue = _eventQueue;
+        _this._eventService = _eventService;
+        _this._changedFieldsService = _changedFieldsService;
+        _this._taskOperations = _taskOperations;
+        _this._taskViewService = _taskViewService;
+        _this.permissionService = permissionService;
+        return _this;
+    }
+    /**
+     * Performs the 'cancel' operation on the task held by {@link TaskContentService}.
+     *
+     * Doesn't send any requests if the loading indicator is in it's active state.
+     * Otherwise sets the indicator to the active state and disables it once the request response is received.
+     *
+     * The argument can be used to chain operations together,
+     * or to execute code conditionally based on the success state of the cancel operation.
+     *
+     * 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 cancel completes successfully `true` will be emitted into this Subject, otherwise `false` will be emitted
+     */
+    CancelTaskService.prototype.cancel = function (afterAction) {
+        var _this = this;
+        if (afterAction === void 0) { afterAction = new AfterAction(); }
+        this._eventQueue.scheduleEvent(new QueuedEvent(function () { return _this.permissionService.canCancel(_this._safeTask); }, function (nextEvent) {
+            _this.performCancelRequest(afterAction, nextEvent, _this._taskViewService !== null && !_this._taskViewService.allowMultiOpen);
+        }, function (nextEvent) {
+            _this.completeActions(afterAction, nextEvent, false);
+        }));
+    };
+    /**
+     * Performs a `cancel` request on the task currently stored in the `taskContent` service
+     * @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 forceReload whether a force reload of the task data should be performed after cancel.
+     * If set to `false` a regular reload is performed instead.
+     */
+    CancelTaskService.prototype.performCancelRequest = function (afterAction, nextEvent, forceReload) {
+        var canceledTaskId = this._safeTask.stringId;
+        // this is probably no longer necessary because of the event queue
+        if (this._taskState.isLoading(canceledTaskId)) {
+            nextEvent.resolve(true);
+            return;
+        }
+        this._taskState.startLoading(canceledTaskId);
+        this.cancelRequest(afterAction, canceledTaskId, nextEvent, forceReload);
+    };
+    /**
+     * Calls the endpoint and processes the possible responses.
+     * @param afterAction the action that should be performed after the request is processed
+     * @param canceledTaskId the id of the task that is being canceled
+     * @param nextEvent indicates to the event queue that the next event can be processed
+     * @param forceReload whether a force reload of the task data should be performed after cancel.
+     * If set to `false` a regular reload is performed instead.
+     */
+    CancelTaskService.prototype.cancelRequest = function (afterAction, canceledTaskId, nextEvent, forceReload) {
+        var _this = this;
+        if (afterAction === void 0) { afterAction = new AfterAction(); }
+        if (nextEvent === void 0) { nextEvent = new AfterAction(); }
+        this._taskResourceService.cancelTask(this._safeTask.stringId).pipe(take(1)).subscribe(function (outcomeResource) {
+            _this._taskState.stopLoading(canceledTaskId);
+            if (!_this.isTaskRelevant(canceledTaskId)) {
+                _this._log.debug('current task changed before the cancel response could be received, discarding...');
+                nextEvent.resolve(false);
+                return;
+            }
+            if (outcomeResource.success) {
+                _this._taskContentService.updateStateData(outcomeResource.outcome);
+                var changedFieldsMap = _this._eventService
+                    .parseChangedFieldsFromOutcomeTree(outcomeResource.outcome);
+                if (!!changedFieldsMap) {
+                    _this._changedFieldsService.emitChangedFields(changedFieldsMap);
+                }
+                forceReload ? _this._taskOperations.forceReload() : _this._taskOperations.reload();
+                _this.completeActions(afterAction, nextEvent, true);
+            }
+            else if (outcomeResource.error !== undefined) {
+                if (outcomeResource.error !== '') {
+                    _this._snackBar.openErrorSnackBar(outcomeResource.error);
+                }
+                if (outcomeResource.outcome !== undefined) {
+                    var changedFieldsMap = _this._eventService.parseChangedFieldsFromOutcomeTree(outcomeResource.outcome);
+                    _this._changedFieldsService.emitChangedFields(changedFieldsMap);
+                }
+                _this.completeActions(afterAction, nextEvent, false);
+            }
+        }, function (error) {
+            _this._taskState.stopLoading(canceledTaskId);
+            _this._log.debug('canceling task failed', error);
+            if (!_this.isTaskRelevant(canceledTaskId)) {
+                _this._log.debug('current task changed before the cancel error could be received');
+                nextEvent.resolve(false);
+                return;
+            }
+            _this._snackBar.openErrorSnackBar(_this._translate.instant('tasks.snackbar.cancelTask') + "\n             " + _this._task + " " + _this._translate.instant('tasks.snackbar.failed'));
+            _this.completeActions(afterAction, nextEvent, false);
+        });
+    };
+    /**
+     * complete all action streams and send notification with selected boolean
+     */
+    CancelTaskService.prototype.completeActions = function (afterAction, nextEvent, bool) {
+        this.sendNotification(bool);
+        afterAction.resolve(bool);
+        nextEvent.resolve(bool);
+    };
+    /**
+     * Publishes a cancel notification to the {@link TaskEventService}
+     * @param success whether the cancel operation was successful or not
+     */
+    CancelTaskService.prototype.sendNotification = function (success) {
+        this._taskEvent.publishTaskEvent(createTaskEventNotification(this._safeTask, TaskEvent.CANCEL, success));
+    };
+    CancelTaskService.ctorParameters = function () { return [
+        { type: LoggerService },
+        { type: TaskEventService },
+        { type: TaskResourceService },
+        { type: TranslateService },
+        { type: SnackBarService },
+        { type: TaskRequestStateService },
+        { type: UserComparatorService },
+        { type: TaskEventService },
+        { type: TaskDataService },
+        { type: EventQueueService },
+        { type: EventService },
+        { type: ChangedFieldsService },
+        { type: undefined, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] },
+        { type: SelectedCaseService, decorators: [{ type: Optional }] },
+        { type: TaskViewService, decorators: [{ type: Optional }] },
+        { type: TaskContentService },
+        { type: PermissionService }
+    ]; };
+    CancelTaskService.decorators = [
+        { type: Injectable }
+    ];
+    CancelTaskService.ctorParameters = function () { return [
+        { type: LoggerService },
+        { type: TaskEventService },
+        { type: TaskResourceService },
+        { type: TranslateService },
+        { type: SnackBarService },
+        { type: TaskRequestStateService },
+        { type: UserComparatorService },
+        { type: TaskEventService },
+        { type: TaskDataService },
+        { type: EventQueueService },
+        { type: EventService },
+        { type: ChangedFieldsService },
+        { type: undefined, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] },
+        { type: SelectedCaseService, decorators: [{ type: Optional }] },
+        { type: TaskViewService, decorators: [{ type: Optional }] },
+        { type: TaskContentService },
+        { type: PermissionService }
+    ]; };
+    return CancelTaskService;
+}(TaskHandlingService));
+export { CancelTaskService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cancel-task.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/task/services/cancel-task.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, Optional} from '@angular/core';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {TaskContentService} from '../../task-content/services/task-content.service';\nimport {TaskEventService} from '../../task-content/services/task-event.service';\nimport {TaskResourceService} from '../../resources/engine-endpoint/task-resource.service';\nimport {TranslateService} from '@ngx-translate/core';\nimport {SnackBarService} from '../../snack-bar/services/snack-bar.service';\nimport {TaskRequestStateService} from './task-request-state.service';\nimport {TaskHandlingService} from './task-handling-service';\nimport {NAE_TASK_OPERATIONS} from '../models/task-operations-injection-token';\nimport {TaskOperations} from '../interfaces/task-operations';\nimport {UserComparatorService} from '../../user/services/user-comparator.service';\nimport {SelectedCaseService} from './selected-case.service';\nimport {createTaskEventNotification} from '../../task-content/model/task-event-notification';\nimport {TaskEvent} from '../../task-content/model/task-event';\nimport {TaskDataService} from './task-data.service';\nimport {take} from 'rxjs/operators';\nimport {TaskViewService} from '../../view/task-view/service/task-view.service';\nimport {CancelTaskEventOutcome} from '../../event/model/event-outcomes/task-outcomes/cancel-task-event-outcome';\nimport {EventOutcomeMessageResource} from '../../resources/interface/message-resource';\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 {PermissionService} from '../../authorization/permission/permission.service';\nimport {ChangedFieldsService} from '../../changed-fields/services/changed-fields.service';\nimport { EventService} from '../../event/services/event.service';\nimport {ChangedFieldsMap} from '../../event/services/interfaces/changed-fields-map';\n\n/**\n * Service that handles the logic of canceling a task.\n */\n@Injectable()\nexport class CancelTaskService extends TaskHandlingService {\n\n    constructor(protected _log: LoggerService,\n                protected _taskEventService: TaskEventService,\n                protected _taskResourceService: TaskResourceService,\n                protected _translate: TranslateService,\n                protected _snackBar: SnackBarService,\n                protected _taskState: TaskRequestStateService,\n                protected _userComparator: UserComparatorService,\n                protected _taskEvent: TaskEventService,\n                protected _taskDataService: TaskDataService,\n                protected _eventQueue: EventQueueService,\n                protected _eventService: EventService,\n                protected _changedFieldsService: ChangedFieldsService,\n                @Inject(NAE_TASK_OPERATIONS) protected _taskOperations: TaskOperations,\n                @Optional() _selectedCaseService: SelectedCaseService,\n                @Optional() protected _taskViewService: TaskViewService,\n                _taskContentService: TaskContentService,\n                protected permissionService: PermissionService) {\n        super(_taskContentService, _selectedCaseService);\n    }\n\n    /**\n     * Performs the 'cancel' operation on the task held by {@link TaskContentService}.\n     *\n     * Doesn't send any requests if the loading indicator is in it's active state.\n     * Otherwise sets the indicator to the active state and disables it once the request response is received.\n     *\n     * The argument can be used to chain operations together,\n     * or to execute code conditionally based on the success state of the cancel operation.\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     * @param afterAction if cancel completes successfully `true` will be emitted into this Subject, otherwise `false` will be emitted\n     */\n    public cancel(afterAction: AfterAction = new AfterAction()) {\n        this._eventQueue.scheduleEvent(new QueuedEvent(\n            () => this.permissionService.canCancel(this._safeTask),\n            nextEvent => {\n                this.performCancelRequest(afterAction, nextEvent, this._taskViewService !== null && !this._taskViewService.allowMultiOpen);\n            },\n            nextEvent => {\n                this.completeActions(afterAction, nextEvent, false);\n            }\n        ));\n    }\n\n    /**\n     * Performs a `cancel` 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 nextEvent indicates to the event queue that the next event can be processed\n     * @param forceReload whether a force reload of the task data should be performed after cancel.\n     * If set to `false` a regular reload is performed instead.\n     */\n    protected performCancelRequest(afterAction: AfterAction, nextEvent: AfterAction, forceReload: boolean) {\n        const canceledTaskId = this._safeTask.stringId;\n\n        // this is probably no longer necessary because of the event queue\n        if (this._taskState.isLoading(canceledTaskId)) {\n            nextEvent.resolve(true);\n            return;\n        }\n\n        this._taskState.startLoading(canceledTaskId);\n        this.cancelRequest(afterAction, canceledTaskId, nextEvent, forceReload);\n    }\n\n    /**\n     * Calls the endpoint and processes the possible responses.\n     * @param afterAction the action that should be performed after the request is processed\n     * @param canceledTaskId the id of the task that is being canceled\n     * @param nextEvent indicates to the event queue that the next event can be processed\n     * @param forceReload whether a force reload of the task data should be performed after cancel.\n     * If set to `false` a regular reload is performed instead.\n     */\n    protected cancelRequest(afterAction: AfterAction = new AfterAction(),\n                            canceledTaskId: string,\n                            nextEvent: AfterAction = new AfterAction(),\n                            forceReload: boolean) {\n        this._taskResourceService.cancelTask(this._safeTask.stringId).pipe(take(1)).subscribe(\n            (outcomeResource: EventOutcomeMessageResource) => {\n            this._taskState.stopLoading(canceledTaskId);\n            if (!this.isTaskRelevant(canceledTaskId)) {\n                this._log.debug('current task changed before the cancel response could be received, discarding...');\n                nextEvent.resolve(false);\n                return;\n            }\n\n            if (outcomeResource.success) {\n                this._taskContentService.updateStateData(outcomeResource.outcome as CancelTaskEventOutcome);\n                const changedFieldsMap: ChangedFieldsMap = this._eventService\n                    .parseChangedFieldsFromOutcomeTree(outcomeResource.outcome);\n                if (!!changedFieldsMap) {\n                    this._changedFieldsService.emitChangedFields(changedFieldsMap);\n                }\n                forceReload ? this._taskOperations.forceReload() : this._taskOperations.reload();\n                this.completeActions(afterAction, nextEvent, true);\n            } else if (outcomeResource.error !== undefined) {\n                if (outcomeResource.error !== '') {\n                    this._snackBar.openErrorSnackBar(outcomeResource.error);\n                }\n                if (outcomeResource.outcome !== undefined) {\n                    const changedFieldsMap = this._eventService.parseChangedFieldsFromOutcomeTree(outcomeResource.outcome);\n                    this._changedFieldsService.emitChangedFields(changedFieldsMap);\n                }\n                this.completeActions(afterAction, nextEvent, false);\n            }\n        }, error => {\n            this._taskState.stopLoading(canceledTaskId);\n            this._log.debug('canceling task failed', error);\n\n            if (!this.isTaskRelevant(canceledTaskId)) {\n                this._log.debug('current task changed before the cancel error could be received');\n                nextEvent.resolve(false);\n                return;\n            }\n\n            this._snackBar.openErrorSnackBar(`${this._translate.instant('tasks.snackbar.cancelTask')}\n             ${this._task} ${this._translate.instant('tasks.snackbar.failed')}`);\n            this.completeActions(afterAction, nextEvent, false);\n        });\n    }\n\n    /**\n     * complete all action streams and send notification with selected boolean\n     */\n    protected completeActions(afterAction: AfterAction, nextEvent: AfterAction, bool: boolean): void {\n        this.sendNotification(bool);\n        afterAction.resolve(bool);\n        nextEvent.resolve(bool);\n    }\n\n    /**\n     * Publishes a cancel notification to the {@link TaskEventService}\n     * @param success whether the cancel operation was successful or not\n     */\n    protected sendNotification(success: boolean): void {\n        this._taskEvent.publishTaskEvent(createTaskEventNotification(this._safeTask, TaskEvent.CANCEL, success));\n    }\n}\n"]}

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

@@ -0,0 +1,40 @@
+import { __extends } from "tslib";
+import { Injectable } from '@angular/core';
+import { DataFocusPolicy } from '../../task-content/model/policy';
+import { TaskContentService } from '../../task-content/services/task-content.service';
+import { TaskHandlingService } from './task-handling-service';
+/**
+ * Handles the sequence of actions that are performed when a task si [opened]{@link TaskOperations#open}.
+ */
+var DataFocusPolicyService = /** @class */ (function (_super) {
+    __extends(DataFocusPolicyService, _super);
+    function DataFocusPolicyService(_taskContentService) {
+        return _super.call(this, _taskContentService) || this;
+    }
+    /**
+     * Performs the selection of some data fields if the policy is set to [Auto Required]{@link DataFocusPolicy#autoRequired}.
+     */
+    DataFocusPolicyService.prototype.performDataFocusPolicy = function () {
+        if (this._safeTask.dataFocusPolicy === DataFocusPolicy.autoRequired) {
+            this.autoRequiredDataFocusPolicy();
+        }
+    };
+    /**
+     * Currently does nothing
+     */
+    DataFocusPolicyService.prototype.autoRequiredDataFocusPolicy = function () {
+        // TODO Implement focus in FUTURE, if someone wants this feature (for now we don't want it )
+    };
+    DataFocusPolicyService.ctorParameters = function () { return [
+        { type: TaskContentService }
+    ]; };
+    DataFocusPolicyService.decorators = [
+        { type: Injectable }
+    ];
+    DataFocusPolicyService.ctorParameters = function () { return [
+        { type: TaskContentService }
+    ]; };
+    return DataFocusPolicyService;
+}(TaskHandlingService));
+export { DataFocusPolicyService };
+//# sourceMappingURL=data:application/json;base64,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