@hmcts/ccd-case-ui-toolkit 5.0.6-angular11-upgrade → 5.0.7-angular11-upgrade

package/esm2015/lib/shared/components/event-start/components/task-conflict/task-conflict.component.js

@@ -0,0 +1,54 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+const _c0 = function (a3) { return ["/", "cases", "case-details", a3, "tasks"]; };
+export class TaskConflictComponent {
+}
+TaskConflictComponent.ɵfac = function TaskConflictComponent_Factory(t) { return new (t || TaskConflictComponent)(); };
+TaskConflictComponent.ɵcmp = i0.ɵɵdefineComponent({ type: TaskConflictComponent, selectors: [["app-task-conflict"]], inputs: { task: "task", caseId: "caseId" }, decls: 18, vars: 3, consts: [[1, "govuk-!-margin-9"], ["aria-labelledby", "error-summary-title", "role", "alert", "tabindex", "-1", "data-module", "error-summary", 1, "govuk-error-summary"], ["id", "error-summary-title", 1, "govuk-error-summary__title"], [1, "govuk-error-summary__body"], [1, "govuk-list", "govuk-error-summary__list"], ["href", "#"], [1, "govuk-form-group", "govuk-form-group--error"], [1, "govuk-heading-m"], ["href", "javascript:void(0)", 3, "routerLink"]], template: function TaskConflictComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div", 0);
+        i0.ɵɵelementStart(1, "div", 1);
+        i0.ɵɵelementStart(2, "h2", 2);
+        i0.ɵɵtext(3, " There is a problem ");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(4, "div", 3);
+        i0.ɵɵelementStart(5, "ul", 4);
+        i0.ɵɵelementStart(6, "li");
+        i0.ɵɵelementStart(7, "a", 5);
+        i0.ɵɵtext(8, "Task conflict");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(9, "div", 6);
+        i0.ɵɵelementStart(10, "h2", 7);
+        i0.ɵɵtext(11, "Task conflict");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(12, "p");
+        i0.ɵɵtext(13, "This task cannot be completed due to conflict with another task or tasks for this case.");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(14, "p");
+        i0.ɵɵtext(15, "If the problem persists, contact William Priest");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(16, "a", 8);
+        i0.ɵɵtext(17, "Return to tasks tab");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(16);
+        i0.ɵɵproperty("routerLink", i0.ɵɵpureFunction1(1, _c0, ctx.caseId));
+    } }, directives: [i1.RouterLinkWithHref], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TaskConflictComponent, [{
+        type: Component,
+        args: [{
+                selector: 'app-task-conflict',
+                templateUrl: './task-conflict.component.html'
+            }]
+    }], null, { task: [{
+            type: Input
+        }], caseId: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/shared/components/event-start/components/task-unassigned/task-unassigned.component.js

@@ -0,0 +1,52 @@
+import { Component } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+const _c0 = function (a3) { return ["/", "cases", "case-details", a3, "tasks"]; };
+export class TaskUnassignedComponent {
+    constructor(route) {
+        this.route = route;
+        this.caseId = this.route.snapshot.data.case.case_id;
+    }
+}
+TaskUnassignedComponent.ɵfac = function TaskUnassignedComponent_Factory(t) { return new (t || TaskUnassignedComponent)(i0.ɵɵdirectiveInject(i1.ActivatedRoute)); };
+TaskUnassignedComponent.ɵcmp = i0.ɵɵdefineComponent({ type: TaskUnassignedComponent, selectors: [["app-task-unassigned"]], decls: 16, vars: 3, consts: [[1, "govuk-!-margin-9"], ["aria-labelledby", "error-summary-title", "role", "alert", "tabindex", "-1", "data-module", "error-summary", 1, "govuk-error-summary"], ["id", "error-summary-title", 1, "govuk-error-summary__title"], [1, "govuk-error-summary__body"], [1, "govuk-list", "govuk-error-summary__list"], ["href", "#"], [1, "govuk-form-group", "govuk-form-group--error"], [1, "govuk-heading-m"], ["href", "javascript:void(0)", 3, "routerLink"]], template: function TaskUnassignedComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div", 0);
+        i0.ɵɵelementStart(1, "div", 1);
+        i0.ɵɵelementStart(2, "h2", 2);
+        i0.ɵɵtext(3, " There is a problem ");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(4, "div", 3);
+        i0.ɵɵelementStart(5, "ul", 4);
+        i0.ɵɵelementStart(6, "li");
+        i0.ɵɵelementStart(7, "a", 5);
+        i0.ɵɵtext(8, "Task assignment required");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(9, "div", 6);
+        i0.ɵɵelementStart(10, "h2", 7);
+        i0.ɵɵtext(11, "Task assignment required");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(12, "p");
+        i0.ɵɵtext(13, "You must assign one of the available tasks from the task tab to continue with your work.");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(14, "a", 8);
+        i0.ɵɵtext(15, "Return to tasks tab to assign a task");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(14);
+        i0.ɵɵproperty("routerLink", i0.ɵɵpureFunction1(1, _c0, ctx.caseId));
+    } }, directives: [i1.RouterLinkWithHref], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TaskUnassignedComponent, [{
+        type: Component,
+        args: [{
+                selector: 'app-task-unassigned',
+                templateUrl: './task-unassigned.component.html'
+            }]
+    }], function () { return [{ type: i1.ActivatedRoute }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/shared/components/event-start/event-guard/event-start.guard.js

@@ -0,0 +1,103 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { of } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+import { AbstractAppConfig } from '../../../../app.config';
+import { SessionStorageService } from '../../../services/session/session-storage.service';
+import { WorkAllocationService } from '../../case-editor/services/work-allocation.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../case-editor/services/work-allocation.service";
+import * as i2 from "@angular/router";
+import * as i3 from "../../../../app.config";
+import * as i4 from "../../../services/session/session-storage.service";
+export class EventStartGuard {
+    constructor(workAllocationService, router, appConfig, sessionStorageService) {
+        this.workAllocationService = workAllocationService;
+        this.router = router;
+        this.appConfig = appConfig;
+        this.sessionStorageService = sessionStorageService;
+    }
+    canActivate(route) {
+        // Checks must be performed only for Work Allocation 2
+        if (this.appConfig.getWorkAllocationApiUrl().toLowerCase() === 'workallocation2') {
+            const caseId = route.params['cid'];
+            const eventId = route.params['eid'];
+            const taskId = route.queryParams['tid'];
+            // TODO: NavigationExtras should be used once Angular upgrade changes have been incorporated
+            const isComplete = route.queryParams['isComplete'];
+            const caseInfoStr = this.sessionStorageService.getItem('caseInfo');
+            if (caseInfoStr) {
+                const caseInfo = JSON.parse(caseInfoStr);
+                if (caseInfo && caseInfo.cid === caseId) {
+                    if (isComplete) {
+                        return of(true);
+                    }
+                    return this.workAllocationService.getTasksByCaseIdAndEventId(eventId, caseId, caseInfo.caseType, caseInfo.jurisdiction).pipe(switchMap((payload) => this.checkForTasks(payload, caseId, eventId, taskId)));
+                }
+            }
+        }
+        else {
+            // Checks not required, return true by default for Work Allocation 1
+            return of(true);
+        }
+    }
+    checkTaskInEventNotRequired(payload, caseId, taskId) {
+        if (!payload || !payload.tasks) {
+            return true;
+        }
+        const taskNumber = payload.tasks.length;
+        if (taskNumber === 0) {
+            // if there are no tasks just carry on
+            return true;
+        }
+        // Get number of tasks assigned to user
+        const userInfoStr = this.sessionStorageService.getItem('userDetails');
+        const userInfo = JSON.parse(userInfoStr);
+        const tasksAssignedToUser = payload.tasks.filter(x => x.task_state !== 'unassigned' && x.assignee === userInfo.id || x.assignee === userInfo.uid);
+        if (tasksAssignedToUser.length === 0) {
+            // if no tasks assigned to user carry on
+            return true;
+        }
+        else if (tasksAssignedToUser.length > 1 && !taskId) {
+            // if more than one task assigned to the user then give multiple tasks error
+            this.router.navigate([`/cases/case-details/${caseId}/multiple-tasks-exist`]);
+            return false;
+        }
+        else {
+            let task;
+            if (taskId) {
+                task = payload.tasks.find(x => x.id === taskId);
+            }
+            else {
+                task = tasksAssignedToUser[0];
+            }
+            // if one task assigned to user, allow user to complete event
+            this.sessionStorageService.setItem('taskToComplete', JSON.stringify(task));
+            return true;
+        }
+    }
+    checkForTasks(payload, caseId, eventId, taskId) {
+        // Clear taskToComplete from session as we will be starting the process for new task
+        this.sessionStorageService.removeItem('taskToComplete');
+        if (payload.task_required_for_event) {
+            // There are some issues in EventTriggerResolver/CaseService and/or CCD for some events
+            // which triggers the CanActivate guard again.
+            // If event start is initiated again, then we do not need to perform state machine processing again.
+            // https://tools.hmcts.net/jira/browse/EUI-5489
+            if (this.router && this.router.url && this.router.url.includes('event-start')) {
+                return of(true);
+            }
+            this.router.navigate([`/cases/case-details/${caseId}/event-start`], { queryParams: { caseId, eventId, taskId } });
+            return of(false);
+        }
+        else {
+            return of(this.checkTaskInEventNotRequired(payload, caseId, taskId));
+        }
+    }
+}
+EventStartGuard.ɵfac = function EventStartGuard_Factory(t) { return new (t || EventStartGuard)(i0.ɵɵinject(i1.WorkAllocationService), i0.ɵɵinject(i2.Router), i0.ɵɵinject(i3.AbstractAppConfig), i0.ɵɵinject(i4.SessionStorageService)); };
+EventStartGuard.ɵprov = i0.ɵɵdefineInjectable({ token: EventStartGuard, factory: EventStartGuard.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EventStartGuard, [{
+        type: Injectable
+    }], function () { return [{ type: i1.WorkAllocationService }, { type: i2.Router }, { type: i3.AbstractAppConfig }, { type: i4.SessionStorageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-start.guard.js","sourceRoot":"","sources":["../../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/event-start/event-guard/event-start.guard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAuC,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EAAc,EAAE,EAAE,MAAM,MAAM,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAC;AAC1F,OAAO,EAAE,qBAAqB,EAAE,MAAM,oDAAoD,CAAC;;;;;;AAG3F,MAAM,OAAO,eAAe;IAE1B,YAA6B,qBAA4C,EACtD,MAAc,EACd,SAA4B,EAC5B,qBAA4C;QAHlC,0BAAqB,GAArB,qBAAqB,CAAuB;QACtD,WAAM,GAAN,MAAM,CAAQ;QACd,cAAS,GAAT,SAAS,CAAmB;QAC5B,0BAAqB,GAArB,qBAAqB,CAAuB;IAC/D,CAAC;IAEM,WAAW,CAAC,KAA6B;QAC9C,sDAAsD;QACtD,IAAI,IAAI,CAAC,SAAS,CAAC,uBAAuB,EAAE,CAAC,WAAW,EAAE,KAAK,iBAAiB,EAAE;YAChF,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACnC,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACpC,MAAM,MAAM,GAAG,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;YAExC,4FAA4F;YAC5F,MAAM,UAAU,GAAG,KAAK,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;YACnD,MAAM,WAAW,GAAG,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YACnE,IAAI,WAAW,EAAE;gBACf,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;gBACzC,IAAI,QAAQ,IAAI,QAAQ,CAAC,GAAG,KAAK,MAAM,EAAE;oBACvC,IAAI,UAAU,EAAE;wBACd,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;qBACjB;oBAED,OAAO,IAAI,CAAC,qBAAqB,CAAC,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC,IAAI,CAC1H,SAAS,CAAC,CAAC,OAAoB,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC,CAC1F,CAAC;iBACH;aACF;SACF;aAAM;YACL,oEAAoE;YACpE,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;SACjB;IACH,CAAC;IAEM,2BAA2B,CAAC,OAAoB,EAAE,MAAc,EAAE,MAAc;QACrF,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;YAC9B,OAAO,IAAI,CAAC;SACb;QACD,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC;QACxC,IAAI,UAAU,KAAK,CAAC,EAAE;YACpB,sCAAsC;YACtC,OAAO,IAAI,CAAC;SACb;QACD,uCAAuC;QACvC,MAAM,WAAW,GAAG,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;QACtE,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QACzC,MAAM,mBAAmB,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CACnD,CAAC,CAAC,UAAU,KAAK,YAAY,IAAI,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,GAAG,CAC3F,CAAC;QAEF,IAAI,mBAAmB,CAAC,MAAM,KAAK,CAAC,EAAE;YACpC,wCAAwC;YACxC,OAAO,IAAI,CAAC;SACb;aAAM,IAAI,mBAAmB,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE;YACpD,4EAA4E;YAC5E,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,uBAAuB,MAAM,uBAAuB,CAAC,CAAC,CAAC;YAC7E,OAAO,KAAK,CAAC;SACd;aAAM;YACL,IAAI,IAAS,CAAC;YACd,IAAI,MAAM,EAAE;gBACV,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,CAAC;aACjD;iBAAM;gBACL,IAAI,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC;aAC/B;YACD,6DAA6D;YAC7D,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,gBAAgB,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;YAC3E,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IAEO,aAAa,CAAC,OAAoB,EAAE,MAAc,EAAE,OAAe,EAAE,MAAc;QACzF,oFAAoF;QACpF,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;QAExD,IAAI,OAAO,CAAC,uBAAuB,EAAE;YACnC,uFAAuF;YACvF,8CAA8C;YAC9C,oGAAoG;YACpG,+CAA+C;YAC/C,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE;gBAC7E,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;aACjB;YACD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,uBAAuB,MAAM,cAAc,CAAC,EAAE,EAAE,WAAW,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC;YAClH,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;SAClB;aAAM;YACL,OAAO,EAAE,CAAC,IAAI,CAAC,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;SACtE;IACH,CAAC;;8EAzFU,eAAe;uDAAf,eAAe,WAAf,eAAe;uFAAf,eAAe;cAD3B,UAAU","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ActivatedRouteSnapshot, CanActivate, Router } from '@angular/router';\nimport { Observable, of } from 'rxjs';\nimport { switchMap } from 'rxjs/operators';\nimport { AbstractAppConfig } from '../../../../app.config';\nimport { TaskPayload } from '../../../domain/work-allocation/TaskPayload';\nimport { SessionStorageService } from '../../../services/session/session-storage.service';\nimport { WorkAllocationService } from '../../case-editor/services/work-allocation.service';\n\n@Injectable()\nexport class EventStartGuard implements CanActivate {\n\n  constructor(private readonly workAllocationService: WorkAllocationService,\n    private readonly router: Router,\n    private readonly appConfig: AbstractAppConfig,\n    private readonly sessionStorageService: SessionStorageService) {\n  }\n\n  public canActivate(route: ActivatedRouteSnapshot): Observable<boolean> {\n    // Checks must be performed only for Work Allocation 2\n    if (this.appConfig.getWorkAllocationApiUrl().toLowerCase() === 'workallocation2') {\n      const caseId = route.params['cid'];\n      const eventId = route.params['eid'];\n      const taskId = route.queryParams['tid'];\n\n      // TODO: NavigationExtras should be used once Angular upgrade changes have been incorporated\n      const isComplete = route.queryParams['isComplete'];\n      const caseInfoStr = this.sessionStorageService.getItem('caseInfo');\n      if (caseInfoStr) {\n        const caseInfo = JSON.parse(caseInfoStr);\n        if (caseInfo && caseInfo.cid === caseId) {\n          if (isComplete) {\n            return of(true);\n          }\n\n          return this.workAllocationService.getTasksByCaseIdAndEventId(eventId, caseId, caseInfo.caseType, caseInfo.jurisdiction).pipe(\n            switchMap((payload: TaskPayload) => this.checkForTasks(payload, caseId, eventId, taskId))\n          );\n        }\n      }\n    } else {\n      // Checks not required, return true by default for Work Allocation 1\n      return of(true);\n    }\n  }\n\n  public checkTaskInEventNotRequired(payload: TaskPayload, caseId: string, taskId: string): boolean {\n    if (!payload || !payload.tasks) {\n      return true;\n    }\n    const taskNumber = payload.tasks.length;\n    if (taskNumber === 0) {\n      // if there are no tasks just carry on\n      return true;\n    }\n    // Get number of tasks assigned to user\n    const userInfoStr = this.sessionStorageService.getItem('userDetails');\n    const userInfo = JSON.parse(userInfoStr);\n    const tasksAssignedToUser = payload.tasks.filter(x =>\n      x.task_state !== 'unassigned' && x.assignee === userInfo.id || x.assignee === userInfo.uid\n    );\n\n    if (tasksAssignedToUser.length === 0) {\n      // if no tasks assigned to user carry on\n      return true;\n    } else if (tasksAssignedToUser.length > 1 && !taskId) {\n      // if more than one task assigned to the user then give multiple tasks error\n      this.router.navigate([`/cases/case-details/${caseId}/multiple-tasks-exist`]);\n      return false;\n    } else {\n      let task: any;\n      if (taskId) {\n        task = payload.tasks.find(x => x.id === taskId);\n      } else {\n        task = tasksAssignedToUser[0];\n      }\n      // if one task assigned to user, allow user to complete event\n      this.sessionStorageService.setItem('taskToComplete', JSON.stringify(task));\n      return true;\n    }\n  }\n\n  private checkForTasks(payload: TaskPayload, caseId: string, eventId: string, taskId: string): Observable<boolean> {\n    // Clear taskToComplete from session as we will be starting the process for new task\n    this.sessionStorageService.removeItem('taskToComplete');\n\n    if (payload.task_required_for_event) {\n      // There are some issues in EventTriggerResolver/CaseService and/or CCD for some events\n      // which triggers the CanActivate guard again.\n      // If event start is initiated again, then we do not need to perform state machine processing again.\n      // https://tools.hmcts.net/jira/browse/EUI-5489\n      if (this.router && this.router.url && this.router.url.includes('event-start')) {\n        return of(true);\n      }\n      this.router.navigate([`/cases/case-details/${caseId}/event-start`], { queryParams: { caseId, eventId, taskId } });\n      return of(false);\n    } else {\n      return of(this.checkTaskInEventNotRequired(payload, caseId, taskId));\n    }\n  }\n}\n"]}

package/esm2015/lib/shared/components/event-start/event-start.component.js

@@ -0,0 +1,52 @@
+import { Component } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { SessionStorageService } from '../../services/session/session-storage.service';
+import { EventStartStateMachineService } from './services/event-start-state-machine.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./services/event-start-state-machine.service";
+import * as i2 from "@angular/router";
+import * as i3 from "../../services/session/session-storage.service";
+export class EventStartComponent {
+    constructor(service, router, route, sessionStorageService) {
+        this.service = service;
+        this.router = router;
+        this.route = route;
+        this.sessionStorageService = sessionStorageService;
+    }
+    ngOnInit() {
+        // Get task and case id payload from route data
+        const tasks = this.route.snapshot.data.tasks;
+        const caseId = this.route.snapshot.data.case.case_id;
+        const eventId = this.route.snapshot.queryParams['eventId'];
+        const taskId = this.route.snapshot.queryParams['taskId'];
+        // Setup the context
+        this.context = {
+            tasks,
+            caseId,
+            eventId,
+            taskId,
+            router: this.router,
+            route: this.route,
+            sessionStorageService: this.sessionStorageService
+        };
+        // Initialise state machine
+        this.service = new EventStartStateMachineService();
+        this.stateMachine = this.service.initialiseStateMachine(this.context);
+        // Create states
+        this.service.createStates(this.stateMachine);
+        // Add transitions for the states
+        this.service.addTransitions();
+        // Start state machine
+        this.service.startStateMachine(this.stateMachine);
+    }
+}
+EventStartComponent.ɵfac = function EventStartComponent_Factory(t) { return new (t || EventStartComponent)(i0.ɵɵdirectiveInject(i1.EventStartStateMachineService), i0.ɵɵdirectiveInject(i2.Router), i0.ɵɵdirectiveInject(i2.ActivatedRoute), i0.ɵɵdirectiveInject(i3.SessionStorageService)); };
+EventStartComponent.ɵcmp = i0.ɵɵdefineComponent({ type: EventStartComponent, selectors: [["ccd-event-start"]], decls: 0, vars: 0, template: function EventStartComponent_Template(rf, ctx) { }, encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EventStartComponent, [{
+        type: Component,
+        args: [{
+                selector: 'ccd-event-start',
+                templateUrl: './event-start.component.html'
+            }]
+    }], function () { return [{ type: i1.EventStartStateMachineService }, { type: i2.Router }, { type: i2.ActivatedRoute }, { type: i3.SessionStorageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/shared/components/event-start/event-start.module.js

@@ -0,0 +1,69 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { RouterModule } from '@angular/router';
+import { MultipleTasksExistComponent } from './components/multiple-tasks-exist/multiple-tasks-exist.component';
+import { NoTasksAvailableComponent } from './components/no-tasks-available/no-tasks-available.component';
+import { TaskAssignedComponent } from './components/task-assigned/task-assigned.component';
+import { TaskCancelledComponent } from './components/task-cancelled/task-cancelled.component';
+import { TaskConflictComponent } from './components/task-conflict/task-conflict.component';
+import { TaskUnassignedComponent } from './components/task-unassigned/task-unassigned.component';
+import { EventStartGuard } from './event-guard/event-start.guard';
+import { EventStartComponent } from './event-start.component';
+import { EventTasksResolverService } from './resolvers/event-tasks-resolver.service';
+import { EventStartStateMachineService } from './services';
+import * as i0 from "@angular/core";
+export class EventStartModule {
+}
+EventStartModule.ɵfac = function EventStartModule_Factory(t) { return new (t || EventStartModule)(); };
+EventStartModule.ɵmod = i0.ɵɵdefineNgModule({ type: EventStartModule });
+EventStartModule.ɵinj = i0.ɵɵdefineInjector({ providers: [
+        EventStartGuard,
+        EventTasksResolverService,
+        EventStartStateMachineService
+    ], imports: [[
+            CommonModule,
+            ReactiveFormsModule,
+            RouterModule
+        ]] });
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(EventStartModule, { declarations: [EventStartComponent,
+        MultipleTasksExistComponent,
+        NoTasksAvailableComponent,
+        TaskAssignedComponent,
+        TaskCancelledComponent,
+        TaskConflictComponent,
+        TaskUnassignedComponent], imports: [CommonModule,
+        ReactiveFormsModule,
+        RouterModule], exports: [EventStartComponent,
+        TaskAssignedComponent,
+        TaskUnassignedComponent] }); })();
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EventStartModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    ReactiveFormsModule,
+                    RouterModule
+                ],
+                declarations: [
+                    EventStartComponent,
+                    MultipleTasksExistComponent,
+                    NoTasksAvailableComponent,
+                    TaskAssignedComponent,
+                    TaskCancelledComponent,
+                    TaskConflictComponent,
+                    TaskUnassignedComponent
+                ],
+                providers: [
+                    EventStartGuard,
+                    EventTasksResolverService,
+                    EventStartStateMachineService
+                ],
+                exports: [
+                    EventStartComponent,
+                    TaskAssignedComponent,
+                    TaskUnassignedComponent
+                ]
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/shared/components/event-start/index.js

@@ -0,0 +1,10 @@
+export * from './components/multiple-tasks-exist/multiple-tasks-exist.component';
+export * from './components/no-tasks-available/no-tasks-available.component';
+export * from './components/task-assigned/task-assigned.component';
+export * from './components/task-cancelled/task-cancelled.component';
+export * from './components/task-conflict/task-conflict.component';
+export * from './components/task-unassigned/task-unassigned.component';
+export * from './event-start.component';
+export * from './event-start.module';
+export * from './services';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL2NvbXBvbmVudHMvZXZlbnQtc3RhcnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrRUFBa0UsQ0FBQztBQUNqRixjQUFjLDhEQUE4RCxDQUFDO0FBQzdFLGNBQWMsb0RBQW9ELENBQUM7QUFDbkUsY0FBYyxzREFBc0QsQ0FBQztBQUNyRSxjQUFjLG9EQUFvRCxDQUFDO0FBQ25FLGNBQWMsd0RBQXdELENBQUM7QUFDdkUsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL211bHRpcGxlLXRhc2tzLWV4aXN0L211bHRpcGxlLXRhc2tzLWV4aXN0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvbm8tdGFza3MtYXZhaWxhYmxlL25vLXRhc2tzLWF2YWlsYWJsZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL3Rhc2stYXNzaWduZWQvdGFzay1hc3NpZ25lZC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL3Rhc2stY2FuY2VsbGVkL3Rhc2stY2FuY2VsbGVkLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvdGFzay1jb25mbGljdC90YXNrLWNvbmZsaWN0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvdGFzay11bmFzc2lnbmVkL3Rhc2stdW5hc3NpZ25lZC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9ldmVudC1zdGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9ldmVudC1zdGFydC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcyc7XG4iXX0=

package/esm2015/lib/shared/components/event-start/models/event-start-state-machine-context.model.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtc3RhcnQtc3RhdGUtbWFjaGluZS1jb250ZXh0Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NkLWNhc2UtdWktdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9jb21wb25lbnRzL2V2ZW50LXN0YXJ0L21vZGVscy9ldmVudC1zdGFydC1zdGF0ZS1tYWNoaW5lLWNvbnRleHQubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFjdGl2YXRlZFJvdXRlLCBSb3V0ZXIgfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuaW1wb3J0IHsgVGFzayB9IGZyb20gJy4uLy4uLy4uL2RvbWFpbi93b3JrLWFsbG9jYXRpb24vVGFzayc7XG5pbXBvcnQgeyBTZXNzaW9uU3RvcmFnZVNlcnZpY2UgfSBmcm9tICcuLi8uLi8uLi9zZXJ2aWNlcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgRXZlbnRTdGFydFN0YXRlTWFjaGluZUNvbnRleHQge1xuICB0YXNrczogVGFza1tdO1xuICBjYXNlSWQ6IHN0cmluZztcbiAgZXZlbnRJZDogc3RyaW5nO1xuICB0YXNrSWQ6IHN0cmluZztcbiAgcm91dGVyOiBSb3V0ZXI7XG4gIHJvdXRlOiBBY3RpdmF0ZWRSb3V0ZTtcbiAgc2Vzc2lvblN0b3JhZ2VTZXJ2aWNlOiBTZXNzaW9uU3RvcmFnZVNlcnZpY2U7XG59XG4iXX0=

package/esm2015/lib/shared/components/event-start/models/event-start-states-enum.model.js

@@ -0,0 +1,16 @@
+export var EventStartStates;
+(function (EventStartStates) {
+    EventStartStates["CHECK_FOR_MATCHING_TASKS"] = "check-for-matching-tasks";
+    EventStartStates["NO_TASK"] = "no-task";
+    EventStartStates["ONE_OR_MORE_TASKS"] = "one-or-more-tasks";
+    EventStartStates["TASK_ASSIGNED_TO_USER"] = "task-assigned-to-user";
+    EventStartStates["ONE_TASK_ASSIGNED_TO_USER"] = "one-task-assigned-to-user";
+    EventStartStates["MULTIPLE_TASKS_ASSIGNED_TO_USER"] = "multiple-tasks-assigned-to-user";
+    EventStartStates["TASK_UNASSIGNED"] = "task-unassigned";
+    EventStartStates["TASK_ASSIGNMENT_REQUIRED"] = "task-assignment-required";
+    EventStartStates["ASSIGN_TASK_TO_SELF"] = "assign-task-to-self";
+    EventStartStates["ASK_MANAGER_TO_ASSIGN_TASK"] = "ask-manager-to-assign-task";
+    EventStartStates["SHOW_WARNING"] = "show-warning";
+    EventStartStates["FINAL"] = "final";
+})(EventStartStates || (EventStartStates = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtc3RhcnQtc3RhdGVzLWVudW0ubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL2NvbXBvbmVudHMvZXZlbnQtc3RhcnQvbW9kZWxzL2V2ZW50LXN0YXJ0LXN0YXRlcy1lbnVtLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLGdCQWFYO0FBYkQsV0FBWSxnQkFBZ0I7SUFDMUIseUVBQXFELENBQUE7SUFDckQsdUNBQW1CLENBQUE7SUFDbkIsMkRBQXVDLENBQUE7SUFDdkMsbUVBQStDLENBQUE7SUFDL0MsMkVBQXVELENBQUE7SUFDdkQsdUZBQW1FLENBQUE7SUFDbkUsdURBQW1DLENBQUE7SUFDbkMseUVBQXFELENBQUE7SUFDckQsK0RBQTJDLENBQUE7SUFDM0MsNkVBQXlELENBQUE7SUFDekQsaURBQTZCLENBQUE7SUFDN0IsbUNBQWUsQ0FBQTtBQUNqQixDQUFDLEVBYlcsZ0JBQWdCLEtBQWhCLGdCQUFnQixRQWEzQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIEV2ZW50U3RhcnRTdGF0ZXMge1xuICBDSEVDS19GT1JfTUFUQ0hJTkdfVEFTS1MgPSAnY2hlY2stZm9yLW1hdGNoaW5nLXRhc2tzJyxcbiAgTk9fVEFTSyA9ICduby10YXNrJyxcbiAgT05FX09SX01PUkVfVEFTS1MgPSAnb25lLW9yLW1vcmUtdGFza3MnLFxuICBUQVNLX0FTU0lHTkVEX1RPX1VTRVIgPSAndGFzay1hc3NpZ25lZC10by11c2VyJyxcbiAgT05FX1RBU0tfQVNTSUdORURfVE9fVVNFUiA9ICdvbmUtdGFzay1hc3NpZ25lZC10by11c2VyJyxcbiAgTVVMVElQTEVfVEFTS1NfQVNTSUdORURfVE9fVVNFUiA9ICdtdWx0aXBsZS10YXNrcy1hc3NpZ25lZC10by11c2VyJyxcbiAgVEFTS19VTkFTU0lHTkVEID0gJ3Rhc2stdW5hc3NpZ25lZCcsXG4gIFRBU0tfQVNTSUdOTUVOVF9SRVFVSVJFRCA9ICd0YXNrLWFzc2lnbm1lbnQtcmVxdWlyZWQnLFxuICBBU1NJR05fVEFTS19UT19TRUxGID0gJ2Fzc2lnbi10YXNrLXRvLXNlbGYnLFxuICBBU0tfTUFOQUdFUl9UT19BU1NJR05fVEFTSyA9ICdhc2stbWFuYWdlci10by1hc3NpZ24tdGFzaycsXG4gIFNIT1dfV0FSTklORyA9ICdzaG93LXdhcm5pbmcnLFxuICBGSU5BTCA9ICdmaW5hbCdcbn1cbiJdfQ==

package/esm2015/lib/shared/components/event-start/models/index.js

@@ -0,0 +1,3 @@
+export * from './event-start-state-machine-context.model';
+export * from './event-start-states-enum.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL2NvbXBvbmVudHMvZXZlbnQtc3RhcnQvbW9kZWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMkNBQTJDLENBQUM7QUFDMUQsY0FBYyxpQ0FBaUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZXZlbnQtc3RhcnQtc3RhdGUtbWFjaGluZS1jb250ZXh0Lm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vZXZlbnQtc3RhcnQtc3RhdGVzLWVudW0ubW9kZWwnO1xuIl19

package/esm2015/lib/shared/components/event-start/resolvers/event-tasks-resolver.service.js

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { SessionStorageService } from '../../../services/session/session-storage.service';
+import { WorkAllocationService } from '../../case-editor/services/work-allocation.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../case-editor/services/work-allocation.service";
+import * as i2 from "../../../services/session/session-storage.service";
+export class EventTasksResolverService {
+    constructor(service, sessionStorageService) {
+        this.service = service;
+        this.sessionStorageService = sessionStorageService;
+    }
+    resolve(route) {
+        const eventId = route.queryParamMap.get('eventId');
+        const caseId = route.queryParamMap.get('caseId');
+        const caseInfoStr = this.sessionStorageService.getItem('caseInfo');
+        const caseInfo = JSON.parse(caseInfoStr);
+        if (caseInfo) {
+            return this.service.getTasksByCaseIdAndEventId(eventId, caseId, caseInfo.caseType, caseInfo.jurisdiction)
+                .pipe(map((payload) => payload.tasks));
+        }
+    }
+}
+EventTasksResolverService.ɵfac = function EventTasksResolverService_Factory(t) { return new (t || EventTasksResolverService)(i0.ɵɵinject(i1.WorkAllocationService), i0.ɵɵinject(i2.SessionStorageService)); };
+EventTasksResolverService.ɵprov = i0.ɵɵdefineInjectable({ token: EventTasksResolverService, factory: EventTasksResolverService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EventTasksResolverService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.WorkAllocationService }, { type: i2.SessionStorageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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