@netgrif/components-core 6.0.1

package/esm2015/lib/task/services/delegate-task.service.js

@@ -0,0 +1,185 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { SideMenuSize } from '../../side-menu/models/side-menu-size';
+import { LoggerService } from '../../logger/services/logger.service';
+import { SideMenuService } from '../../side-menu/services/side-menu.service';
+import { TaskResourceService } from '../../resources/engine-endpoint/task-resource.service';
+import { TaskContentService } from '../../task-content/services/task-content.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 { UserValue } from '../../data-fields/user-field/models/user-value';
+import { SelectedCaseService } from './selected-case.service';
+import { NAE_USER_ASSIGN_COMPONENT } from '../../side-menu/content-components/injection-tokens';
+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 { TaskDataService } from './task-data.service';
+import { take } from 'rxjs/operators';
+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 delegating a task.
+ */
+export class DelegateTaskService extends TaskHandlingService {
+    constructor(_log, _sideMenuService, _taskResourceService, _snackBar, _translate, _taskState, _taskEvent, _taskDataService, _eventQueue, _eventService, _changedFieldsService, _taskOperations, _userAssignComponent, _selectedCaseService, _taskContentService) {
+        super(_taskContentService, _selectedCaseService);
+        this._log = _log;
+        this._sideMenuService = _sideMenuService;
+        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._userAssignComponent = _userAssignComponent;
+    }
+    /**
+     * Performs the 'delegate' 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 delegate 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 delegate completes successfully `true` will be emitted into this Subject, otherwise `false` will be emitted
+     */
+    delegate(afterAction = new AfterAction()) {
+        const delegatedTaskId = this._safeTask.stringId;
+        if (this._taskState.isLoading(delegatedTaskId)) {
+            return;
+        }
+        this._sideMenuService.open(this._userAssignComponent, SideMenuSize.MEDIUM, {
+            roles: Object.keys(this._safeTask.roles).filter(role => this._safeTask.roles[role]['assign'] !== undefined && this._safeTask.roles[role]['assign']),
+            value: !this._safeTask.user ? undefined : new UserValue(this._safeTask.user.id, this._safeTask.user.name, this._safeTask.user.surname, this._safeTask.user.email),
+            negativeRoles: Object.keys(this._safeTask.roles).filter(role => this._safeTask.roles[role]['assign'] !== undefined && !this._safeTask.roles[role]['assign'])
+        }).onClose.subscribe(event => {
+            this._log.debug('Delegate sidemenu event:' + event);
+            if (event.data === undefined) {
+                return;
+            }
+            this._eventQueue.scheduleEvent(new QueuedEvent(() => {
+                const result = this.isTaskRelevant(delegatedTaskId);
+                if (!result) {
+                    this._log.debug('current task changed before the delegate side menu data was received, discarding...');
+                }
+                return result;
+            }, nextEvent => {
+                this.performDelegateRequest(afterAction, delegatedTaskId, event.data.id, nextEvent);
+            }));
+        });
+    }
+    /**
+     * Performs a `delegate` request on the task currently stored in the `taskContent` service
+     * @param afterAction the action that should be performed after the request is processed
+     * @param delegatedTaskId id of the task that is being delegated
+     * @param delegatedUserId id of the user whom the task is being delegated
+     * @param nextEvent indicates to the event queue that the next event can be processed
+     */
+    performDelegateRequest(afterAction, delegatedTaskId, delegatedUserId, nextEvent) {
+        this._taskState.startLoading(delegatedTaskId);
+        this._taskResourceService.delegateTask(this._safeTask.stringId, delegatedUserId).pipe(take(1)).subscribe((outcomeResource) => {
+            this._taskState.stopLoading(delegatedTaskId);
+            if (!this.isTaskRelevant(delegatedTaskId)) {
+                this._log.debug('current task changed before the delegate response could be received, discarding...');
+                nextEvent.resolve(false);
+                return;
+            }
+            if (outcomeResource.success) {
+                this._taskContentService.updateStateData(outcomeResource.outcome);
+                const changedFieldsMap = this._eventService
+                    .parseChangedFieldsFromOutcomeTree(outcomeResource.outcome);
+                if (!!changedFieldsMap) {
+                    this._changedFieldsService.emitChangedFields(changedFieldsMap);
+                }
+                this.completeSuccess(afterAction, nextEvent);
+            }
+            else if (outcomeResource.error) {
+                this._snackBar.openErrorSnackBar(outcomeResource.error);
+                this.completeActions(afterAction, nextEvent, false);
+            }
+        }, error => {
+            this._taskState.stopLoading(delegatedTaskId);
+            this._log.debug('getting task data failed', error);
+            if (!this.isTaskRelevant(delegatedTaskId)) {
+                this._log.debug('current task changed before the delegate error could be received');
+                nextEvent.resolve(false);
+                return;
+            }
+            this._snackBar.openErrorSnackBar(`${this._translate.instant('tasks.snackbar.assignTask')}
+                     ${this._task} ${this._translate.instant('tasks.snackbar.failed')}`);
+            this.completeActions(afterAction, nextEvent, false);
+        });
+    }
+    /**
+     * Reloads the task and emits `true` to the `afterAction` stream
+     */
+    completeSuccess(afterAction, nextEvent) {
+        this._taskOperations.reload();
+        this.completeActions(afterAction, nextEvent, true);
+    }
+    /**
+     * Completes all the action streams and sends the notification, with the provided result
+     */
+    completeActions(afterAction, nextEvent, result) {
+        this.sendNotification(result);
+        afterAction.resolve(result);
+        nextEvent.resolve(result);
+    }
+    /**
+     * Publishes a delegate notification to the {@link TaskEventService}
+     * @param success whether the delegate operation was successful or not
+     */
+    sendNotification(success) {
+        this._taskEvent.publishTaskEvent(createTaskEventNotification(this._safeTask, TaskEvent.DELEGATE, success));
+    }
+}
+DelegateTaskService.ctorParameters = () => [
+    { type: LoggerService },
+    { type: SideMenuService },
+    { 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: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_USER_ASSIGN_COMPONENT,] }] },
+    { type: SelectedCaseService, decorators: [{ type: Optional }] },
+    { type: TaskContentService }
+];
+DelegateTaskService.decorators = [
+    { type: Injectable }
+];
+DelegateTaskService.ctorParameters = () => [
+    { type: LoggerService },
+    { type: SideMenuService },
+    { 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: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_USER_ASSIGN_COMPONENT,] }] },
+    { type: SelectedCaseService, decorators: [{ type: Optional }] },
+    { type: TaskContentService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"delegate-task.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/task/services/delegate-task.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, Optional} from '@angular/core';\nimport {SideMenuSize} from '../../side-menu/models/side-menu-size';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {SideMenuService} from '../../side-menu/services/side-menu.service';\nimport {TaskResourceService} from '../../resources/engine-endpoint/task-resource.service';\nimport {TaskContentService} from '../../task-content/services/task-content.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 {UserListInjectedData} from '../../side-menu/content-components/user-assign/model/user-list-injected-data';\nimport {UserValue} from '../../data-fields/user-field/models/user-value';\nimport {SelectedCaseService} from './selected-case.service';\nimport {NAE_USER_ASSIGN_COMPONENT} from '../../side-menu/content-components/injection-tokens';\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 {TaskDataService} from './task-data.service';\nimport {take} from 'rxjs/operators';\nimport {DelegateTaskEventOutcome} from '../../event/model/event-outcomes/task-outcomes/delegate-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 {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 delegating a task.\n */\n@Injectable()\nexport class DelegateTaskService extends TaskHandlingService {\n\n    constructor(protected _log: LoggerService,\n                protected _sideMenuService: SideMenuService,\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() @Inject(NAE_USER_ASSIGN_COMPONENT) protected _userAssignComponent: any,\n                @Optional() _selectedCaseService: SelectedCaseService,\n                _taskContentService: TaskContentService) {\n        super(_taskContentService, _selectedCaseService);\n    }\n\n    /**\n     * Performs the 'delegate' 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 delegate 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 delegate completes successfully `true` will be emitted into this Subject, otherwise `false` will be emitted\n     */\n    public delegate(afterAction: AfterAction = new AfterAction()) {\n        const delegatedTaskId = this._safeTask.stringId;\n\n        if (this._taskState.isLoading(delegatedTaskId)) {\n            return;\n        }\n        this._sideMenuService.open(this._userAssignComponent, SideMenuSize.MEDIUM,\n            {\n                roles: Object.keys(this._safeTask.roles).filter(role =>\n                    this._safeTask.roles[role]['assign'] !== undefined && this._safeTask.roles[role]['assign']),\n                value: !this._safeTask.user ? undefined : new UserValue(\n                    this._safeTask.user.id, this._safeTask.user.name, this._safeTask.user.surname, this._safeTask.user.email\n                ),\n                negativeRoles: Object.keys(this._safeTask.roles).filter(role =>\n                    this._safeTask.roles[role]['assign'] !== undefined && !this._safeTask.roles[role]['assign'])\n            } as UserListInjectedData).onClose.subscribe(event => {\n\n            this._log.debug('Delegate sidemenu event:' + event);\n            if (event.data === undefined) {\n                return;\n            }\n\n            this._eventQueue.scheduleEvent(new QueuedEvent(\n                () => {\n                    const result = this.isTaskRelevant(delegatedTaskId);\n                    if (!result) {\n                        this._log.debug('current task changed before the delegate side menu data was received, discarding...');\n                    }\n                    return result;\n                },\n                nextEvent => {\n                    this.performDelegateRequest(afterAction, delegatedTaskId, event.data.id, nextEvent);\n                }\n            ));\n        });\n    }\n\n    /**\n     * Performs a `delegate` 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 delegatedTaskId id of the task that is being delegated\n     * @param delegatedUserId id of the user whom the task is being delegated\n     * @param nextEvent indicates to the event queue that the next event can be processed\n     */\n    protected performDelegateRequest(afterAction: AfterAction, delegatedTaskId: string, delegatedUserId: any, nextEvent: AfterAction) {\n        this._taskState.startLoading(delegatedTaskId);\n        this._taskResourceService.delegateTask(this._safeTask.stringId, delegatedUserId).pipe(take(1)).subscribe(\n            (outcomeResource: EventOutcomeMessageResource) => {\n            this._taskState.stopLoading(delegatedTaskId);\n            if (!this.isTaskRelevant(delegatedTaskId)) {\n                this._log.debug('current task changed before the delegate response could be received, discarding...');\n                nextEvent.resolve(false);\n                return;\n            }\n\n            if (outcomeResource.success) {\n                this._taskContentService.updateStateData(outcomeResource.outcome as DelegateTaskEventOutcome);\n                const changedFieldsMap: ChangedFieldsMap = this._eventService\n                    .parseChangedFieldsFromOutcomeTree(outcomeResource.outcome);\n                if (!!changedFieldsMap) {\n                    this._changedFieldsService.emitChangedFields(changedFieldsMap);\n                }\n                this.completeSuccess(afterAction, nextEvent);\n            } else if (outcomeResource.error) {\n                this._snackBar.openErrorSnackBar(outcomeResource.error);\n                this.completeActions(afterAction, nextEvent, false);\n            }\n        }, error => {\n            this._taskState.stopLoading(delegatedTaskId);\n            this._log.debug('getting task data failed', error);\n\n            if (!this.isTaskRelevant(delegatedTaskId)) {\n                this._log.debug('current task changed before the delegate error could be received');\n                nextEvent.resolve(false);\n                return;\n            }\n\n            this._snackBar.openErrorSnackBar(`${this._translate.instant('tasks.snackbar.assignTask')}\n                     ${this._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     * Completes all the action streams and sends the notification, with the provided result\n     */\n    protected completeActions(afterAction: AfterAction, nextEvent: AfterAction, result: boolean) {\n        this.sendNotification(result);\n        afterAction.resolve(result);\n        nextEvent.resolve(result);\n    }\n\n    /**\n     * Publishes a delegate notification to the {@link TaskEventService}\n     * @param success whether the delegate operation was successful or not\n     */\n    protected sendNotification(success: boolean): void {\n        this._taskEvent.publishTaskEvent(createTaskEventNotification(this._safeTask, TaskEvent.DELEGATE, success));\n    }\n}\n"]}

package/esm2015/lib/task/services/finish-policy.service.js

@@ -0,0 +1,79 @@
+import { Inject, Injectable } from '@angular/core';
+import { TaskHandlingService } from './task-handling-service';
+import { TaskContentService } from '../../task-content/services/task-content.service';
+import { FinishPolicy } from '../../task-content/model/policy';
+import { DataFocusPolicyService } from './data-focus-policy.service';
+import { NAE_TASK_OPERATIONS } from '../models/task-operations-injection-token';
+import { FinishTaskService } from './finish-task.service';
+import { AfterAction } from '../../utility/call-chain/after-action';
+/**
+ * Handles the sequence of actions that are performed when a task is being finished, based on the task's configuration.
+ */
+export class FinishPolicyService extends TaskHandlingService {
+    constructor(_dataFocusPolicyService, _finishTaskService, _taskOperations, taskContentService) {
+        super(taskContentService);
+        this._dataFocusPolicyService = _dataFocusPolicyService;
+        this._finishTaskService = _finishTaskService;
+        this._taskOperations = _taskOperations;
+    }
+    /**
+     * Performs the actions that correspond to the policy defined by the Task when it's finished.
+     * @param afterAction the action that should be performed when the finish policy finishes
+     */
+    performFinishPolicy(afterAction = new AfterAction()) {
+        if (this._safeTask.finishPolicy === FinishPolicy.autoNoData) {
+            this.autoNoDataFinishPolicy(afterAction);
+        }
+        else {
+            this.manualFinishPolicy(afterAction);
+        }
+    }
+    /**
+     * Performs the actions that correspond to the [Auto Finish Policy]{@link FinishPolicy#autoNoData}.
+     *
+     * If the task has no data performs finish and [closes]{@link TaskOperations#close} the task.
+     * Otherwise [opens]{@link TaskOperations#open} it and performs the [data focus policy]{@link DataFocusPolicyService}.
+     *
+     * @param afterAction the action that should be performed when the finish policy finishes
+     */
+    autoNoDataFinishPolicy(afterAction) {
+        if (this._safeTask.dataSize <= 0) {
+            this._finishTaskService.validateDataAndFinish(afterAction);
+            this._taskOperations.close();
+        }
+        else {
+            this._taskOperations.open();
+            this._dataFocusPolicyService.performDataFocusPolicy();
+            afterAction.resolve(true);
+        }
+    }
+    /**
+     * Performs the actions that correspond to the [Manual Finish Policy]{@link FinishPolicy#manual}.
+     *
+     * [Opens]{@link TaskOperations#open} the task and performs the [data focus policy]{@link DataFocusPolicyService}.
+     *
+     * @param afterAction the action that should be performed when the finish policy finishes
+     */
+    manualFinishPolicy(afterAction) {
+        this._taskOperations.open();
+        this._dataFocusPolicyService.performDataFocusPolicy();
+        afterAction.next(true);
+        afterAction.complete();
+    }
+}
+FinishPolicyService.ctorParameters = () => [
+    { type: DataFocusPolicyService },
+    { type: FinishTaskService },
+    { type: undefined, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] },
+    { type: TaskContentService }
+];
+FinishPolicyService.decorators = [
+    { type: Injectable }
+];
+FinishPolicyService.ctorParameters = () => [
+    { type: DataFocusPolicyService },
+    { type: FinishTaskService },
+    { type: undefined, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] },
+    { type: TaskContentService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/task/services/finish-task.service.js

@@ -0,0 +1,207 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { take } from 'rxjs/operators';
+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 { TaskDataService } from './task-data.service';
+import { TaskHandlingService } from './task-handling-service';
+import { NAE_TASK_OPERATIONS } from '../models/task-operations-injection-token';
+import { CallChainService } from '../../utility/call-chain/call-chain.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 { TaskEventService } from '../../task-content/services/task-event.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 finishing a task.
+ */
+export class FinishTaskService extends TaskHandlingService {
+    constructor(_log, _taskResourceService, _snackBar, _translate, _taskState, _taskDataService, _callChain, _taskEvent, _eventQueue, _eventService, _changedFieldsService, _taskOperations, _selectedCaseService, _taskContentService) {
+        super(_taskContentService, _selectedCaseService);
+        this._log = _log;
+        this._taskResourceService = _taskResourceService;
+        this._snackBar = _snackBar;
+        this._translate = _translate;
+        this._taskState = _taskState;
+        this._taskDataService = _taskDataService;
+        this._callChain = _callChain;
+        this._taskEvent = _taskEvent;
+        this._eventQueue = _eventQueue;
+        this._eventService = _eventService;
+        this._changedFieldsService = _changedFieldsService;
+        this._taskOperations = _taskOperations;
+    }
+    /**
+     * Updates the task data to their current state from backend, checks the validity of the data and
+     * sends a finish request to backend.
+     *
+     * Finish request is not sent if the task contains invalid data.
+     *
+     * If an update to the data is already in progress waits for it's successful completion and sends the finish request after.
+     *
+     * @param afterAction if finish request completes successfully `true` will be emitted into this Subject,
+     * otherwise `false` will be emitted
+     */
+    validateDataAndFinish(afterAction = new AfterAction()) {
+        if (this._safeTask.dataSize <= 0) {
+            this._taskDataService.initializeTaskDataFields(this._callChain.create(() => {
+                if (this._safeTask.dataSize <= 0 ||
+                    (this._taskContentService.validateDynamicEnumField() && this._taskContentService.validateTaskData())) {
+                    this.queueFinishTaskRequest(afterAction);
+                }
+            }));
+        }
+        else if (this._taskContentService.validateDynamicEnumField() && this._taskContentService.validateTaskData()) {
+            const finishedTaskId = this._safeTask.stringId;
+            this._taskDataService.updateTaskDataFields(this._callChain.create(success => {
+                if (success) {
+                    if (this._taskState.isUpdating(finishedTaskId)) {
+                        this._taskDataService.updateSuccess$.pipe(take(1)).subscribe(bool => {
+                            if (bool) {
+                                this.queueFinishTaskRequest(afterAction);
+                            }
+                        });
+                    }
+                    else {
+                        this.queueFinishTaskRequest(afterAction);
+                    }
+                }
+            }));
+        }
+    }
+    /**
+     * Sends the finish request to backend and notifies the user about the outcome of the operation via a snack bar message.
+     *
+     * 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 finish request.
+     *
+     * 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 finish request completes successfully `true` will be emitted into this Subject,
+     * otherwise `false` will be emitted
+     */
+    queueFinishTaskRequest(afterAction) {
+        this._eventQueue.scheduleEvent(new QueuedEvent(() => true, nextEvent => {
+            this.performFinishRequest(afterAction, nextEvent);
+        }));
+    }
+    /**
+     * Performs a `finish` 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
+     */
+    performFinishRequest(afterAction, nextEvent) {
+        const finishedTaskId = this._safeTask.stringId;
+        // this is probably no longer necessary because of the event queue
+        if (this._taskState.isLoading(finishedTaskId)) {
+            nextEvent.resolve(true);
+            return;
+        }
+        this._taskState.startLoading(finishedTaskId);
+        this._taskResourceService.finishTask(this._safeTask.stringId).pipe(take(1))
+            .subscribe((outcomeResource) => {
+            this._taskState.stopLoading(finishedTaskId);
+            if (!this.isTaskRelevant(finishedTaskId)) {
+                this._log.debug('current task changed before the finish response could be received, discarding...');
+                nextEvent.resolve(false);
+                return;
+            }
+            if (outcomeResource.success) {
+                this._taskContentService.updateStateData(outcomeResource.outcome);
+                const changedFieldsMap = this._eventService
+                    .parseChangedFieldsFromOutcomeTree(outcomeResource.outcome);
+                if (!!changedFieldsMap) {
+                    this._changedFieldsService.emitChangedFields(changedFieldsMap);
+                }
+                this._taskOperations.reload();
+                this.completeActions(afterAction, nextEvent, true);
+                this._taskOperations.close();
+                this._snackBar.openSuccessSnackBar(outcomeResource.outcome.message === undefined
+                    ? this._translate.instant('tasks.snackbar.finishTaskSuccess')
+                    : outcomeResource.outcome.message);
+            }
+            else if (outcomeResource.error !== undefined) {
+                if (outcomeResource.error !== '') {
+                    this._snackBar.openErrorSnackBar(outcomeResource.error);
+                }
+                if (outcomeResource.outcome !== undefined) {
+                    const changedFieldsMap = this._eventService.parseChangedFieldsFromOutcomeTree(outcomeResource.outcome);
+                    this._changedFieldsService.emitChangedFields(changedFieldsMap);
+                }
+                this.completeActions(afterAction, nextEvent, false);
+            }
+        }, error => {
+            this._taskState.stopLoading(finishedTaskId);
+            this._log.debug('finishing task failed', error);
+            if (!this.isTaskRelevant(finishedTaskId)) {
+                this._log.debug('current task changed before the finish error could be received');
+                nextEvent.resolve(false);
+                return;
+            }
+            this._snackBar.openErrorSnackBar(`${this._translate.instant('tasks.snackbar.finishTask')}
+             ${this._task.title} ${this._translate.instant('tasks.snackbar.failed')}`);
+            this.completeActions(afterAction, nextEvent, false);
+        });
+    }
+    /**
+     * Completes all the action streams and sends the notification, with the provided result
+     */
+    completeActions(afterAction, nextEvent, result) {
+        this.sendNotification(result);
+        afterAction.resolve(result);
+        nextEvent.resolve(result);
+    }
+    /**
+     * Publishes a finish notification to the {@link TaskEventService}
+     * @param success whether the finish operation was successful or not
+     */
+    sendNotification(success) {
+        this._taskEvent.publishTaskEvent(createTaskEventNotification(this._safeTask, TaskEvent.FINISH, success));
+    }
+}
+FinishTaskService.ctorParameters = () => [
+    { type: LoggerService },
+    { type: TaskResourceService },
+    { type: SnackBarService },
+    { type: TranslateService },
+    { type: TaskRequestStateService },
+    { type: TaskDataService },
+    { type: CallChainService },
+    { type: TaskEventService },
+    { type: EventQueueService },
+    { type: EventService },
+    { type: ChangedFieldsService },
+    { type: undefined, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] },
+    { type: SelectedCaseService, decorators: [{ type: Optional }] },
+    { type: TaskContentService }
+];
+FinishTaskService.decorators = [
+    { type: Injectable }
+];
+FinishTaskService.ctorParameters = () => [
+    { type: LoggerService },
+    { type: TaskResourceService },
+    { type: SnackBarService },
+    { type: TranslateService },
+    { type: TaskRequestStateService },
+    { type: TaskDataService },
+    { type: CallChainService },
+    { type: TaskEventService },
+    { type: EventQueueService },
+    { type: EventService },
+    { type: ChangedFieldsService },
+    { type: undefined, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] },
+    { type: SelectedCaseService, decorators: [{ type: Optional }] },
+    { type: TaskContentService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"finish-task.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/task/services/finish-task.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, Optional} from '@angular/core';\nimport {take} from 'rxjs/operators';\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 {TaskDataService} from './task-data.service';\nimport {TaskHandlingService} from './task-handling-service';\nimport {NAE_TASK_OPERATIONS} from '../models/task-operations-injection-token';\nimport {TaskOperations} from '../interfaces/task-operations';\nimport {CallChainService} from '../../utility/call-chain/call-chain.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 {TaskEventService} from '../../task-content/services/task-event.service';\nimport {FinishTaskEventOutcome} from '../../event/model/event-outcomes/task-outcomes/finish-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 {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 finishing a task.\n */\n@Injectable()\nexport class FinishTaskService 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 _taskDataService: TaskDataService,\n                protected _callChain: CallChainService,\n                protected _taskEvent: TaskEventService,\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                _taskContentService: TaskContentService) {\n        super(_taskContentService, _selectedCaseService);\n    }\n\n    /**\n     * Updates the task data to their current state from backend, checks the validity of the data and\n     * sends a finish request to backend.\n     *\n     * Finish request is not sent if the task contains invalid data.\n     *\n     * If an update to the data is already in progress waits for it's successful completion and sends the finish request after.\n     *\n     * @param afterAction if finish request completes successfully `true` will be emitted into this Subject,\n     * otherwise `false` will be emitted\n     */\n    public validateDataAndFinish(afterAction: AfterAction = new AfterAction()): void {\n        if (this._safeTask.dataSize <= 0) {\n            this._taskDataService.initializeTaskDataFields(this._callChain.create(() => {\n                if (this._safeTask.dataSize <= 0 ||\n                    (this._taskContentService.validateDynamicEnumField() && this._taskContentService.validateTaskData())) {\n                    this.queueFinishTaskRequest(afterAction);\n                }\n            }));\n        } else if (this._taskContentService.validateDynamicEnumField() && this._taskContentService.validateTaskData()) {\n            const finishedTaskId = this._safeTask.stringId;\n            this._taskDataService.updateTaskDataFields(this._callChain.create(success => {\n                if (success) {\n                    if (this._taskState.isUpdating(finishedTaskId)) {\n                        this._taskDataService.updateSuccess$.pipe(take(1)).subscribe(bool => {\n                            if (bool) {\n                                this.queueFinishTaskRequest(afterAction);\n                            }\n                        });\n                    } else {\n                        this.queueFinishTaskRequest(afterAction);\n                    }\n                }\n            }));\n        }\n    }\n\n    /**\n     * Sends the finish request to backend and notifies the user about the outcome of the operation via a snack bar message.\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 finish request.\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 finish request completes successfully `true` will be emitted into this Subject,\n     * otherwise `false` will be emitted\n     */\n    protected queueFinishTaskRequest(afterAction: AfterAction): void {\n        this._eventQueue.scheduleEvent(new QueuedEvent(\n            () => true,\n            nextEvent => {\n                this.performFinishRequest(afterAction, nextEvent);\n            }\n        ));\n    }\n\n    /**\n     * Performs a `finish` 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     */\n    protected performFinishRequest(afterAction: AfterAction, nextEvent: AfterAction) {\n        const finishedTaskId = this._safeTask.stringId;\n\n        // this is probably no longer necessary because of the event queue\n        if (this._taskState.isLoading(finishedTaskId)) {\n            nextEvent.resolve(true);\n            return;\n        }\n\n        this._taskState.startLoading(finishedTaskId);\n\n        this._taskResourceService.finishTask(this._safeTask.stringId).pipe(take(1))\n            .subscribe((outcomeResource: EventOutcomeMessageResource) => {\n            this._taskState.stopLoading(finishedTaskId);\n            if (!this.isTaskRelevant(finishedTaskId)) {\n                this._log.debug('current task changed before the finish response could be received, discarding...');\n                nextEvent.resolve(false);\n                return;\n            }\n\n            if (outcomeResource.success) {\n                this._taskContentService.updateStateData(outcomeResource.outcome as FinishTaskEventOutcome);\n                const changedFieldsMap: ChangedFieldsMap = this._eventService\n                    .parseChangedFieldsFromOutcomeTree(outcomeResource.outcome);\n                if (!!changedFieldsMap) {\n                    this._changedFieldsService.emitChangedFields(changedFieldsMap);\n                }\n                this._taskOperations.reload();\n                this.completeActions(afterAction, nextEvent, true);\n                this._taskOperations.close();\n                this._snackBar.openSuccessSnackBar(outcomeResource.outcome.message === undefined\n                    ? this._translate.instant('tasks.snackbar.finishTaskSuccess')\n                    : outcomeResource.outcome.message);\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(finishedTaskId);\n            this._log.debug('finishing task failed', error);\n\n            if (!this.isTaskRelevant(finishedTaskId)) {\n                this._log.debug('current task changed before the finish error could be received');\n                nextEvent.resolve(false);\n                return;\n            }\n\n            this._snackBar.openErrorSnackBar(`${this._translate.instant('tasks.snackbar.finishTask')}\n             ${this._task.title} ${this._translate.instant('tasks.snackbar.failed')}`);\n            this.completeActions(afterAction, nextEvent, false);\n        });\n    }\n\n    /**\n     * Completes all the action streams and sends the notification, with the provided result\n     */\n    protected completeActions(afterAction: AfterAction, nextEvent: AfterAction, result: boolean) {\n        this.sendNotification(result);\n        afterAction.resolve(result);\n        nextEvent.resolve(result);\n    }\n\n    /**\n     * Publishes a finish notification to the {@link TaskEventService}\n     * @param success whether the finish operation was successful or not\n     */\n    protected sendNotification(success: boolean): void {\n        this._taskEvent.publishTaskEvent(createTaskEventNotification(this._safeTask, TaskEvent.FINISH, success));\n    }\n}\n"]}

package/esm2015/lib/task/services/selected-case.service.js

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+/**
+ * Holds information about the currently selected {@link Case}.
+ *
+ * Services that handle various task operations, can use this service to take into consideration changes in frontend data in
+ * between backend call and backend response.
+ *
+ * This service is used by Tree Case View's {@link TreeTaskContentService}.
+ */
+export class SelectedCaseService {
+    constructor() {
+        this._selectedCase$ = new BehaviorSubject(undefined);
+    }
+    ngOnDestroy() {
+        this._selectedCase$.complete();
+    }
+    get selectedCase$() {
+        return this._selectedCase$.asObservable();
+    }
+    /**
+     * @param selectedCase the new value, that is emitted into the underlying stream
+     */
+    set selectedCase(selectedCase) {
+        this._selectedCase$.next(selectedCase);
+    }
+    /**
+     * @returns the current value of the underlying stream
+     */
+    get selectedCase() {
+        return this._selectedCase$.getValue();
+    }
+}
+SelectedCaseService.decorators = [
+    { type: Injectable }
+];
+SelectedCaseService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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