@netgrif/components-core
Version:
Netgrif Application engine frontend core Angular library
208 lines • 33.7 kB
JavaScript
import { Inject, Injectable, Optional } from '@angular/core';
import { take } from 'rxjs/operators';
import { TaskHandlingService } from './task-handling-service';
import { NAE_TASK_OPERATIONS } from '../models/task-operations-injection-token';
import { createTaskEventNotification } from '../../task-content/model/task-event-notification';
import { TaskEvent } from '../../task-content/model/task-event';
import { QueuedEvent } from '../../event-queue/model/queued-event';
import { AfterAction } from '../../utility/call-chain/after-action';
import * as i0 from "@angular/core";
import * as i1 from "../../logger/services/logger.service";
import * as i2 from "../../resources/engine-endpoint/task-resource.service";
import * as i3 from "../../snack-bar/services/snack-bar.service";
import * as i4 from "@ngx-translate/core";
import * as i5 from "./task-request-state.service";
import * as i6 from "./task-data.service";
import * as i7 from "../../utility/call-chain/call-chain.service";
import * as i8 from "../../task-content/services/task-event.service";
import * as i9 from "../../event-queue/services/event-queue.service";
import * as i10 from "../../event/services/event.service";
import * as i11 from "../../changed-fields/services/changed-fields.service";
import * as i12 from "./selected-case.service";
import * as i13 from "../../task-content/services/task-content.service";
import * as i14 from "../../actions/services/front-action.service";
/**
* Service that handles the logic of finishing a task.
*/
export class FinishTaskService extends TaskHandlingService {
_log;
_taskResourceService;
_snackBar;
_translate;
_taskState;
_taskDataService;
_callChain;
_taskEvent;
_eventQueue;
_eventService;
_changedFieldsService;
_taskOperations;
_frontActionService;
constructor(_log, _taskResourceService, _snackBar, _translate, _taskState, _taskDataService, _callChain, _taskEvent, _eventQueue, _eventService, _changedFieldsService, _taskOperations, _selectedCaseService, _taskContentService, _frontActionService) {
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;
this._frontActionService = _frontActionService;
}
/**
* 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.dataIsEmpty()) {
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 && this._taskState.isUpdating(finishedTaskId)) {
this._taskDataService.updateSuccess$.pipe(take(1)).subscribe(bool => {
if (bool) {
this.queueFinishTaskRequest(afterAction);
}
});
}
else if (success) {
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);
const frontActions = this._eventService.parseFrontActionsFromOutcomeTree(outcomeResource.outcome);
if (!!changedFieldsMap) {
this._changedFieldsService.emitChangedFields(changedFieldsMap);
}
if (frontActions?.length > 0) {
this._frontActionService.runAll(frontActions);
}
this._taskOperations.reload();
this.completeActions(afterAction, nextEvent, true, outcomeResource.outcome);
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, outcome) {
this.sendNotification(result, outcome);
afterAction.resolve(result);
nextEvent.resolve(result);
}
/**
* Publishes a finish notification to the {@link TaskEventService}
* @param success whether the finish operation was successful or not
* @param outcome TaskEventOutcome
*/
sendNotification(success, outcome) {
this._taskEvent.publishTaskEvent(createTaskEventNotification(this._safeTask, TaskEvent.FINISH, success, outcome));
}
/**
* Checks data size
* @return boolean whether the task contains data or not
*/
dataIsEmpty() {
return this._safeTask.dataSize <= 0 || !this._safeTask.dataGroups || this._safeTask.dataGroups.length <= 0;
}
static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FinishTaskService, deps: [{ token: i1.LoggerService }, { token: i2.TaskResourceService }, { token: i3.SnackBarService }, { token: i4.TranslateService }, { token: i5.TaskRequestStateService }, { token: i6.TaskDataService }, { token: i7.CallChainService }, { token: i8.TaskEventService }, { token: i9.EventQueueService }, { token: i10.EventService }, { token: i11.ChangedFieldsService }, { token: NAE_TASK_OPERATIONS }, { token: i12.SelectedCaseService, optional: true }, { token: i13.TaskContentService }, { token: i14.FrontActionService }], target: i0.ɵɵFactoryTarget.Injectable });
static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FinishTaskService });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FinishTaskService, decorators: [{
type: Injectable
}], ctorParameters: () => [{ type: i1.LoggerService }, { type: i2.TaskResourceService }, { type: i3.SnackBarService }, { type: i4.TranslateService }, { type: i5.TaskRequestStateService }, { type: i6.TaskDataService }, { type: i7.CallChainService }, { type: i8.TaskEventService }, { type: i9.EventQueueService }, { type: i10.EventService }, { type: i11.ChangedFieldsService }, { type: undefined, decorators: [{
type: Inject,
args: [NAE_TASK_OPERATIONS]
}] }, { type: i12.SelectedCaseService, decorators: [{
type: Optional
}] }, { type: i13.TaskContentService }, { type: i14.FrontActionService }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"finish-task.service.js","sourceRoot":"","sources":["../../../../../../projects/netgrif-components-core/src/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';\nimport {TaskEventOutcome} from '../../event/model/event-outcomes/task-outcomes/task-event-outcome';\nimport {FrontActionService} from '../../actions/services/front-action.service';\nimport {FrontAction} from '../../data-fields/models/changed-fields';\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                protected _frontActionService: FrontActionService) {\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.dataIsEmpty()) {\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 && this._taskState.isUpdating(finishedTaskId)) {\n                        this._taskDataService.updateSuccess$.pipe(take(1)).subscribe(bool => {\n                            if (bool) {\n                                this.queueFinishTaskRequest(afterAction);\n                            }\n                        });\n                    } else if (success) {\n                        this.queueFinishTaskRequest(afterAction);\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                const frontActions: Array<FrontAction> = this._eventService.parseFrontActionsFromOutcomeTree(outcomeResource.outcome);\n                \n                if (!!changedFieldsMap) {\n                    this._changedFieldsService.emitChangedFields(changedFieldsMap);\n                }\n                if (frontActions?.length > 0) {\n                    this._frontActionService.runAll(frontActions);\n                }\n\n                this._taskOperations.reload();\n                this.completeActions(afterAction, nextEvent, true, outcomeResource.outcome as FinishTaskEventOutcome);\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, outcome?: TaskEventOutcome) {\n        this.sendNotification(result, outcome);\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     * @param outcome TaskEventOutcome\n     */\n    protected sendNotification(success: boolean, outcome?: TaskEventOutcome): void {\n        this._taskEvent.publishTaskEvent(createTaskEventNotification(this._safeTask, TaskEvent.FINISH, success, outcome));\n    }\n\n    /**\n     * Checks data size\n     * @return boolean whether the task contains data or not\n     */\n    private dataIsEmpty(): boolean {\n        return this._safeTask.dataSize <= 0 || !this._safeTask.dataGroups || this._safeTask.dataGroups.length <= 0;\n    }\n}\n"]}