@netgrif/components-core
Version:
Netgrif Application engine frontend core Angular library
287 lines • 42.8 kB
JavaScript
import { Inject, Injectable } from '@angular/core';
import { AssignPolicy } from '../../../task-content/model/policy';
import { NAE_TASK_OPERATIONS } from '../../../task/models/task-operations-injection-token';
import { TreePetriflowIdentifiers } from '../model/tree-petriflow-identifiers';
import { LoadingEmitter } from '../../../utility/loading-emitter';
import { ReplaySubject } from 'rxjs';
import { hasContent } from '../../../utility/pagination/page-has-content';
import { getImmediateData } from '../../../utility/get-immediate-data';
import { filter } from 'rxjs/operators';
import { SimpleFilter } from '../../../filter/models/simple-filter';
import * as i0 from "@angular/core";
import * as i1 from "../tree-case-view.service";
import * as i2 from "../../../task/services/task-data.service";
import * as i3 from "../../../task-content/services/task-content.service";
import * as i4 from "../../../resources/engine-endpoint/task-resource.service";
import * as i5 from "../../../task-content/services/task-event.service";
import * as i6 from "../../../task/services/assign-policy.service";
import * as i7 from "../../../task/services/cancel-task.service";
import * as i8 from "../../../user/services/user-comparator.service";
import * as i9 from "../../../utility/call-chain/call-chain.service";
import * as i10 from "../../../logger/services/logger.service";
import * as i11 from "../../../task/services/selected-case.service";
import * as i12 from "../../../changed-fields/services/changed-fields.service";
import * as i13 from "../../../authorization/permission/permission.service";
import * as i14 from "../../../task/models/subject-task-operations";
export class TreeTaskContentService {
_treeCaseService;
_taskDataService;
_taskContentService;
_taskResourceService;
_taskEventService;
_assignPolicy;
_cancel;
_userComparator;
_callchain;
_logger;
_selectedCaseService;
_changedFieldsService;
_permissionService;
_taskOperations;
_processingTaskChange;
_displayedTaskText$;
/**
* a unique identifier consisting of caseId and transition ID
*
* Is set if a reload of the given task is currently taking place, `undefined` otherwise.
*/
_reloadedTaskUniqueIdentifier;
constructor(_treeCaseService, _taskDataService, _taskContentService, _taskResourceService, _taskEventService, _assignPolicy, _cancel, _userComparator, _callchain, _logger, _selectedCaseService, _changedFieldsService, _permissionService, _taskOperations) {
this._treeCaseService = _treeCaseService;
this._taskDataService = _taskDataService;
this._taskContentService = _taskContentService;
this._taskResourceService = _taskResourceService;
this._taskEventService = _taskEventService;
this._assignPolicy = _assignPolicy;
this._cancel = _cancel;
this._userComparator = _userComparator;
this._callchain = _callchain;
this._logger = _logger;
this._selectedCaseService = _selectedCaseService;
this._changedFieldsService = _changedFieldsService;
this._permissionService = _permissionService;
this._taskOperations = _taskOperations;
this._processingTaskChange = new LoadingEmitter();
this._displayedTaskText$ = new ReplaySubject();
this._changedFieldsService.changedFields$.subscribe((changedFieldsMap) => {
const filteredCaseIds = Object.keys(changedFieldsMap).filter(caseId => Object.keys(this._taskContentService.referencedTaskAndCaseIds).includes(caseId));
const changedFields = [];
filteredCaseIds.forEach(caseId => {
const taskIds = this._taskContentService.referencedTaskAndCaseIds[caseId];
changedFields.push(...this._changedFieldsService.parseChangedFieldsByCaseAndTaskIds(caseId, taskIds, changedFieldsMap));
});
changedFields.filter(fields => fields !== undefined).forEach(fields => {
this._taskContentService.updateFromChangedFields(fields);
});
});
_taskDataService.updateSuccess$.subscribe(result => {
if (result) {
this._treeCaseService.reloadCase$.next();
this.resolveTaskBlockState();
}
});
_treeCaseService.loadTask$.asObservable().pipe(filter(selectedCase => this.taskChanged(selectedCase))).subscribe(selectedCase => {
this.cancelAndLoadFeaturedTask(selectedCase);
});
_taskOperations.reload$.subscribe(() => {
this.updateTaskState();
this._treeCaseService.reloadCase$.next();
});
_taskOperations.open$.subscribe(() => {
this._taskContentService.blockFields(false);
});
_taskOperations.close$.subscribe(() => {
this._taskContentService.blockFields(true);
});
}
get taskContentText$() {
return this._displayedTaskText$.asObservable();
}
get processingTaskChange() {
return this._processingTaskChange.isActive;
}
displayEmptyTaskContent() {
this._taskContentService.$shouldCreate.next([]);
this._displayedTaskText$.next('caseTree.noTaskSelected');
}
/**
* Cancels the currently selected {@link Task} if any. And then loads and assigns the new Task.
* @param selectedCase the Case who's task should be now displayed
*/
cancelAndLoadFeaturedTask(selectedCase) {
this._processingTaskChange.on();
this._taskContentService.blockFields(true);
if (this.shouldCancelTask) {
this._cancel.cancel(this._callchain.create(success => {
if (success) {
this._logger.debug('Old tree task successfully canceled');
}
else {
this._logger.warn('Old tree task could not be canceled');
}
}));
}
this.loadFeaturedTask(selectedCase);
}
/**
* Changes the currently displayed {@link Task} based on the selected {@link Case} from the Tree.
* @param selectedCase the Case who's task should be now displayed
*/
loadFeaturedTask(selectedCase) {
this._selectedCaseService.selectedCase = selectedCase;
const requestBody = this.getTaskFilter();
if (requestBody === undefined) {
this.clearCurrentTask();
return;
}
this._taskResourceService.getTasks(requestBody).subscribe(page => {
if (hasContent(page)) {
this.setStandardTaskText();
this.switchToTask(page.content[0]);
}
else {
this.clearCurrentTask();
}
});
}
/**
* Checks whether the currently displayed task differs from the new one
* @param newCase [Case]{@link Case} object that holds the newly selected {@link Task}
* @returns `true` if the currently selected Case has a different ID from the newly selected Case.
* If the IDs are the same returns `true` if the transition IDs are different.
* Returns `false` otherwise.
*/
taskChanged(newCase) {
const currentCaseId = this._selectedCaseService.selectedCase ? this._selectedCaseService.selectedCase.stringId : undefined;
const newCaseId = newCase ? newCase.stringId : undefined;
if (currentCaseId !== newCaseId) {
return true;
}
const currentTransitionId = this.getTransitionId(this._selectedCaseService.selectedCase);
const newTransitionId = this.getTransitionId(newCase);
return currentTransitionId !== newTransitionId;
}
/**
* Checks whether a Task object is currently selected and if it can be cancelled by the user
*/
get shouldCancelTask() {
return this._taskContentService.task && this._permissionService.canCancel(this._taskContentService.task);
}
/**
* Creates a {@link Filter} object that finds the specified Task for the currently selected Case in a Tree Case View
* @returns a request body that finds tasks of the given case with task id that corresponds to the value in the `treeTaskTransitionId`
* immediate data field. Returns `undefined` if the request body cannot be created.
*/
getTaskFilter() {
const transitionId = this.getTransitionId(this._selectedCaseService.selectedCase);
if (transitionId) {
return SimpleFilter.fromTaskQuery({
case: { id: this._selectedCaseService.selectedCase.stringId },
transitionId
});
}
return undefined;
}
/**
* @param examinedCase the {@link Case} object from which we want to extract the transition ID
* @returns the ID of the transition that should be displayed in the {@link AbstractTaskContentComponent},
* or `undefined` if the currently selected case doesn't define it
*/
getTransitionId(examinedCase) {
if (examinedCase && examinedCase.immediateData) {
const transitionId = getImmediateData(examinedCase, TreePetriflowIdentifiers.FEATURED_TRANSITION);
return transitionId ? transitionId.value : undefined;
}
return undefined;
}
/**
* Changes the currently selected {@link Task}.
* @param task the Task that should now be selected
*/
switchToTask(task) {
if (task.caseId !== this._selectedCaseService.selectedCase.stringId) {
this._logger.debug('Tree featured task has been loaded, but the selected case has changed since. Discarding...');
return;
}
task.assignPolicy = AssignPolicy.auto;
this._taskContentService.task = task;
this._taskContentService.blockFields(true);
this._assignPolicy.performAssignPolicy(true, this._callchain.create(() => {
this._processingTaskChange.off();
}));
}
/**
* Notifies all connected Services that no Task is currently selected
*/
clearCurrentTask() {
this._taskContentService.task = undefined;
this.displayEmptyTaskContent();
this._processingTaskChange.off();
}
/**
* Updates the state of the current Task from backend
*/
updateTaskState() {
const uniqueTaskIdentifier = this.getUniqueTaskIdentifier();
if (uniqueTaskIdentifier === this._reloadedTaskUniqueIdentifier) {
this._logger.debug('The currently selected task is already being reloaded. Ignoring reload request.');
return;
}
this._reloadedTaskUniqueIdentifier = uniqueTaskIdentifier;
this._taskResourceService.getTasks(this.getTaskFilter()).subscribe(page => {
if (hasContent(page)) {
if (this._taskContentService.task && this._taskContentService.task.stringId === page.content[0].stringId) {
this._reloadedTaskUniqueIdentifier = undefined;
Object.assign(this._taskContentService.task, page.content[0]);
}
this.resolveTaskBlockState();
}
});
}
/**
* If the current {@link Task} is assigned to the current user it is unblocked. Otherwise it is blocked.
*/
resolveTaskBlockState() {
const taskShouldBeBlocked = !this._taskContentService.task
|| this._taskContentService.task.assignee === undefined
|| !this._userComparator.compareUsers(this._taskContentService.task.assignee?.id);
this._taskContentService.blockFields(taskShouldBeBlocked);
}
/**
* Sets the noData text in the task content to it's default value
*/
setStandardTaskText() {
this._displayedTaskText$.next(undefined);
}
/**
* Attempts to cancel the currently opened Task if the Task is in such state that allows cancellation.
*/
ngOnDestroy() {
if (this.shouldCancelTask) {
this._cancel.cancel();
}
if (this._taskOperations) {
this._taskOperations.destroy();
}
}
/**
* @returns a unique identifier for the currently selected task, that consists of it's case's id and it's transition id.
*
* Returns `undefined`, if no task is currently selected.
*/
getUniqueTaskIdentifier() {
if (!this._selectedCaseService.selectedCase) {
return undefined;
}
return `${this._selectedCaseService.selectedCase.stringId}#${this.getTransitionId(this._selectedCaseService.selectedCase)}`;
}
static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TreeTaskContentService, deps: [{ token: i1.TreeCaseViewService }, { token: i2.TaskDataService }, { token: i3.TaskContentService }, { token: i4.TaskResourceService }, { token: i5.TaskEventService }, { token: i6.AssignPolicyService }, { token: i7.CancelTaskService }, { token: i8.UserComparatorService }, { token: i9.CallChainService }, { token: i10.LoggerService }, { token: i11.SelectedCaseService }, { token: i12.ChangedFieldsService }, { token: i13.PermissionService }, { token: NAE_TASK_OPERATIONS }], target: i0.ɵɵFactoryTarget.Injectable });
static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TreeTaskContentService });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TreeTaskContentService, decorators: [{
type: Injectable
}], ctorParameters: () => [{ type: i1.TreeCaseViewService }, { type: i2.TaskDataService }, { type: i3.TaskContentService }, { type: i4.TaskResourceService }, { type: i5.TaskEventService }, { type: i6.AssignPolicyService }, { type: i7.CancelTaskService }, { type: i8.UserComparatorService }, { type: i9.CallChainService }, { type: i10.LoggerService }, { type: i11.SelectedCaseService }, { type: i12.ChangedFieldsService }, { type: i13.PermissionService }, { type: i14.SubjectTaskOperations, decorators: [{
type: Inject,
args: [NAE_TASK_OPERATIONS]
}] }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-task-content.service.js","sourceRoot":"","sources":["../../../../../../../projects/netgrif-components-core/src/lib/view/tree-case-view/tree-task-content/tree-task-content.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, OnDestroy} from '@angular/core';\nimport {TaskContentService} from '../../../task-content/services/task-content.service';\nimport {TaskDataService} from '../../../task/services/task-data.service';\nimport {CancelTaskService} from '../../../task/services/cancel-task.service';\nimport {TaskEventService} from '../../../task-content/services/task-event.service';\nimport {TaskResourceService} from '../../../resources/engine-endpoint/task-resource.service';\nimport {TreeCaseViewService} from '../tree-case-view.service';\nimport {Case} from '../../../resources/interface/case';\nimport {Task} from '../../../resources/interface/task';\nimport {AssignPolicyService} from '../../../task/services/assign-policy.service';\nimport {AssignPolicy} from '../../../task-content/model/policy';\nimport {NAE_TASK_OPERATIONS} from '../../../task/models/task-operations-injection-token';\nimport {SubjectTaskOperations} from '../../../task/models/subject-task-operations';\nimport {UserComparatorService} from '../../../user/services/user-comparator.service';\nimport {TreePetriflowIdentifiers} from '../model/tree-petriflow-identifiers';\nimport {CallChainService} from '../../../utility/call-chain/call-chain.service';\nimport {LoadingEmitter} from '../../../utility/loading-emitter';\nimport {Observable, ReplaySubject, Subject} from 'rxjs';\nimport {hasContent} from '../../../utility/pagination/page-has-content';\nimport {getImmediateData} from '../../../utility/get-immediate-data';\nimport {filter} from 'rxjs/operators';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {SelectedCaseService} from '../../../task/services/selected-case.service';\nimport {Filter} from '../../../filter/models/filter';\nimport {SimpleFilter} from '../../../filter/models/simple-filter';\nimport {PermissionService} from '../../../authorization/permission/permission.service';\nimport {ChangedFieldsService} from '../../../changed-fields/services/changed-fields.service';\nimport {ChangedFields} from '../../../data-fields/models/changed-fields';\nimport {ChangedFieldsMap} from '../../../event/services/interfaces/changed-fields-map';\n\n@Injectable()\nexport class TreeTaskContentService implements OnDestroy {\n\n    private _processingTaskChange: LoadingEmitter;\n    private _displayedTaskText$: ReplaySubject<string>;\n    /**\n     * a unique identifier consisting of caseId and transition ID\n     *\n     * Is set if a reload of the given task is currently taking place, `undefined` otherwise.\n     */\n    private _reloadedTaskUniqueIdentifier: string;\n\n    constructor(protected _treeCaseService: TreeCaseViewService,\n                protected _taskDataService: TaskDataService,\n                protected _taskContentService: TaskContentService,\n                protected _taskResourceService: TaskResourceService,\n                protected _taskEventService: TaskEventService,\n                protected _assignPolicy: AssignPolicyService,\n                protected _cancel: CancelTaskService,\n                protected _userComparator: UserComparatorService,\n                protected _callchain: CallChainService,\n                protected _logger: LoggerService,\n                protected _selectedCaseService: SelectedCaseService,\n                protected _changedFieldsService: ChangedFieldsService,\n                protected _permissionService: PermissionService,\n                @Inject(NAE_TASK_OPERATIONS) protected _taskOperations: SubjectTaskOperations) {\n        this._processingTaskChange = new LoadingEmitter();\n        this._displayedTaskText$ = new ReplaySubject<string>();\n\n        this._changedFieldsService.changedFields$.subscribe((changedFieldsMap: ChangedFieldsMap) => {\n            const filteredCaseIds: Array<string> = Object.keys(changedFieldsMap).filter(\n                caseId => Object.keys(this._taskContentService.referencedTaskAndCaseIds).includes(caseId)\n            );\n            const changedFields: Array<ChangedFields> = [];\n            filteredCaseIds.forEach(caseId => {\n                const taskIds: Array<string> = this._taskContentService.referencedTaskAndCaseIds[caseId];\n                changedFields.push(...this._changedFieldsService.parseChangedFieldsByCaseAndTaskIds(caseId, taskIds, changedFieldsMap));\n            });\n            changedFields.filter(fields => fields !== undefined).forEach(fields => {\n                this._taskContentService.updateFromChangedFields(fields);\n            });\n        });\n        _taskDataService.updateSuccess$.subscribe(result => {\n            if (result) {\n                this._treeCaseService.reloadCase$.next();\n                this.resolveTaskBlockState();\n            }\n        });\n\n        _treeCaseService.loadTask$.asObservable().pipe(filter(selectedCase => this.taskChanged(selectedCase))).subscribe(selectedCase => {\n            this.cancelAndLoadFeaturedTask(selectedCase);\n        });\n\n        _taskOperations.reload$.subscribe(() => {\n            this.updateTaskState();\n            this._treeCaseService.reloadCase$.next();\n        });\n        _taskOperations.open$.subscribe(() => {\n            this._taskContentService.blockFields(false);\n        });\n        _taskOperations.close$.subscribe(() => {\n            this._taskContentService.blockFields(true);\n        });\n    }\n\n    public get taskContentText$(): Observable<string> {\n        return this._displayedTaskText$.asObservable();\n    }\n\n    public get processingTaskChange(): boolean {\n        return this._processingTaskChange.isActive;\n    }\n\n    public displayEmptyTaskContent(): void {\n        this._taskContentService.$shouldCreate.next([]);\n        this._displayedTaskText$.next('caseTree.noTaskSelected');\n    }\n\n    /**\n     * Cancels the currently selected {@link Task} if any. And then loads and assigns the new Task.\n     * @param selectedCase the Case who's task should be now displayed\n     */\n    protected cancelAndLoadFeaturedTask(selectedCase: Case | undefined) {\n        this._processingTaskChange.on();\n        this._taskContentService.blockFields(true);\n        if (this.shouldCancelTask) {\n            this._cancel.cancel(this._callchain.create(success => {\n                if (success) {\n                    this._logger.debug('Old tree task successfully canceled');\n                } else {\n                    this._logger.warn('Old tree task could not be canceled');\n                }\n            }));\n        }\n        this.loadFeaturedTask(selectedCase);\n    }\n\n    /**\n     * Changes the currently displayed {@link Task} based on the selected {@link Case} from the Tree.\n     * @param selectedCase the Case who's task should be now displayed\n     */\n    protected loadFeaturedTask(selectedCase: Case | undefined): void {\n        this._selectedCaseService.selectedCase = selectedCase;\n\n        const requestBody = this.getTaskFilter();\n        if (requestBody === undefined) {\n            this.clearCurrentTask();\n            return;\n        }\n\n        this._taskResourceService.getTasks(requestBody).subscribe(page => {\n            if (hasContent(page)) {\n                this.setStandardTaskText();\n                this.switchToTask(page.content[0]);\n            } else {\n                this.clearCurrentTask();\n            }\n        });\n    }\n\n    /**\n     * Checks whether the currently displayed task differs from the new one\n     * @param newCase [Case]{@link Case} object that holds the newly selected {@link Task}\n     * @returns `true` if the currently selected Case has a different ID from the newly selected Case.\n     * If the IDs are the same returns `true` if the transition IDs are different.\n     * Returns `false` otherwise.\n     */\n    private taskChanged(newCase: Case | undefined): boolean {\n        const currentCaseId = this._selectedCaseService.selectedCase ? this._selectedCaseService.selectedCase.stringId : undefined;\n        const newCaseId = newCase ? newCase.stringId : undefined;\n        if (currentCaseId !== newCaseId) {\n            return true;\n        }\n\n        const currentTransitionId = this.getTransitionId(this._selectedCaseService.selectedCase);\n        const newTransitionId = this.getTransitionId(newCase);\n        return currentTransitionId !== newTransitionId;\n    }\n\n    /**\n     * Checks whether a Task object is currently selected and if it can be cancelled by the user\n     */\n    private get shouldCancelTask(): boolean {\n        return this._taskContentService.task && this._permissionService.canCancel(this._taskContentService.task);\n    }\n\n    /**\n     * Creates a {@link Filter} object that finds the specified Task for the currently selected Case in a Tree Case View\n     * @returns a request body that finds tasks of the given case with task id that corresponds to the value in the `treeTaskTransitionId`\n     * immediate data field. Returns `undefined` if the request body cannot be created.\n     */\n    protected getTaskFilter(): Filter | undefined {\n        const transitionId = this.getTransitionId(this._selectedCaseService.selectedCase);\n        if (transitionId) {\n            return SimpleFilter.fromTaskQuery({\n                case: {id: this._selectedCaseService.selectedCase.stringId},\n                transitionId\n            });\n        }\n        return undefined;\n    }\n\n    /**\n     * @param examinedCase the {@link Case} object from which we want to extract the transition ID\n     * @returns the ID of the transition that should be displayed in the {@link AbstractTaskContentComponent},\n     * or `undefined` if the currently selected case doesn't define it\n     */\n    protected getTransitionId(examinedCase: Case): string | undefined {\n        if (examinedCase && examinedCase.immediateData) {\n            const transitionId = getImmediateData(examinedCase, TreePetriflowIdentifiers.FEATURED_TRANSITION);\n            return transitionId ? transitionId.value : undefined;\n        }\n        return undefined;\n    }\n\n    /**\n     * Changes the currently selected {@link Task}.\n     * @param task the Task that should now be selected\n     */\n    protected switchToTask(task: Task): void {\n        if (task.caseId !== this._selectedCaseService.selectedCase.stringId) {\n            this._logger.debug('Tree featured task has been loaded, but the selected case has changed since. Discarding...');\n            return;\n        }\n\n        task.assignPolicy = AssignPolicy.auto;\n        this._taskContentService.task = task;\n        this._taskContentService.blockFields(true);\n        this._assignPolicy.performAssignPolicy(true, this._callchain.create(() => {\n            this._processingTaskChange.off();\n        }));\n    }\n\n    /**\n     * Notifies all connected Services that no Task is currently selected\n     */\n    protected clearCurrentTask(): void {\n        this._taskContentService.task = undefined;\n        this.displayEmptyTaskContent();\n        this._processingTaskChange.off();\n    }\n\n    /**\n     * Updates the state of the current Task from backend\n     */\n    protected updateTaskState(): void {\n        const uniqueTaskIdentifier = this.getUniqueTaskIdentifier();\n        if (uniqueTaskIdentifier === this._reloadedTaskUniqueIdentifier) {\n            this._logger.debug('The currently selected task is already being reloaded. Ignoring reload request.');\n            return;\n        }\n        this._reloadedTaskUniqueIdentifier = uniqueTaskIdentifier;\n        this._taskResourceService.getTasks(this.getTaskFilter()).subscribe(page => {\n            if (hasContent(page)) {\n                if (this._taskContentService.task && this._taskContentService.task.stringId === page.content[0].stringId) {\n                    this._reloadedTaskUniqueIdentifier = undefined;\n                    Object.assign(this._taskContentService.task, page.content[0]);\n                }\n                this.resolveTaskBlockState();\n            }\n        });\n    }\n\n    /**\n     * If the current {@link Task} is assigned to the current user it is unblocked. Otherwise it is blocked.\n     */\n    protected resolveTaskBlockState(): void {\n        const taskShouldBeBlocked = !this._taskContentService.task\n                                    || this._taskContentService.task.assignee === undefined\n                                    || !this._userComparator.compareUsers(this._taskContentService.task.assignee?.id);\n        this._taskContentService.blockFields(taskShouldBeBlocked);\n    }\n\n    /**\n     * Sets the noData text in the task content to it's default value\n     */\n    protected setStandardTaskText(): void {\n        this._displayedTaskText$.next(undefined);\n    }\n\n    /**\n     * Attempts to cancel the currently opened Task if the Task is in such state that allows cancellation.\n     */\n    ngOnDestroy(): void {\n        if (this.shouldCancelTask) {\n            this._cancel.cancel();\n        }\n        if (this._taskOperations) {\n            this._taskOperations.destroy();\n        }\n    }\n\n    /**\n     * @returns a unique identifier for the currently selected task, that consists of it's case's id and it's transition id.\n     *\n     * Returns `undefined`, if no task is currently selected.\n     */\n    protected getUniqueTaskIdentifier(): string {\n        if (!this._selectedCaseService.selectedCase) {\n            return undefined;\n        }\n        return `${this._selectedCaseService.selectedCase.stringId}#${this.getTransitionId(this._selectedCaseService.selectedCase)}`;\n    }\n}\n"]}