@hmcts/ccd-case-ui-toolkit 7.0.39-angular-upgrade-rc → 7.0.39-case-consolidated-link

package/esm2020/lib/shared/components/case-editor/services/cases.service.mjs

@@ -0,0 +1,292 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { plainToClass } from 'class-transformer';
+import { throwError } from 'rxjs';
+import { catchError, finalize, map, tap } from 'rxjs/operators';
+import { AbstractAppConfig } from '../../../../app.config';
+import { ShowCondition } from '../../../directives';
+import { CaseEventTrigger, Draft } from '../../../domain';
+import { FieldsUtils, HttpErrorService, HttpService, LoadingService, OrderService, RetryUtil, SessionStorageService } from '../../../services';
+import { CaseAccessUtils } from '../case-access-utils';
+import { WizardPageFieldToCaseFieldMapper } from './wizard-page-field-to-case-field.mapper';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services";
+import * as i2 from "../../../../app.config";
+import * as i3 from "./wizard-page-field-to-case-field.mapper";
+export class CasesService {
+    constructor(http, appConfig, orderService, errorService, wizardPageFieldToCaseFieldMapper, loadingService, sessionStorageService, retryUtil) {
+        this.http = http;
+        this.appConfig = appConfig;
+        this.orderService = orderService;
+        this.errorService = errorService;
+        this.wizardPageFieldToCaseFieldMapper = wizardPageFieldToCaseFieldMapper;
+        this.loadingService = loadingService;
+        this.sessionStorageService = sessionStorageService;
+        this.retryUtil = retryUtil;
+        this.get = this.getCaseView;
+    }
+    static updateChallengedAccessRequestAttributes(httpClient, caseId, attributesToUpdate) {
+        return httpClient.post(`/api/challenged-access-request/update-attributes`, {
+            caseId,
+            attributesToUpdate
+        });
+    }
+    static updateSpecificAccessRequestAttributes(httpClient, caseId, attributesToUpdate) {
+        return httpClient.post(`/api/specific-access-request/update-attributes`, {
+            caseId,
+            attributesToUpdate
+        });
+    }
+    getCaseView(jurisdictionId, caseTypeId, caseId) {
+        const url = `${this.appConfig.getApiUrl()}/caseworkers/:uid/jurisdictions/${jurisdictionId}/case-types/${caseTypeId}/cases/${caseId}`;
+        const loadingToken = this.loadingService.register();
+        return this.http
+            .get(url)
+            .pipe(catchError(error => {
+            this.errorService.setError(error);
+            return throwError(error);
+        }), finalize(() => this.loadingService.unregister(loadingToken)));
+    }
+    getCaseViewV2(caseId) {
+        const url = `${this.appConfig.getCaseDataUrl()}/internal/cases/${caseId}`;
+        const headers = new HttpHeaders()
+            .set('experimental', 'true')
+            .set('Accept', CasesService.V2_MEDIATYPE_CASE_VIEW)
+            .set('Content-Type', 'application/json');
+        const loadingToken = this.loadingService.register();
+        let http$ = this.http.get(url, { headers, observe: 'body' });
+        const artificialDelay = this.appConfig.getTimeoutsCaseRetrievalArtificialDelay();
+        const timeoutPeriods = this.appConfig.getTimeoutsForCaseRetrieval();
+        console.log(`Timeout periods: ${timeoutPeriods} seconds.`);
+        if (timeoutPeriods && timeoutPeriods.length > 0 && timeoutPeriods[0] > 0) {
+            http$ = this.retryUtil.pipeTimeoutMechanismOn(http$, artificialDelay, timeoutPeriods);
+        }
+        else {
+            console.warn('Skipping to pipe a retry mechanism!');
+        }
+        http$ = this.pipeErrorProcessor(http$);
+        http$ = http$.pipe(finalize(() => this.finalizeGetCaseViewWith(caseId, loadingToken)));
+        return http$;
+    }
+    pipeErrorProcessor(in$) {
+        const out$ = in$.pipe(catchError(error => {
+            console.error(`Error while getting case view with getCaseViewV2! Error type: '${typeof error}, Error name: '${error?.name}'`);
+            console.error(error);
+            this.errorService.setError(error);
+            return throwError(error);
+        }));
+        return out$;
+    }
+    finalizeGetCaseViewWith(caseId, loadingToken) {
+        this.loadingService.unregister(loadingToken);
+    }
+    syncWait(seconds) {
+        const end = Date.now() + seconds * 1000;
+        while (Date.now() < end)
+            continue;
+    }
+    getEventTrigger(caseTypeId, eventTriggerId, caseId, ignoreWarning) {
+        ignoreWarning = undefined !== ignoreWarning ? ignoreWarning : 'false';
+        const url = this.buildEventTriggerUrl(caseTypeId, eventTriggerId, caseId, ignoreWarning);
+        let headers = new HttpHeaders();
+        headers = headers.set('experimental', 'true');
+        headers = headers.set('Content-Type', 'application/json');
+        if (Draft.isDraft(caseId)) {
+            headers = headers.set('Accept', CasesService.V2_MEDIATYPE_START_DRAFT_TRIGGER);
+        }
+        else if (caseId !== undefined && caseId !== null) {
+            headers = headers.set('Accept', CasesService.V2_MEDIATYPE_START_EVENT_TRIGGER);
+        }
+        else {
+            headers = headers.set('Accept', CasesService.V2_MEDIATYPE_START_CASE_TRIGGER);
+        }
+        return this.http
+            .get(url, { headers, observe: 'body' })
+            .pipe(map(body => {
+            return FieldsUtils.handleNestedDynamicLists(body);
+        }), catchError(error => {
+            this.errorService.setError(error);
+            return throwError(error);
+        }), map((p) => plainToClass(CaseEventTrigger, p)), tap(eventTrigger => this.initialiseEventTrigger(eventTrigger)));
+    }
+    createEvent(caseDetails, eventData) {
+        const caseId = caseDetails.case_id;
+        const url = `${this.appConfig.getCaseDataUrl()}/cases/${caseId}/events`;
+        const headers = new HttpHeaders()
+            .set('experimental', 'true')
+            .set('Accept', CasesService.V2_MEDIATYPE_CREATE_EVENT)
+            .set('Content-Type', 'application/json');
+        return this.http
+            .post(url, eventData, { headers, observe: 'body' })
+            .pipe(catchError(error => {
+            this.errorService.setError(error);
+            return throwError(error);
+        }));
+    }
+    validateCase(ctid, eventData, pageId) {
+        const pageIdString = pageId ? `?pageId=${pageId}` : '';
+        const url = `${this.appConfig.getCaseDataUrl()}/case-types/${ctid}/validate${pageIdString}`;
+        const headers = new HttpHeaders()
+            .set('experimental', 'true')
+            .set('Accept', CasesService.V2_MEDIATYPE_CASE_DATA_VALIDATE)
+            .set('Content-Type', 'application/json');
+        return this.http
+            .post(url, eventData, { headers, observe: 'body' })
+            .pipe(catchError(error => {
+            this.errorService.setError(error);
+            return throwError(error);
+        }));
+    }
+    createCase(ctid, eventData) {
+        let ignoreWarning = 'false';
+        if (eventData.ignore_warning) {
+            ignoreWarning = 'true';
+        }
+        const url = `${this.appConfig.getCaseDataUrl()}/case-types/${ctid}/cases?ignore-warning=${ignoreWarning}`;
+        const headers = new HttpHeaders()
+            .set('experimental', 'true')
+            .set('Accept', CasesService.V2_MEDIATYPE_CREATE_CASE)
+            .set('Content-Type', 'application/json');
+        return this.http
+            .post(url, eventData, { headers, observe: 'body' })
+            .pipe(catchError(error => {
+            this.errorService.setError(error);
+            return throwError(error);
+        }));
+    }
+    getPrintDocuments(caseId) {
+        const url = `${this.appConfig.getCaseDataUrl()}/cases/${caseId}/documents`;
+        const headers = new HttpHeaders()
+            .set('experimental', 'true')
+            .set('Accept', CasesService.V2_MEDIATYPE_CASE_DOCUMENTS)
+            .set('Content-Type', 'application/json');
+        return this.http
+            .get(url, { headers, observe: 'body' })
+            .pipe(map(body => body.documentResources), catchError(error => {
+            this.errorService.setError(error);
+            return throwError(error);
+        }));
+    }
+    buildEventTriggerUrl(caseTypeId, eventTriggerId, caseId, ignoreWarning) {
+        let url = `${this.appConfig.getCaseDataUrl()}/internal`;
+        if (Draft.isDraft(caseId)) {
+            url += `/drafts/${caseId}`
+                + `/event-trigger`
+                + `?ignore-warning=${ignoreWarning}`;
+        }
+        else if (caseTypeId === undefined || caseTypeId === null) {
+            url += `/cases/${caseId}`
+                + `/event-triggers/${eventTriggerId}`
+                + `?ignore-warning=${ignoreWarning}`;
+        }
+        else {
+            url += `/case-types/${caseTypeId}`
+                + `/event-triggers/${eventTriggerId}`
+                + `?ignore-warning=${ignoreWarning}`;
+        }
+        return url;
+    }
+    initialiseEventTrigger(eventTrigger) {
+        if (!eventTrigger.wizard_pages) {
+            eventTrigger.wizard_pages = [];
+        }
+        eventTrigger.wizard_pages.forEach((wizardPage) => {
+            wizardPage.parsedShowCondition = ShowCondition.getInstance(wizardPage.show_condition);
+            wizardPage.case_fields = this.orderService.sort(this.wizardPageFieldToCaseFieldMapper.mapAll(wizardPage.wizard_page_fields, eventTrigger.case_fields));
+        });
+    }
+    /*
+    Checks if the user has role of pui-case-manager and returns true or false
+    */
+    isPuiCaseManager() {
+        const userInfoStr = this.sessionStorageService.getItem('userDetails');
+        if (userInfoStr) {
+            const userInfo = JSON.parse(userInfoStr);
+            return userInfo && userInfo.roles && (userInfo.roles.indexOf(CasesService.PUI_CASE_MANAGER) !== -1);
+        }
+        return false;
+    }
+    getCourtOrHearingCentreName(locationId) {
+        return this.http.post(`/api/locations/getLocationsById`, { locations: [{ locationId }] });
+    }
+    createChallengedAccessRequest(caseId, request) {
+        // Assignment API endpoint
+        const userInfoStr = this.sessionStorageService.getItem('userDetails');
+        const camUtils = new CaseAccessUtils();
+        let userInfo;
+        if (userInfoStr) {
+            userInfo = JSON.parse(userInfoStr);
+        }
+        const roleCategory = userInfo.roleCategory || camUtils.getMappedRoleCategory(userInfo.roles, userInfo.roleCategories);
+        const roleName = camUtils.getAMRoleName('challenged', roleCategory);
+        const beginTime = new Date();
+        const endTime = new Date(new Date().setUTCHours(23, 59, 59, 999));
+        const id = userInfo.id ? userInfo.id : userInfo.uid;
+        const isNew = true;
+        const payload = camUtils.getAMPayload(id, id, roleName, roleCategory, 'CHALLENGED', caseId, request, beginTime, endTime, isNew);
+        return this.http.post(`/api/challenged-access-request`, payload);
+    }
+    createSpecificAccessRequest(caseId, sar) {
+        // Assignment API endpoint
+        const userInfoStr = this.sessionStorageService.getItem('userDetails');
+        const camUtils = new CaseAccessUtils();
+        let userInfo;
+        if (userInfoStr) {
+            userInfo = JSON.parse(userInfoStr);
+        }
+        const roleCategory = userInfo.roleCategory || camUtils.getMappedRoleCategory(userInfo.roles, userInfo.roleCategories);
+        const roleName = camUtils.getAMRoleName('specific', roleCategory);
+        const id = userInfo.id ? userInfo.id : userInfo.uid;
+        const payload = camUtils.getAMPayload(null, id, roleName, roleCategory, 'SPECIFIC', caseId, sar, null, null, true);
+        payload.roleRequest = {
+            ...payload.roleRequest,
+            process: 'specific-access',
+            replaceExisting: true,
+            assignerId: payload.requestedRoles[0].actorId,
+            reference: `${caseId}/${roleName}/${payload.requestedRoles[0].actorId}`
+        };
+        payload.requestedRoles[0] = {
+            ...payload.requestedRoles[0],
+            roleName: 'specific-access-requested',
+            roleCategory,
+            classification: 'PRIVATE',
+            endTime: new Date(new Date().setDate(new Date().getDate() + 30)),
+            beginTime: null,
+            grantType: 'BASIC',
+            readOnly: true
+        };
+        payload.requestedRoles[0].attributes = {
+            ...payload.requestedRoles[0].attributes,
+            requestedRole: roleName,
+            specificAccessReason: sar.specificReason
+        };
+        payload.requestedRoles[0].notes[0] = {
+            ...payload.requestedRoles[0].notes[0],
+            userId: payload.requestedRoles[0].actorId
+        };
+        return this.http.post(`/api/specific-access-request`, payload);
+    }
+    getLinkedCases(caseId) {
+        const url = `${this.appConfig.getCaseDataStoreApiUrl()}/${caseId}`;
+        return this.http
+            .get(url)
+            .pipe(catchError(error => throwError(error)));
+    }
+}
+// Internal (UI) API
+CasesService.V2_MEDIATYPE_CASE_VIEW = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-case-view.v2+json';
+CasesService.V2_MEDIATYPE_START_CASE_TRIGGER = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-start-case-trigger.v2+json;charset=UTF-8';
+CasesService.V2_MEDIATYPE_START_EVENT_TRIGGER = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-start-event-trigger.v2+json;charset=UTF-8';
+CasesService.V2_MEDIATYPE_START_DRAFT_TRIGGER = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-start-draft-trigger.v2+json;charset=UTF-8';
+// External (Data Store) API
+CasesService.V2_MEDIATYPE_CASE_DOCUMENTS = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.case-documents.v2+json;charset=UTF-8';
+CasesService.V2_MEDIATYPE_CASE_DATA_VALIDATE = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.case-data-validate.v2+json;charset=UTF-8';
+CasesService.V2_MEDIATYPE_CREATE_EVENT = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.create-event.v2+json;charset=UTF-8';
+CasesService.V2_MEDIATYPE_CREATE_CASE = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.create-case.v2+json;charset=UTF-8';
+CasesService.PUI_CASE_MANAGER = 'pui-case-manager';
+CasesService.ɵfac = function CasesService_Factory(t) { return new (t || CasesService)(i0.ɵɵinject(i1.HttpService), i0.ɵɵinject(i2.AbstractAppConfig), i0.ɵɵinject(i1.OrderService), i0.ɵɵinject(i1.HttpErrorService), i0.ɵɵinject(i3.WizardPageFieldToCaseFieldMapper), i0.ɵɵinject(i1.LoadingService), i0.ɵɵinject(i1.SessionStorageService), i0.ɵɵinject(i1.RetryUtil)); };
+CasesService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CasesService, factory: CasesService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CasesService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpService }, { type: i2.AbstractAppConfig }, { type: i1.OrderService }, { type: i1.HttpErrorService }, { type: i3.WizardPageFieldToCaseFieldMapper }, { type: i1.LoadingService }, { type: i1.SessionStorageService }, { type: i1.RetryUtil }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cases.service.js","sourceRoot":"","sources":["../../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/case-editor/services/cases.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpHeaders } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { plainToClass } from 'class-transformer';\nimport { Observable, throwError } from 'rxjs';\nimport { catchError, finalize, map, tap } from 'rxjs/operators';\nimport { AbstractAppConfig } from '../../../../app.config';\nimport { ShowCondition } from '../../../directives';\nimport {\n  CaseEventData,\n  CaseEventTrigger,\n  CasePrintDocument,\n  CaseView,\n  ChallengedAccessRequest, Draft,\n  RoleAssignmentResponse,\n  RoleCategory,\n  RoleRequestPayload, SpecificAccessRequest\n} from '../../../domain';\nimport { UserInfo } from '../../../domain/user/user-info.model';\nimport { FieldsUtils, HttpErrorService, HttpService, LoadingService, OrderService, RetryUtil, SessionStorageService } from '../../../services';\nimport { LinkedCasesResponse } from '../../palette/linked-cases/domain/linked-cases.model';\nimport { CaseAccessUtils } from '../case-access-utils';\nimport { WizardPage } from '../domain';\nimport { WizardPageFieldToCaseFieldMapper } from './wizard-page-field-to-case-field.mapper';\n\n@Injectable()\nexport class CasesService {\n  // Internal (UI) API\n  public static readonly V2_MEDIATYPE_CASE_VIEW = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-case-view.v2+json';\n  public static readonly V2_MEDIATYPE_START_CASE_TRIGGER =\n    'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-start-case-trigger.v2+json;charset=UTF-8';\n  public static readonly V2_MEDIATYPE_START_EVENT_TRIGGER =\n    'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-start-event-trigger.v2+json;charset=UTF-8';\n  public static readonly V2_MEDIATYPE_START_DRAFT_TRIGGER =\n    'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-start-draft-trigger.v2+json;charset=UTF-8';\n\n  // External (Data Store) API\n\n  public static readonly V2_MEDIATYPE_CASE_DOCUMENTS =\n    'application/vnd.uk.gov.hmcts.ccd-data-store-api.case-documents.v2+json;charset=UTF-8';\n\n  public static readonly V2_MEDIATYPE_CASE_DATA_VALIDATE =\n    'application/vnd.uk.gov.hmcts.ccd-data-store-api.case-data-validate.v2+json;charset=UTF-8';\n  public static readonly V2_MEDIATYPE_CREATE_EVENT =\n    'application/vnd.uk.gov.hmcts.ccd-data-store-api.create-event.v2+json;charset=UTF-8';\n  public static readonly V2_MEDIATYPE_CREATE_CASE =\n    'application/vnd.uk.gov.hmcts.ccd-data-store-api.create-case.v2+json;charset=UTF-8';\n\n  public static readonly PUI_CASE_MANAGER = 'pui-case-manager';\n\n  public get = this.getCaseView;\n\n  public static updateChallengedAccessRequestAttributes(httpClient: HttpClient, caseId: string, attributesToUpdate: { [x: string]: any })\n    : Observable<RoleAssignmentResponse> {\n    return httpClient.post<RoleAssignmentResponse>(`/api/challenged-access-request/update-attributes`, {\n      caseId,\n      attributesToUpdate\n    });\n  }\n\n  public static updateSpecificAccessRequestAttributes(httpClient: HttpClient, caseId: string, attributesToUpdate: { [x: string]: any })\n    : Observable<RoleAssignmentResponse> {\n    return httpClient.post<RoleAssignmentResponse>(`/api/specific-access-request/update-attributes`, {\n      caseId,\n      attributesToUpdate\n    });\n  }\n\n  constructor(\n    private http: HttpService,\n    private appConfig: AbstractAppConfig,\n    private orderService: OrderService,\n    private errorService: HttpErrorService,\n    private wizardPageFieldToCaseFieldMapper: WizardPageFieldToCaseFieldMapper,\n    private loadingService: LoadingService,\n    private readonly sessionStorageService: SessionStorageService,\n    private readonly retryUtil: RetryUtil\n  ) {\n  }\n\n  public getCaseView(jurisdictionId: string,\n    caseTypeId: string,\n    caseId: string): Observable<CaseView> {\n    const url = `${this.appConfig.getApiUrl()}/caseworkers/:uid/jurisdictions/${jurisdictionId}/case-types/${caseTypeId}/cases/${caseId}`;\n\n    const loadingToken = this.loadingService.register();\n    return this.http\n      .get(url)\n      .pipe(\n        catchError(error => {\n          this.errorService.setError(error);\n          return throwError(error);\n        }),\n        finalize(() => this.loadingService.unregister(loadingToken))\n      );\n  }\n\n  public getCaseViewV2(caseId: string): Observable<CaseView> {\n    const url = `${this.appConfig.getCaseDataUrl()}/internal/cases/${caseId}`;\n    const headers = new HttpHeaders()\n      .set('experimental', 'true')\n      .set('Accept', CasesService.V2_MEDIATYPE_CASE_VIEW)\n      .set('Content-Type', 'application/json');\n\n    const loadingToken = this.loadingService.register();\n\n    let http$ = this.http.get(url, { headers, observe: 'body' });\n\n    const artificialDelay: number = this.appConfig.getTimeoutsCaseRetrievalArtificialDelay();\n    const timeoutPeriods = this.appConfig.getTimeoutsForCaseRetrieval();\n    console.log(`Timeout periods: ${timeoutPeriods} seconds.`);\n    if (timeoutPeriods && timeoutPeriods.length > 0 && timeoutPeriods[0] > 0) {\n      http$ = this.retryUtil.pipeTimeoutMechanismOn(http$, artificialDelay, timeoutPeriods);\n    } else {\n      console.warn('Skipping to pipe a retry mechanism!');\n    }\n\n    http$ = this.pipeErrorProcessor(http$);\n\n    http$ = http$.pipe(finalize(() => this.finalizeGetCaseViewWith(caseId, loadingToken)));\n\n    return http$;\n  }\n\n  private pipeErrorProcessor(in$: Observable<CaseView>): Observable<CaseView> {\n    const out$ = in$.pipe(catchError(error => {\n      console.error(`Error while getting case view with getCaseViewV2! Error type: '${typeof error}, Error name: '${error?.name}'`);\n      console.error(error);\n      this.errorService.setError(error);\n      return throwError(error);\n    }));\n    return out$;\n  }\n\n  private finalizeGetCaseViewWith(caseId: string, loadingToken: string) {\n    this.loadingService.unregister(loadingToken);\n  }\n\n  public syncWait(seconds) {\n    const end = Date.now() + seconds * 1000;\n    while (Date.now() < end) continue;\n  }\n\n  public getEventTrigger(caseTypeId: string,\n    eventTriggerId: string,\n    caseId?: string,\n    ignoreWarning?: string): Observable<CaseEventTrigger> {\n    ignoreWarning = undefined !== ignoreWarning ? ignoreWarning : 'false';\n\n    const url = this.buildEventTriggerUrl(caseTypeId, eventTriggerId, caseId, ignoreWarning);\n\n    let headers = new HttpHeaders();\n    headers = headers.set('experimental', 'true');\n    headers = headers.set('Content-Type', 'application/json');\n\n    if (Draft.isDraft(caseId)) {\n      headers = headers.set('Accept', CasesService.V2_MEDIATYPE_START_DRAFT_TRIGGER);\n    } else if (caseId !== undefined && caseId !== null) {\n      headers = headers.set('Accept', CasesService.V2_MEDIATYPE_START_EVENT_TRIGGER);\n    } else {\n      headers = headers.set('Accept', CasesService.V2_MEDIATYPE_START_CASE_TRIGGER);\n    }\n\n    return this.http\n      .get(url, { headers, observe: 'body' })\n      .pipe(\n        map(body => {\n          return FieldsUtils.handleNestedDynamicLists(body);\n        }),\n        catchError(error => {\n          this.errorService.setError(error);\n          return throwError(error);\n        }),\n        map((p) => plainToClass(CaseEventTrigger, p)),\n        tap(eventTrigger => this.initialiseEventTrigger(eventTrigger))\n      );\n  }\n\n  public createEvent(caseDetails: CaseView, eventData: CaseEventData): Observable<{}> {\n    const caseId = caseDetails.case_id;\n    const url = `${this.appConfig.getCaseDataUrl()}/cases/${caseId}/events`;\n\n    const headers = new HttpHeaders()\n      .set('experimental', 'true')\n      .set('Accept', CasesService.V2_MEDIATYPE_CREATE_EVENT)\n      .set('Content-Type', 'application/json');\n\n    return this.http\n      .post(url, eventData, { headers, observe: 'body' })\n      .pipe(\n        catchError(error => {\n          this.errorService.setError(error);\n          return throwError(error);\n        })\n      );\n  }\n\n  public validateCase(ctid: string, eventData: CaseEventData, pageId: string): Observable<object> {\n    const pageIdString = pageId ? `?pageId=${pageId}` : '';\n    const url = `${this.appConfig.getCaseDataUrl()}/case-types/${ctid}/validate${pageIdString}`;\n\n    const headers = new HttpHeaders()\n      .set('experimental', 'true')\n      .set('Accept', CasesService.V2_MEDIATYPE_CASE_DATA_VALIDATE)\n      .set('Content-Type', 'application/json');\n\n    return this.http\n      .post(url, eventData, { headers, observe: 'body' })\n      .pipe(\n        catchError(error => {\n          this.errorService.setError(error);\n          return throwError(error);\n        })\n      );\n  }\n\n  public createCase(ctid: string, eventData: CaseEventData): Observable<object> {\n    let ignoreWarning = 'false';\n\n    if (eventData.ignore_warning) {\n      ignoreWarning = 'true';\n    }\n    const url = `${this.appConfig.getCaseDataUrl()}/case-types/${ctid}/cases?ignore-warning=${ignoreWarning}`;\n\n    const headers = new HttpHeaders()\n      .set('experimental', 'true')\n      .set('Accept', CasesService.V2_MEDIATYPE_CREATE_CASE)\n      .set('Content-Type', 'application/json');\n\n    return this.http\n      .post(url, eventData, { headers, observe: 'body' })\n      .pipe(\n        catchError(error => {\n          this.errorService.setError(error);\n          return throwError(error);\n        })\n      );\n  }\n\n  public getPrintDocuments(caseId: string): Observable<CasePrintDocument[]> {\n    const url = `${this.appConfig.getCaseDataUrl()}/cases/${caseId}/documents`;\n\n    const headers = new HttpHeaders()\n      .set('experimental', 'true')\n      .set('Accept', CasesService.V2_MEDIATYPE_CASE_DOCUMENTS)\n      .set('Content-Type', 'application/json');\n\n    return this.http\n      .get(url, { headers, observe: 'body' })\n      .pipe(\n        map(body => body.documentResources),\n        catchError(error => {\n          this.errorService.setError(error);\n          return throwError(error);\n        })\n      );\n  }\n\n  private buildEventTriggerUrl(caseTypeId: string,\n    eventTriggerId: string,\n    caseId?: string,\n    ignoreWarning?: string): string {\n    let url = `${this.appConfig.getCaseDataUrl()}/internal`;\n\n    if (Draft.isDraft(caseId)) {\n      url += `/drafts/${caseId}`\n        + `/event-trigger`\n        + `?ignore-warning=${ignoreWarning}`;\n    } else if (caseTypeId === undefined || caseTypeId === null) {\n      url += `/cases/${caseId}`\n        + `/event-triggers/${eventTriggerId}`\n        + `?ignore-warning=${ignoreWarning}`;\n    } else {\n      url += `/case-types/${caseTypeId}`\n        + `/event-triggers/${eventTriggerId}`\n        + `?ignore-warning=${ignoreWarning}`;\n    }\n\n    return url;\n  }\n\n  private initialiseEventTrigger(eventTrigger: CaseEventTrigger) {\n    if (!eventTrigger.wizard_pages) {\n      eventTrigger.wizard_pages = [];\n    }\n\n    eventTrigger.wizard_pages.forEach((wizardPage: WizardPage) => {\n      wizardPage.parsedShowCondition = ShowCondition.getInstance(wizardPage.show_condition);\n      wizardPage.case_fields = this.orderService.sort(\n        this.wizardPageFieldToCaseFieldMapper.mapAll(wizardPage.wizard_page_fields, eventTrigger.case_fields));\n    });\n  }\n\n  /*\n  Checks if the user has role of pui-case-manager and returns true or false\n  */\n  private isPuiCaseManager(): boolean {\n    const userInfoStr = this.sessionStorageService.getItem('userDetails');\n    if (userInfoStr) {\n      const userInfo: UserInfo = JSON.parse(userInfoStr);\n      return userInfo && userInfo.roles && (userInfo.roles.indexOf(CasesService.PUI_CASE_MANAGER) !== -1);\n    }\n    return false;\n  }\n\n  public getCourtOrHearingCentreName(locationId: number): Observable<any> {\n    return this.http.post(`/api/locations/getLocationsById`, { locations: [{ locationId }] });\n  }\n\n  public createChallengedAccessRequest(caseId: string, request: ChallengedAccessRequest): Observable<RoleAssignmentResponse> {\n    // Assignment API endpoint\n    const userInfoStr = this.sessionStorageService.getItem('userDetails');\n\n    const camUtils = new CaseAccessUtils();\n    let userInfo: UserInfo;\n    if (userInfoStr) {\n      userInfo = JSON.parse(userInfoStr);\n    }\n\n    const roleCategory: RoleCategory = userInfo.roleCategory || camUtils.getMappedRoleCategory(userInfo.roles, userInfo.roleCategories);\n    const roleName = camUtils.getAMRoleName('challenged', roleCategory);\n    const beginTime = new Date();\n    const endTime = new Date(new Date().setUTCHours(23, 59, 59, 999));\n    const id = userInfo.id ? userInfo.id : userInfo.uid;\n    const isNew = true;\n\n    const payload: RoleRequestPayload = camUtils.getAMPayload(id,\n      id,\n      roleName,\n      roleCategory,\n      'CHALLENGED',\n      caseId,\n      request,\n      beginTime,\n      endTime,\n      isNew\n    );\n\n    return this.http.post(`/api/challenged-access-request`, payload);\n  }\n\n  public createSpecificAccessRequest(caseId: string, sar: SpecificAccessRequest): Observable<RoleAssignmentResponse> {\n    // Assignment API endpoint\n    const userInfoStr = this.sessionStorageService.getItem('userDetails');\n\n    const camUtils = new CaseAccessUtils();\n    let userInfo: UserInfo;\n    if (userInfoStr) {\n      userInfo = JSON.parse(userInfoStr);\n    }\n\n    const roleCategory: RoleCategory = userInfo.roleCategory || camUtils.getMappedRoleCategory(userInfo.roles, userInfo.roleCategories);\n    const roleName = camUtils.getAMRoleName('specific', roleCategory);\n    const id = userInfo.id ? userInfo.id : userInfo.uid;\n    const payload: RoleRequestPayload = camUtils.getAMPayload(null, id,\n      roleName, roleCategory, 'SPECIFIC', caseId, sar, null, null, true);\n\n    payload.roleRequest = {\n      ...payload.roleRequest,\n      process: 'specific-access',\n      replaceExisting: true,\n      assignerId: payload.requestedRoles[0].actorId,\n      reference: `${caseId}/${roleName}/${payload.requestedRoles[0].actorId}`\n    };\n\n    payload.requestedRoles[0] = {\n      ...payload.requestedRoles[0],\n      roleName: 'specific-access-requested',\n      roleCategory,\n      classification: 'PRIVATE',\n      endTime: new Date(new Date().setDate(new Date().getDate() + 30)),\n      beginTime: null,\n      grantType: 'BASIC',\n      readOnly: true\n    };\n\n    payload.requestedRoles[0].attributes = {\n      ...payload.requestedRoles[0].attributes,\n      requestedRole: roleName,\n      specificAccessReason: sar.specificReason\n    };\n\n    payload.requestedRoles[0].notes[0] = {\n      ...payload.requestedRoles[0].notes[0],\n      userId: payload.requestedRoles[0].actorId\n    };\n\n    return this.http.post(\n      `/api/specific-access-request`,\n      payload\n    );\n  }\n\n  public getLinkedCases(caseId: string): Observable<LinkedCasesResponse> {\n    const url = `${this.appConfig.getCaseDataStoreApiUrl()}/${caseId}`;\n    return this.http\n      .get(url)\n      .pipe(catchError(error => throwError(error)));\n  }\n}\n"]}

package/esm2020/lib/shared/components/case-editor/services/convert-href-to-router.service.mjs

@@ -0,0 +1,41 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class ConvertHrefToRouterService {
+    constructor(router) {
+        this.router = router;
+        this.hrefMarkdownLinkContent = new BehaviorSubject('Default');
+    }
+    updateHrefLink(content) {
+        this.hrefMarkdownLinkContent.next(content);
+    }
+    getHrefMarkdownLinkContent() {
+        return this.hrefMarkdownLinkContent.asObservable();
+    }
+    callAngularRouter(hrefMarkdownLinkContent) {
+        const urls = hrefMarkdownLinkContent.split('?');
+        const queryParams = urls[1];
+        const queryParamObj = {};
+        if (queryParams) {
+            const queryParam = queryParams.split('&');
+            if (queryParam[0]) {
+                // tslint:disable-next-line: prefer-for-of
+                for (let i = 0; i < queryParam.length; i++) {
+                    const param = queryParam[i].split('=');
+                    queryParamObj[param[0]] = param[1];
+                }
+            }
+        }
+        this.router.navigate([urls[0]], {
+            queryParams: queryParamObj && (Object.keys(queryParamObj).length) ? queryParamObj : ''
+        });
+    }
+}
+ConvertHrefToRouterService.ɵfac = function ConvertHrefToRouterService_Factory(t) { return new (t || ConvertHrefToRouterService)(i0.ɵɵinject(i1.Router)); };
+ConvertHrefToRouterService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ConvertHrefToRouterService, factory: ConvertHrefToRouterService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ConvertHrefToRouterService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.Router }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udmVydC1ocmVmLXRvLXJvdXRlci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NkLWNhc2UtdWktdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9jb21wb25lbnRzL2Nhc2UtZWRpdG9yL3NlcnZpY2VzL2NvbnZlcnQtaHJlZi10by1yb3V0ZXIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUN6QyxPQUFPLEVBQUUsZUFBZSxFQUFjLE1BQU0sTUFBTSxDQUFDOzs7QUFHbkQsTUFBTSxPQUFPLDBCQUEwQjtJQUlyQyxZQUE2QixNQUFjO1FBQWQsV0FBTSxHQUFOLE1BQU0sQ0FBUTtRQUYxQiw0QkFBdUIsR0FBRyxJQUFJLGVBQWUsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUU1QixDQUFDO0lBRXhDLGNBQWMsQ0FBQyxPQUFlO1FBQ25DLElBQUksQ0FBQyx1QkFBdUIsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDN0MsQ0FBQztJQUVNLDBCQUEwQjtRQUMvQixPQUFPLElBQUksQ0FBQyx1QkFBdUIsQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUNyRCxDQUFDO0lBRU0saUJBQWlCLENBQUMsdUJBQXVCO1FBQzlDLE1BQU0sSUFBSSxHQUFHLHVCQUF1QixDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUNoRCxNQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDNUIsTUFBTSxhQUFhLEdBQUcsRUFBRSxDQUFDO1FBRXpCLElBQUksV0FBVyxFQUFFO1lBQ2YsTUFBTSxVQUFVLEdBQUcsV0FBVyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUMxQyxJQUFJLFVBQVUsQ0FBQyxDQUFDLENBQUMsRUFBRTtnQkFDakIsMENBQTBDO2dCQUMxQyxLQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsVUFBVSxDQUFDLE1BQU0sRUFBRSxDQUFDLEVBQUUsRUFBRTtvQkFDMUMsTUFBTSxLQUFLLEdBQUcsVUFBVSxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztvQkFDdkMsYUFBYSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxHQUFHLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQztpQkFDcEM7YUFDRjtTQUNGO1FBRUQsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRTtZQUM5QixXQUFXLEVBQUUsYUFBYSxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQyxFQUFFO1NBQ3ZGLENBQUMsQ0FBQztJQUNMLENBQUM7O29HQWpDVSwwQkFBMEI7Z0ZBQTFCLDBCQUEwQixXQUExQiwwQkFBMEI7dUZBQTFCLDBCQUEwQjtjQUR0QyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUm91dGVyIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcbmltcG9ydCB7IEJlaGF2aW9yU3ViamVjdCwgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgQ29udmVydEhyZWZUb1JvdXRlclNlcnZpY2Uge1xuXG4gIHByaXZhdGUgcmVhZG9ubHkgaHJlZk1hcmtkb3duTGlua0NvbnRlbnQgPSBuZXcgQmVoYXZpb3JTdWJqZWN0KCdEZWZhdWx0Jyk7XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSByb3V0ZXI6IFJvdXRlcikge31cblxuICBwdWJsaWMgdXBkYXRlSHJlZkxpbmsoY29udGVudDogc3RyaW5nKTogdm9pZCB7XG4gICAgdGhpcy5ocmVmTWFya2Rvd25MaW5rQ29udGVudC5uZXh0KGNvbnRlbnQpO1xuICB9XG5cbiAgcHVibGljIGdldEhyZWZNYXJrZG93bkxpbmtDb250ZW50KCk6IE9ic2VydmFibGU8c3RyaW5nPiB7XG4gICAgcmV0dXJuIHRoaXMuaHJlZk1hcmtkb3duTGlua0NvbnRlbnQuYXNPYnNlcnZhYmxlKCk7XG4gIH1cblxuICBwdWJsaWMgY2FsbEFuZ3VsYXJSb3V0ZXIoaHJlZk1hcmtkb3duTGlua0NvbnRlbnQpOiB2b2lkIHtcbiAgICBjb25zdCB1cmxzID0gaHJlZk1hcmtkb3duTGlua0NvbnRlbnQuc3BsaXQoJz8nKTtcbiAgICBjb25zdCBxdWVyeVBhcmFtcyA9IHVybHNbMV07XG4gICAgY29uc3QgcXVlcnlQYXJhbU9iaiA9IHt9O1xuXG4gICAgaWYgKHF1ZXJ5UGFyYW1zKSB7XG4gICAgICBjb25zdCBxdWVyeVBhcmFtID0gcXVlcnlQYXJhbXMuc3BsaXQoJyYnKTtcbiAgICAgIGlmIChxdWVyeVBhcmFtWzBdKSB7XG4gICAgICAgIC8vIHRzbGludDpkaXNhYmxlLW5leHQtbGluZTogcHJlZmVyLWZvci1vZlxuICAgICAgICBmb3IgKGxldCBpID0gMDsgaSA8IHF1ZXJ5UGFyYW0ubGVuZ3RoOyBpKyspIHtcbiAgICAgICAgICBjb25zdCBwYXJhbSA9IHF1ZXJ5UGFyYW1baV0uc3BsaXQoJz0nKTtcbiAgICAgICAgICBxdWVyeVBhcmFtT2JqW3BhcmFtWzBdXSA9IHBhcmFtWzFdO1xuICAgICAgICB9XG4gICAgICB9XG4gICAgfVxuXG4gICAgdGhpcy5yb3V0ZXIubmF2aWdhdGUoW3VybHNbMF1dLCB7XG4gICAgICBxdWVyeVBhcmFtczogcXVlcnlQYXJhbU9iaiAmJiAoT2JqZWN0LmtleXMocXVlcnlQYXJhbU9iaikubGVuZ3RoKSA/IHF1ZXJ5UGFyYW1PYmogOiAnJ1xuICAgIH0pO1xuICB9XG59XG4iXX0=

package/esm2020/lib/shared/components/case-editor/services/event-completion-state-machine.service.mjs

@@ -0,0 +1,143 @@
+import { Injectable } from '@angular/core';
+import { StateMachine } from '@edium/fsm';
+import { throwError } from 'rxjs';
+import { TaskState } from '../../../domain/work-allocation/Task';
+import { EventCompletionPortalTypes } from '../domain/event-completion-portal-types.model';
+import { EventCompletionStates } from '../domain/event-completion-states.enum.model';
+import * as i0 from "@angular/core";
+const EVENT_COMPLETION_STATE_MACHINE = 'EVENT COMPLETION STATE MACHINE';
+export class EventCompletionStateMachineService {
+    initialiseStateMachine(context) {
+        return new StateMachine(EVENT_COMPLETION_STATE_MACHINE, context);
+    }
+    startStateMachine(stateMachine) {
+        stateMachine.start(this.stateCheckTasksCanBeCompleted);
+    }
+    createStates(stateMachine) {
+        // Initial state
+        this.stateCheckTasksCanBeCompleted = stateMachine.createState(EventCompletionStates.CheckTasksCanBeCompleted, false, this.entryActionForStateCheckTasksCanBeCompleted);
+        this.stateCompleteEventAndTask = stateMachine.createState(EventCompletionStates.CompleteEventAndTask, false, this.entryActionForStateCompleteEventAndTask);
+        this.stateTaskCompletedOrCancelled = stateMachine.createState(EventCompletionStates.TaskCompetedOrCancelled, false, this.entryActionForStateTaskCompletedOrCancelled);
+        this.stateTaskAssignedToAnotherUser = stateMachine.createState(EventCompletionStates.TaskAssignedToAnotherUser, false, this.entryActionForStateTaskAssignedToAnotherUser);
+        this.stateTaskUnassigned = stateMachine.createState(EventCompletionStates.TaskUnassigned, false, this.entryActionForStateTaskUnassigned);
+        // Create final state, the second param isComplete is set to true to make sure state machine finished running
+        this.stateFinal = stateMachine.createState(EventCompletionStates.Final, true, this.entryActionForStateFinal);
+    }
+    addTransitions() {
+        // Initial transition
+        this.addTransitionsForStateCheckTasksCanBeCompleted();
+        this.addTransitionsForStateTaskCompletedOrCancelled();
+        this.addTransitionsForStateCompleteEventAndTask();
+        this.addTransitionsForStateTaskAssignedToAnotherUser();
+        this.addTransitionsForStateTaskUnassigned();
+    }
+    entryActionForStateCheckTasksCanBeCompleted(state, context) {
+        context.workAllocationService.getTask(context.task.id).subscribe(taskResponse => {
+            if (taskResponse && taskResponse.task && taskResponse.task.task_state) {
+                switch (taskResponse.task.task_state.toUpperCase()) {
+                    case TaskState.Unassigned:
+                        // Task unassigned
+                        state.trigger(EventCompletionStates.TaskUnassigned);
+                        break;
+                    case TaskState.Completed:
+                    case TaskState.Cancelled:
+                    case TaskState.Terminated:
+                        // Task completed or cancelled
+                        state.trigger(EventCompletionStates.TaskCompetedOrCancelled);
+                        break;
+                    case TaskState.Assigned:
+                        // Task is in assigned state
+                        if (taskResponse.task.assignee === context.task.assignee) {
+                            // Task still assigned to current user, complete event and task
+                            state.trigger(EventCompletionStates.CompleteEventAndTask);
+                        }
+                        else {
+                            // Task has been reassigned to another user, display error message
+                            context.reassignedTask = taskResponse.task;
+                            state.trigger(EventCompletionStates.TaskAssignedToAnotherUser);
+                        }
+                        break;
+                    default:
+                        // Allow user to complete the event
+                        state.trigger(EventCompletionStates.CompleteEventAndTask);
+                        break;
+                }
+            }
+        }, error => {
+            context.alertService.error(error.message);
+            return throwError(error);
+        });
+    }
+    entryActionForStateTaskCompletedOrCancelled(state, context) {
+        // Trigger final state to complete processing of state machine
+        state.trigger(EventCompletionStates.Final);
+        // Load case event completion task cancelled component
+        context.component.showPortal(EventCompletionPortalTypes.TaskCancelled);
+    }
+    entryActionForStateCompleteEventAndTask(state, context) {
+        // Trigger final state to complete processing of state machine
+        state.trigger(EventCompletionStates.Final);
+        const taskStr = context.sessionStorageService.getItem('taskToComplete');
+        if (taskStr) {
+            context.sessionStorageService.setItem('assignNeeded', 'false');
+            // just set event can be completed
+            context.component.eventCanBeCompleted.emit(true);
+        }
+        else {
+            // Emit event cannot be completed event
+            context.component.eventCanBeCompleted.emit(false);
+        }
+    }
+    entryActionForStateTaskAssignedToAnotherUser(state, context) {
+        // Trigger final state to complete processing of state machine
+        state.trigger(EventCompletionStates.Final);
+        // Load case event completion task reassigned component
+        context.component.showPortal(EventCompletionPortalTypes.TaskReassigned);
+    }
+    entryActionForStateTaskUnassigned(state, context) {
+        // Trigger final state to complete processing of state machine
+        state.trigger(EventCompletionStates.Final);
+        // Get task details
+        const taskStr = context.sessionStorageService.getItem('taskToComplete');
+        if (taskStr) {
+            context.sessionStorageService.setItem('assignNeeded', 'true');
+            context.component.eventCanBeCompleted.emit(true);
+        }
+        else {
+            // Emit event cannot be completed event
+            context.component.eventCanBeCompleted.emit(false);
+        }
+    }
+    entryActionForStateFinal(state, context) {
+        // Final actions can be performed here, the state machine finished running
+        console.log('FINAL');
+    }
+    addTransitionsForStateCheckTasksCanBeCompleted() {
+        // Complete event and task
+        this.stateCheckTasksCanBeCompleted.addTransition(EventCompletionStates.CompleteEventAndTask, this.stateCompleteEventAndTask);
+        // Task completed or cancelled
+        this.stateCheckTasksCanBeCompleted.addTransition(EventCompletionStates.TaskCompetedOrCancelled, this.stateTaskCompletedOrCancelled);
+        // Task assigned to another user
+        this.stateCheckTasksCanBeCompleted.addTransition(EventCompletionStates.TaskAssignedToAnotherUser, this.stateTaskAssignedToAnotherUser);
+        // Task unassigned
+        this.stateCheckTasksCanBeCompleted.addTransition(EventCompletionStates.TaskUnassigned, this.stateTaskUnassigned);
+    }
+    addTransitionsForStateTaskCompletedOrCancelled() {
+        this.stateTaskCompletedOrCancelled.addTransition(EventCompletionStates.Final, this.stateFinal);
+    }
+    addTransitionsForStateCompleteEventAndTask() {
+        this.stateCompleteEventAndTask.addTransition(EventCompletionStates.Final, this.stateFinal);
+    }
+    addTransitionsForStateTaskAssignedToAnotherUser() {
+        this.stateTaskAssignedToAnotherUser.addTransition(EventCompletionStates.Final, this.stateFinal);
+    }
+    addTransitionsForStateTaskUnassigned() {
+        this.stateTaskUnassigned.addTransition(EventCompletionStates.Final, this.stateFinal);
+    }
+}
+EventCompletionStateMachineService.ɵfac = function EventCompletionStateMachineService_Factory(t) { return new (t || EventCompletionStateMachineService)(); };
+EventCompletionStateMachineService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: EventCompletionStateMachineService, factory: EventCompletionStateMachineService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EventCompletionStateMachineService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-completion-state-machine.service.js","sourceRoot":"","sources":["../../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/case-editor/services/event-completion-state-machine.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { State, StateMachine } from '@edium/fsm';\nimport { throwError } from 'rxjs';\nimport { Task, TaskState } from '../../../domain/work-allocation/Task';\nimport { EventCompletionPortalTypes } from '../domain/event-completion-portal-types.model';\nimport { EventCompletionStateMachineContext } from '../domain/event-completion-state-machine-context.model';\nimport { EventCompletionStates } from '../domain/event-completion-states.enum.model';\n\nconst EVENT_COMPLETION_STATE_MACHINE = 'EVENT COMPLETION STATE MACHINE';\n\n@Injectable()\nexport class EventCompletionStateMachineService {\n  public stateCheckTasksCanBeCompleted: State;\n  public stateCompleteEventAndTask: State;\n  public stateCancelEvent: State;\n  public stateCompleteEventNotTask: State;\n  public stateTaskCompletedOrCancelled: State;\n  public stateTaskAssignedToAnotherUser: State;\n  public stateTaskReassignToUser: State;\n  public stateTaskAssignToUser: State;\n  public stateTaskUnassigned: State;\n  public stateFinal: State;\n\n  public initialiseStateMachine(context: EventCompletionStateMachineContext): StateMachine {\n    return new StateMachine(EVENT_COMPLETION_STATE_MACHINE, context);\n  }\n\n  public startStateMachine(stateMachine: StateMachine): void {\n    stateMachine.start(this.stateCheckTasksCanBeCompleted);\n  }\n\n  public createStates(stateMachine: StateMachine): void {\n    // Initial state\n    this.stateCheckTasksCanBeCompleted = stateMachine.createState(\n      EventCompletionStates.CheckTasksCanBeCompleted,\n      false,\n      this.entryActionForStateCheckTasksCanBeCompleted\n    );\n\n    this.stateCompleteEventAndTask = stateMachine.createState(\n      EventCompletionStates.CompleteEventAndTask,\n      false,\n      this.entryActionForStateCompleteEventAndTask\n    );\n\n    this.stateTaskCompletedOrCancelled = stateMachine.createState(\n      EventCompletionStates.TaskCompetedOrCancelled,\n      false,\n      this.entryActionForStateTaskCompletedOrCancelled\n    );\n\n    this.stateTaskAssignedToAnotherUser = stateMachine.createState(\n      EventCompletionStates.TaskAssignedToAnotherUser,\n      false,\n      this.entryActionForStateTaskAssignedToAnotherUser\n    );\n\n    this.stateTaskUnassigned = stateMachine.createState(\n      EventCompletionStates.TaskUnassigned,\n      false,\n      this.entryActionForStateTaskUnassigned\n    );\n\n    // Create final state, the second param isComplete is set to true to make sure state machine finished running\n    this.stateFinal = stateMachine.createState(\n      EventCompletionStates.Final,\n      true,\n      this.entryActionForStateFinal\n    );\n  }\n\n  public addTransitions(): void {\n    // Initial transition\n    this.addTransitionsForStateCheckTasksCanBeCompleted();\n    this.addTransitionsForStateTaskCompletedOrCancelled();\n    this.addTransitionsForStateCompleteEventAndTask();\n    this.addTransitionsForStateTaskAssignedToAnotherUser();\n    this.addTransitionsForStateTaskUnassigned();\n  }\n\n  public entryActionForStateCheckTasksCanBeCompleted(state: State, context: EventCompletionStateMachineContext): void {\n    context.workAllocationService.getTask(context.task.id).subscribe(\n      taskResponse => {\n        if (taskResponse && taskResponse.task && taskResponse.task.task_state) {\n          switch (taskResponse.task.task_state.toUpperCase()) {\n            case TaskState.Unassigned:\n              // Task unassigned\n              state.trigger(EventCompletionStates.TaskUnassigned);\n              break;\n            case TaskState.Completed:\n            case TaskState.Cancelled:\n            case TaskState.Terminated:\n              // Task completed or cancelled\n              state.trigger(EventCompletionStates.TaskCompetedOrCancelled);\n              break;\n            case TaskState.Assigned:\n              // Task is in assigned state\n              if (taskResponse.task.assignee === context.task.assignee) {\n                // Task still assigned to current user, complete event and task\n                state.trigger(EventCompletionStates.CompleteEventAndTask);\n              } else {\n                // Task has been reassigned to another user, display error message\n                context.reassignedTask = taskResponse.task;\n                state.trigger(EventCompletionStates.TaskAssignedToAnotherUser);\n              }\n              break;\n            default:\n              // Allow user to complete the event\n              state.trigger(EventCompletionStates.CompleteEventAndTask);\n              break;\n          }\n        }\n      },\n      error => {\n        context.alertService.error(error.message);\n        return throwError(error);\n      });\n  }\n\n  public entryActionForStateTaskCompletedOrCancelled(state: State, context: EventCompletionStateMachineContext): void {\n    // Trigger final state to complete processing of state machine\n    state.trigger(EventCompletionStates.Final);\n    // Load case event completion task cancelled component\n    context.component.showPortal(EventCompletionPortalTypes.TaskCancelled);\n  }\n\n  public entryActionForStateCompleteEventAndTask(state: State, context: EventCompletionStateMachineContext): void {\n    // Trigger final state to complete processing of state machine\n    state.trigger(EventCompletionStates.Final);\n\n    const taskStr = context.sessionStorageService.getItem('taskToComplete');\n    if (taskStr) {\n      context.sessionStorageService.setItem('assignNeeded', 'false');\n      // just set event can be completed\n      context.component.eventCanBeCompleted.emit(true);\n    } else {\n      // Emit event cannot be completed event\n      context.component.eventCanBeCompleted.emit(false);\n    }\n  }\n\n  public entryActionForStateTaskAssignedToAnotherUser(state: State, context: EventCompletionStateMachineContext): void {\n    // Trigger final state to complete processing of state machine\n    state.trigger(EventCompletionStates.Final);\n    // Load case event completion task reassigned component\n    context.component.showPortal(EventCompletionPortalTypes.TaskReassigned);\n  }\n\n  public entryActionForStateTaskUnassigned(state: State, context: EventCompletionStateMachineContext): void {\n    // Trigger final state to complete processing of state machine\n    state.trigger(EventCompletionStates.Final);\n\n    // Get task details\n    const taskStr = context.sessionStorageService.getItem('taskToComplete');\n    if (taskStr) {\n      context.sessionStorageService.setItem('assignNeeded', 'true');\n      context.component.eventCanBeCompleted.emit(true);\n    } else {\n      // Emit event cannot be completed event\n      context.component.eventCanBeCompleted.emit(false);\n    }\n  }\n\n  public entryActionForStateFinal(state: State, context: EventCompletionStateMachineContext): void {\n    // Final actions can be performed here, the state machine finished running\n    console.log('FINAL');\n  }\n\n  public addTransitionsForStateCheckTasksCanBeCompleted(): void {\n    // Complete event and task\n    this.stateCheckTasksCanBeCompleted.addTransition(\n      EventCompletionStates.CompleteEventAndTask,\n      this.stateCompleteEventAndTask\n    );\n    // Task completed or cancelled\n    this.stateCheckTasksCanBeCompleted.addTransition(\n      EventCompletionStates.TaskCompetedOrCancelled,\n      this.stateTaskCompletedOrCancelled\n    );\n    // Task assigned to another user\n    this.stateCheckTasksCanBeCompleted.addTransition(\n      EventCompletionStates.TaskAssignedToAnotherUser,\n      this.stateTaskAssignedToAnotherUser\n    );\n    // Task unassigned\n    this.stateCheckTasksCanBeCompleted.addTransition(\n      EventCompletionStates.TaskUnassigned,\n      this.stateTaskUnassigned\n    );\n  }\n\n  public addTransitionsForStateTaskCompletedOrCancelled(): void {\n    this.stateTaskCompletedOrCancelled.addTransition(\n      EventCompletionStates.Final,\n      this.stateFinal\n    );\n  }\n\n  public addTransitionsForStateCompleteEventAndTask(): void {\n    this.stateCompleteEventAndTask.addTransition(\n      EventCompletionStates.Final,\n      this.stateFinal\n    );\n  }\n\n  public addTransitionsForStateTaskAssignedToAnotherUser(): void {\n    this.stateTaskAssignedToAnotherUser.addTransition(\n      EventCompletionStates.Final,\n      this.stateFinal\n    );\n  }\n\n  public addTransitionsForStateTaskUnassigned(): void {\n    this.stateTaskUnassigned.addTransition(\n      EventCompletionStates.Final,\n      this.stateFinal\n    );\n  }\n}\n"]}

package/esm2020/lib/shared/components/case-editor/services/event-trigger.service.mjs

@@ -0,0 +1,20 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class EventTriggerService {
+    constructor() {
+        this.eventTriggerSource = new Subject();
+    }
+    announceEventTrigger(eventTrigger) {
+        this.eventTriggerSource.next(eventTrigger);
+    }
+}
+EventTriggerService.ɵfac = function EventTriggerService_Factory(t) { return new (t || EventTriggerService)(); };
+EventTriggerService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: EventTriggerService, factory: EventTriggerService.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EventTriggerService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtdHJpZ2dlci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NkLWNhc2UtdWktdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9jb21wb25lbnRzL2Nhc2UtZWRpdG9yL3NlcnZpY2VzL2V2ZW50LXRyaWdnZXIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBTS9CLE1BQU0sT0FBTyxtQkFBbUI7SUFIaEM7UUFLUyx1QkFBa0IsR0FBRyxJQUFJLE9BQU8sRUFBb0IsQ0FBQztLQU03RDtJQUpRLG9CQUFvQixDQUFDLFlBQThCO1FBQ3hELElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUM7SUFDN0MsQ0FBQzs7c0ZBTlUsbUJBQW1CO3lFQUFuQixtQkFBbUIsV0FBbkIsbUJBQW1CLG1CQUZsQixNQUFNO3VGQUVQLG1CQUFtQjtjQUgvQixVQUFVO2VBQUM7Z0JBQ1YsVUFBVSxFQUFFLE1BQU07YUFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBDYXNlRXZlbnRUcmlnZ2VyIH0gZnJvbSAnLi4vLi4vLi4vZG9tYWluL2Nhc2Utdmlldy9jYXNlLWV2ZW50LXRyaWdnZXIubW9kZWwnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgRXZlbnRUcmlnZ2VyU2VydmljZSB7XG5cbiAgcHVibGljIGV2ZW50VHJpZ2dlclNvdXJjZSA9IG5ldyBTdWJqZWN0PENhc2VFdmVudFRyaWdnZXI+KCk7XG5cbiAgcHVibGljIGFubm91bmNlRXZlbnRUcmlnZ2VyKGV2ZW50VHJpZ2dlcjogQ2FzZUV2ZW50VHJpZ2dlcikge1xuICAgIHRoaXMuZXZlbnRUcmlnZ2VyU291cmNlLm5leHQoZXZlbnRUcmlnZ2VyKTtcbiAgfVxuXG59XG4iXX0=