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

package/esm2015/lib/shared/components/case-editor/services/cases.service.js

@@ -0,0 +1,270 @@
+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 } from '../../../domain/case-view/case-event-trigger.model';
+import { Draft } from '../../../domain/draft.model';
+import { FieldsUtils } from '../../../services/fields/fields.utils';
+import { HttpErrorService } from '../../../services/http/http-error.service';
+import { HttpService } from '../../../services/http/http.service';
+import { LoadingService } from '../../../services/loading/loading.service';
+import { OrderService } from '../../../services/order/order.service';
+import { SessionStorageService } from '../../../services/session/session-storage.service';
+import { CaseAccessUtils } from '../case-access-utils';
+import { WizardPageFieldToCaseFieldMapper } from './wizard-page-field-to-case-field.mapper';
+import { WorkAllocationService } from './work-allocation.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/http/http.service";
+import * as i2 from "../../../../app.config";
+import * as i3 from "../../../services/order/order.service";
+import * as i4 from "../../../services/http/http-error.service";
+import * as i5 from "./wizard-page-field-to-case-field.mapper";
+import * as i6 from "./work-allocation.service";
+import * as i7 from "../../../services/loading/loading.service";
+import * as i8 from "../../../services/session/session-storage.service";
+export class CasesService {
+    constructor(http, appConfig, orderService, errorService, wizardPageFieldToCaseFieldMapper, workAllocationService, loadingService, sessionStorageService) {
+        this.http = http;
+        this.appConfig = appConfig;
+        this.orderService = orderService;
+        this.errorService = errorService;
+        this.wizardPageFieldToCaseFieldMapper = wizardPageFieldToCaseFieldMapper;
+        this.workAllocationService = workAllocationService;
+        this.loadingService = loadingService;
+        this.sessionStorageService = sessionStorageService;
+        /**
+         * @deprecated Use `CasesService::getCaseView` instead
+         */
+        this.get = this.getCaseView;
+    }
+    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();
+        return this.http
+            .get(url, { headers, observe: 'body' })
+            .pipe(catchError(error => {
+            this.errorService.setError(error);
+            return throwError(error);
+        }), finalize(() => this.loadingService.unregister(loadingToken)));
+    }
+    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(map(body => this.processResponseBody(body, eventData)), 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(map(body => this.processResponseBody(body, eventData)), 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);
+        }));
+    }
+    getCourtOrHearingCentreName(locationId) {
+        return this.http.get(`${this.appConfig.getLocationRefApiUrl()}/building-locations?epimms_id=${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 = 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 payload = camUtils.getAMPayload(id, id, roleName, roleCategory, 'CHALLENGED', caseId, request, beginTime, endTime);
+        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 = 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);
+        payload.roleRequest = Object.assign(Object.assign({}, payload.roleRequest), { process: 'specific-access', replaceExisting: true, assignerId: payload.requestedRoles[0].actorId, reference: `${caseId}/${roleName}/${payload.requestedRoles[0].actorId}` });
+        payload.requestedRoles[0] = Object.assign(Object.assign({}, 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 = Object.assign(Object.assign({}, payload.requestedRoles[0].attributes), { requestedRole: roleName });
+        payload.requestedRoles[0].notes[0] = Object.assign(Object.assign({}, payload.requestedRoles[0].notes[0]), { userId: payload.requestedRoles[0].actorId });
+        return this.http.post(`/api/specific-access-request`, payload);
+    }
+    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;
+    }
+    processResponseBody(body, eventData) {
+        this.processTasksOnSuccess(body, eventData.event);
+        return body;
+    }
+    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));
+        });
+    }
+    processTasksOnSuccess(caseData, eventData) {
+        // The following code is work allocation 1 related
+        if (this.appConfig.getWorkAllocationApiUrl().toLowerCase() === 'workallocation') {
+            // This is used a feature toggle to
+            // control the work allocation
+            if (!this.isPuiCaseManager()) {
+                this.workAllocationService.completeAppropriateTask(caseData.id, eventData.id, caseData.jurisdiction, caseData.case_type)
+                    .subscribe(() => {
+                    // Success. Do nothing.
+                }, error => {
+                    // Show an appropriate warning about something that went wrong.
+                    console.warn('Could not process tasks for this case event', error);
+                });
+            }
+        }
+    }
+    /*
+    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;
+    }
+}
+// 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(i3.OrderService), i0.ɵɵinject(i4.HttpErrorService), i0.ɵɵinject(i5.WizardPageFieldToCaseFieldMapper), i0.ɵɵinject(i6.WorkAllocationService), i0.ɵɵinject(i7.LoadingService), i0.ɵɵinject(i8.SessionStorageService)); };
+CasesService.ɵprov = 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: i3.OrderService }, { type: i4.HttpErrorService }, { type: i5.WizardPageFieldToCaseFieldMapper }, { type: i6.WorkAllocationService }, { type: i7.LoadingService }, { type: i8.SessionStorageService }]; }, 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 { 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';\n\nimport { AbstractAppConfig } from '../../../../app.config';\nimport { ShowCondition } from '../../../directives';\nimport { CaseEventData } from '../../../domain/case-event-data.model';\nimport { CaseEventTrigger } from '../../../domain/case-view/case-event-trigger.model';\nimport { CasePrintDocument } from '../../../domain/case-view/case-print-document.model';\nimport { CaseView } from '../../../domain/case-view/case-view.model';\nimport { ChallengedAccessRequest } from '../../../domain/case-view/challenged-access-request.model';\nimport { RoleAssignmentResponse } from '../../../domain/case-view/role-assignment-response.model';\nimport { RoleCategory, RoleRequestPayload } from '../../../domain/case-view/role-request.model';\nimport { SpecificAccessRequest } from '../../../domain/case-view/specific-access-request.model';\nimport { Draft } from '../../../domain/draft.model';\nimport { UserInfo } from '../../../domain/user/user-info.model';\nimport { FieldsUtils } from '../../../services/fields/fields.utils';\nimport { HttpErrorService } from '../../../services/http/http-error.service';\nimport { HttpService } from '../../../services/http/http.service';\nimport { LoadingService } from '../../../services/loading/loading.service';\nimport { OrderService } from '../../../services/order/order.service';\nimport { SessionStorageService } from '../../../services/session/session-storage.service';\nimport { CaseAccessUtils } from '../case-access-utils';\nimport { WizardPage } from '../domain/wizard-page.model';\nimport { WizardPageFieldToCaseFieldMapper } from './wizard-page-field-to-case-field.mapper';\nimport { WorkAllocationService } from './work-allocation.service';\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  /**\n   * @deprecated Use `CasesService::getCaseView` instead\n   */\n  public get = this.getCaseView;\n\n  constructor(\n    private readonly http: HttpService,\n    private readonly appConfig: AbstractAppConfig,\n    private readonly orderService: OrderService,\n    private readonly errorService: HttpErrorService,\n    private readonly wizardPageFieldToCaseFieldMapper: WizardPageFieldToCaseFieldMapper,\n    private readonly workAllocationService: WorkAllocationService,\n    private readonly loadingService: LoadingService,\n    private readonly sessionStorageService: SessionStorageService\n  ) {\n  }\n\n  public getCaseView(jurisdictionId: string,\n              caseTypeId: string,\n              caseId: string): Observable<CaseView> {\n    const url = this.appConfig.getApiUrl()\n      + `/caseworkers/:uid`\n      + `/jurisdictions/${jurisdictionId}`\n      + `/case-types/${caseTypeId}`\n      + `/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    return this.http\n      .get(url, {headers, observe: 'body'})\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 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: object) => plainToClass(CaseEventTrigger, p)),\n        tap(eventTrigger => this.initialiseEventTrigger(eventTrigger))\n      );\n  }\n\n  public createEvent(caseDetails: CaseView, eventData: CaseEventData): Observable<object> {\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        map(body => this.processResponseBody(body, eventData)),\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()\n      + `/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()\n      + `/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        map(body => this.processResponseBody(body, eventData)),\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()\n      + `/cases/${caseId}`\n      + `/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  public getCourtOrHearingCentreName(locationId: number): Observable<any> {\n    return this.http.get(`${this.appConfig.getLocationRefApiUrl()}/building-locations?epimms_id=${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 = 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 payload: RoleRequestPayload = camUtils.getAMPayload(id,\n                                                              id,\n                                                              roleName,\n                                                              roleCategory,\n                                                              'CHALLENGED',\n                                                              caseId,\n                                                              request,\n                                                              beginTime,\n                                                              endTime);\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 = 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);\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    };\n\n    payload.requestedRoles[0].notes[0] = {\n      ...payload.requestedRoles[0].notes[0],\n      userId: payload.requestedRoles[0].actorId\n    };\n    return this.http.post(\n      `/api/specific-access-request`,\n      payload\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 processResponseBody(body: any, eventData: CaseEventData): any {\n    this.processTasksOnSuccess(body, eventData.event);\n    return body;\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  private processTasksOnSuccess(caseData: any, eventData: any): void {\n    // The following code is work allocation 1 related\n    if (this.appConfig.getWorkAllocationApiUrl().toLowerCase() === 'workallocation') {\n      // This is used a feature toggle to\n      // control the work allocation\n      if (!this.isPuiCaseManager()) {\n        this.workAllocationService.completeAppropriateTask(caseData.id, eventData.id, caseData.jurisdiction, caseData.case_type)\n          .subscribe(() => {\n            // Success. Do nothing.\n          }, error => {\n            // Show an appropriate warning about something that went wrong.\n            console.warn('Could not process tasks for this case event', error);\n          });\n      }\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"]}

package/esm2015/lib/shared/components/case-editor/services/wizard-page-field-to-case-field.mapper.js

@@ -0,0 +1,115 @@
+import { Injectable } from '@angular/core';
+import { ShowCondition } from '../../../directives/conditional-show/domain/conditional-show.model';
+import * as i0 from "@angular/core";
+export class WizardPageFieldToCaseFieldMapper {
+    mapAll(wizardPageFields, caseFields) {
+        return wizardPageFields.map(wizardField => {
+            return this.map(wizardField, caseFields);
+        });
+    }
+    map(wizardPageField, caseFields) {
+        const caseField = caseFields.find(e => e.id === wizardPageField.case_field_id);
+        caseField.wizardProps = wizardPageField;
+        caseField.order = wizardPageField.order;
+        this.fixShowConditionPath(caseField, '');
+        if (wizardPageField.complex_field_overrides && wizardPageField.complex_field_overrides.length > 0) {
+            wizardPageField.complex_field_overrides.forEach((override) => {
+                this.processComplexFieldOverride(override, caseField, caseFields);
+            });
+        }
+        // this will fix the CaseLink type as we exclude it in ccdFieldsFilter directive
+        this.hideParentIfAllChildrenHidden(caseField);
+        return caseField;
+    }
+    processComplexFieldOverride(override, caseField, caseFields) {
+        const caseFieldIds = override.complex_field_element_id.split('.');
+        let case_field_leaf;
+        const children = this.getCaseFieldChildren(caseField);
+        if (children.length > 0) {
+            const [_, ...tail] = caseFieldIds;
+            case_field_leaf = this.getCaseFieldLeaf(tail, children);
+        }
+        else {
+            case_field_leaf = this.getCaseFieldLeaf(caseFieldIds, caseFields);
+        }
+        if (override.display_context !== 'HIDDEN') {
+            case_field_leaf.hidden = false;
+            case_field_leaf.display_context = override.display_context;
+            if (override.label && override.label.length > 0) {
+                case_field_leaf.label = override.label;
+            }
+            if (override.hint_text && override.hint_text.length > 0) {
+                case_field_leaf.hint_text = override.hint_text;
+            }
+            if (override.show_condition && override.show_condition.length > 0) {
+                case_field_leaf.show_condition = override.show_condition;
+            }
+        }
+        else {
+            case_field_leaf.hidden = true;
+            case_field_leaf.display_context = override.display_context;
+        }
+    }
+    fixShowConditionPath(caseField, pathPrefix) {
+        if (caseField.show_condition) {
+            caseField.show_condition = ShowCondition.addPathPrefixToCondition(caseField.show_condition, pathPrefix);
+        }
+        const childrenCaseFields = this.getCaseFieldChildren(caseField);
+        childrenCaseFields.forEach(collectionCaseField => {
+            this.fixShowConditionPath(collectionCaseField, this.preparePathPrefix(pathPrefix, caseField.id));
+        });
+    }
+    preparePathPrefix(pathPrefix, caseField) {
+        return pathPrefix.length === 0 ? caseField : pathPrefix + '.' + caseField;
+    }
+    getCaseFieldLeaf(caseFieldId, caseFields) {
+        const [head, ...tail] = caseFieldId;
+        if (caseFieldId.length === 1) {
+            const caseLeaf = caseFields.find(e => e.id === head);
+            if (!caseLeaf) {
+                throw new Error(`Cannot find leaf for caseFieldId ${caseFieldId.join('.')}`);
+            }
+            return caseLeaf;
+        }
+        else if (caseFieldId.length > 1) {
+            const caseField = caseFields.find(e => e.id === head);
+            const children = this.getCaseFieldChildren(caseField);
+            if (children.length === 0) {
+                throw new Error(`field_type or complex_fields missing for ${caseFieldId.join('.')}`);
+            }
+            return this.getCaseFieldLeaf(tail, children);
+        }
+        else {
+            throw new Error(`Cannot find leaf for caseFieldId ${caseFieldId.join('.')}`);
+        }
+    }
+    hideParentIfAllChildrenHidden(caseField) {
+        const childrenCaseFields = this.getCaseFieldChildren(caseField);
+        childrenCaseFields.forEach(e => this.hideParentIfAllChildrenHidden(e));
+        if (childrenCaseFields.length > 0 && this.allCaseFieldsHidden(childrenCaseFields)) {
+            caseField.hidden = true;
+        }
+    }
+    getCaseFieldChildren(caseField) {
+        let childrenCaseFields = [];
+        if (caseField.isCollection()) {
+            childrenCaseFields = caseField.field_type.collection_field_type.complex_fields || [];
+        }
+        else if (caseField.isComplex()) {
+            childrenCaseFields = caseField.field_type.complex_fields || [];
+        }
+        return childrenCaseFields;
+    }
+    allCaseFieldsHidden(children) {
+        return !children.some(e => e.hidden !== true);
+    }
+}
+WizardPageFieldToCaseFieldMapper.ɵfac = function WizardPageFieldToCaseFieldMapper_Factory(t) { return new (t || WizardPageFieldToCaseFieldMapper)(); };
+WizardPageFieldToCaseFieldMapper.ɵprov = i0.ɵɵdefineInjectable({ token: WizardPageFieldToCaseFieldMapper, factory: WizardPageFieldToCaseFieldMapper.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WizardPageFieldToCaseFieldMapper, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wizard-page-field-to-case-field.mapper.js","sourceRoot":"","sources":["../../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/case-editor/services/wizard-page-field-to-case-field.mapper.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ShowCondition } from '../../../directives/conditional-show/domain/conditional-show.model';\nimport { CaseField } from '../../../domain/definition/case-field.model';\nimport { ComplexFieldOverride } from '../domain/wizard-page-field-complex-override.model';\nimport { WizardPageField } from '../domain/wizard-page-field.model';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class WizardPageFieldToCaseFieldMapper {\n\n  public mapAll(wizardPageFields: WizardPageField[], caseFields: CaseField[]): CaseField[] {\n    return wizardPageFields.map(wizardField => {\n      return this.map(wizardField, caseFields);\n    });\n  }\n\n  private map(wizardPageField: WizardPageField, caseFields: CaseField[]): CaseField {\n\n    const caseField: CaseField = caseFields.find(e => e.id === wizardPageField.case_field_id);\n    caseField.wizardProps = wizardPageField;\n    caseField.order = wizardPageField.order;\n\n    this.fixShowConditionPath(caseField, '');\n\n    if (wizardPageField.complex_field_overrides && wizardPageField.complex_field_overrides.length > 0) {\n      wizardPageField.complex_field_overrides.forEach((override: ComplexFieldOverride) => {\n        this.processComplexFieldOverride(override, caseField, caseFields);\n      });\n    }\n\n    // this will fix the CaseLink type as we exclude it in ccdFieldsFilter directive\n    this.hideParentIfAllChildrenHidden(caseField);\n\n    return caseField;\n  }\n\n  private processComplexFieldOverride(override: ComplexFieldOverride, caseField: CaseField, caseFields: CaseField[]) {\n    const caseFieldIds = override.complex_field_element_id.split('.');\n    let case_field_leaf: CaseField;\n\n    const children = this.getCaseFieldChildren(caseField);\n\n    if (children.length > 0) {\n      const [_, ...tail] = caseFieldIds;\n      case_field_leaf = this.getCaseFieldLeaf(tail, children);\n    } else {\n      case_field_leaf = this.getCaseFieldLeaf(caseFieldIds, caseFields);\n    }\n\n    if (override.display_context !== 'HIDDEN') {\n      case_field_leaf.hidden = false;\n      case_field_leaf.display_context = override.display_context;\n      if (override.label && override.label.length > 0) {\n        case_field_leaf.label = override.label;\n      }\n      if (override.hint_text && override.hint_text.length > 0) {\n        case_field_leaf.hint_text = override.hint_text;\n      }\n      if (override.show_condition && override.show_condition.length > 0) {\n        case_field_leaf.show_condition = override.show_condition;\n      }\n    } else {\n      case_field_leaf.hidden = true;\n      case_field_leaf.display_context = override.display_context;\n    }\n  }\n\n  private fixShowConditionPath(caseField: CaseField, pathPrefix: string) {\n    if (caseField.show_condition) {\n      caseField.show_condition = ShowCondition.addPathPrefixToCondition(caseField.show_condition, pathPrefix);\n    }\n\n    const childrenCaseFields = this.getCaseFieldChildren(caseField);\n\n    childrenCaseFields.forEach(collectionCaseField => {\n      this.fixShowConditionPath(collectionCaseField, this.preparePathPrefix(pathPrefix, caseField.id));\n    });\n  }\n\n  private preparePathPrefix(pathPrefix: string, caseField: string) {\n    return pathPrefix.length === 0 ? caseField : pathPrefix + '.' + caseField;\n  }\n\n  private getCaseFieldLeaf(caseFieldId: string[], caseFields: CaseField[]): CaseField {\n    const [head, ...tail] = caseFieldId;\n    if (caseFieldId.length === 1) {\n      const caseLeaf = caseFields.find(e => e.id === head);\n      if (!caseLeaf) {\n        throw new Error(`Cannot find leaf for caseFieldId ${caseFieldId.join('.')}`);\n      }\n      return caseLeaf;\n    } else if (caseFieldId.length > 1) {\n      const caseField = caseFields.find(e => e.id === head);\n      const children = this.getCaseFieldChildren(caseField);\n\n      if (children.length === 0) {\n        throw new Error(`field_type or complex_fields missing for ${caseFieldId.join('.')}`);\n      }\n      return this.getCaseFieldLeaf(tail, children);\n    } else {\n      throw new Error(`Cannot find leaf for caseFieldId ${caseFieldId.join('.')}`);\n    }\n  }\n\n  private hideParentIfAllChildrenHidden(caseField: CaseField) {\n\n    const childrenCaseFields = this.getCaseFieldChildren(caseField);\n\n    childrenCaseFields.forEach(e => this.hideParentIfAllChildrenHidden(e));\n\n    if (childrenCaseFields.length > 0 && this.allCaseFieldsHidden(childrenCaseFields)) {\n      caseField.hidden = true;\n    }\n  }\n\n  private getCaseFieldChildren(caseField: CaseField) {\n    let childrenCaseFields = [];\n    if (caseField.isCollection()) {\n      childrenCaseFields = caseField.field_type.collection_field_type.complex_fields || [];\n    } else if (caseField.isComplex()) {\n      childrenCaseFields = caseField.field_type.complex_fields || [];\n    }\n    return childrenCaseFields;\n  }\n\n  private allCaseFieldsHidden(children: CaseField[]): boolean {\n    return !children.some(e => e.hidden !== true);\n  }\n}\n"]}