@hmcts/ccd-case-ui-toolkit 7.0.20 → 7.0.21-CVE-fix

package/esm2022/lib/shared/components/case-viewer/case-viewer.module.mjs

@@ -0,0 +1,98 @@
+import { __decorate } from "tslib";
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { MatLegacyTabsModule as MatTabsModule } from '@angular/material/legacy-tabs';
+import { RouterModule } from '@angular/router';
+import { RpxTranslationModule } from 'rpx-xui-translation';
+import { AlertModule } from '../../../components/banners/alert/alert.module';
+import { BannersModule } from '../../../components/banners/banners.module';
+import { ConditionalShowModule, LabelSubstitutorModule } from '../../directives';
+import { CaseReferencePipe } from '../../pipes';
+import { ActivityPollingService, ActivityService, DraftService, ErrorNotifierService, HttpService, NavigationNotifierService, OrderService } from '../../services';
+import { ActivityModule } from '../activity';
+import { CaseEditorModule, CaseNotifier, ConvertHrefToRouterService } from '../case-editor';
+import { CaseHeaderModule } from '../case-header';
+import { CaseHistoryModule } from '../case-history';
+import { EventMessageModule } from '../error-message/error-message.module';
+import { ErrorsModule } from '../error/errors.module';
+import { EventStartModule } from '../event-start/event-start.module';
+import { EventTriggerModule } from '../event-trigger';
+import { LoadingSpinnerModule } from '../loading-spinner/loading-spinner.module';
+import { PaletteModule } from '../palette';
+import { CaseBasicAccessViewComponent } from './case-basic-access-view';
+import { CaseChallengedAccessRequestComponent } from './case-challenged-access-request/case-challenged-access-request.component';
+import { CaseChallengedAccessSuccessComponent } from './case-challenged-access-success/case-challenged-access-success.component';
+import { CaseEventTriggerComponent } from './case-event-trigger';
+import { CaseFullAccessViewComponent } from './case-full-access-view/case-full-access-view.component';
+import { CaseReviewSpecificAccessRejectComponent } from './case-review-specific-access-reject';
+import { CaseReviewSpecificAccessRequestComponent } from './case-review-specific-access-request/case-review-specific-access-request.component';
+import { CaseSpecificAccessRequestComponent } from './case-specific-access-request/case-specific-access-request.component';
+import { CaseSpecificAccessSuccessComponent } from './case-specific-access-success/case-specific-access-success.component';
+import { CaseViewComponent } from './case-view';
+import { CaseViewerComponent } from './case-viewer.component';
+import { CasePrinterComponent, PrintUrlPipe } from './printer';
+import { CaseResolver, EventTriggerResolver } from './services';
+let CaseViewerModule = class CaseViewerModule {
+};
+CaseViewerModule = __decorate([
+    NgModule({
+        imports: [
+            CommonModule,
+            RouterModule,
+            ErrorsModule,
+            ActivityModule,
+            CaseHeaderModule,
+            EventStartModule,
+            EventTriggerModule,
+            PaletteModule,
+            CaseEditorModule,
+            ConditionalShowModule,
+            CaseHistoryModule,
+            MatTabsModule,
+            ReactiveFormsModule,
+            AlertModule,
+            LabelSubstitutorModule,
+            RpxTranslationModule.forChild(),
+            BannersModule,
+            LabelSubstitutorModule,
+            LoadingSpinnerModule,
+            EventMessageModule
+        ],
+        declarations: [
+            CaseEventTriggerComponent,
+            CasePrinterComponent,
+            CaseViewerComponent,
+            CaseFullAccessViewComponent,
+            CaseViewComponent,
+            CaseBasicAccessViewComponent,
+            PrintUrlPipe,
+            CaseChallengedAccessRequestComponent,
+            CaseSpecificAccessRequestComponent,
+            CaseReviewSpecificAccessRequestComponent,
+            CaseChallengedAccessSuccessComponent,
+            CaseSpecificAccessSuccessComponent,
+            CaseReviewSpecificAccessRejectComponent
+        ],
+        exports: [
+            CaseViewerComponent,
+            CaseViewComponent
+        ],
+        providers: [
+            CaseNotifier,
+            ConvertHrefToRouterService,
+            NavigationNotifierService,
+            CaseReferencePipe,
+            EventTriggerResolver,
+            ActivityService,
+            ActivityPollingService,
+            OrderService,
+            DraftService,
+            HttpService,
+            CaseResolver,
+            ErrorNotifierService
+        ]
+    })
+], CaseViewerModule);
+export { CaseViewerModule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"case-viewer.module.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/case-viewer/case-viewer.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { NgModule } from '@angular/core';\nimport { ReactiveFormsModule } from '@angular/forms';\nimport { MatLegacyTabsModule as MatTabsModule } from '@angular/material/legacy-tabs';\nimport { RouterModule } from '@angular/router';\nimport { RpxTranslationModule } from 'rpx-xui-translation';\nimport { AlertModule } from '../../../components/banners/alert/alert.module';\nimport { BannersModule } from '../../../components/banners/banners.module';\nimport { ConditionalShowModule, LabelSubstitutorModule } from '../../directives';\nimport { CaseReferencePipe } from '../../pipes';\nimport {\n  ActivityPollingService,\n  ActivityService,\n  DraftService,\n  ErrorNotifierService,\n  HttpService,\n  NavigationNotifierService,\n  OrderService\n} from '../../services';\nimport { ActivityModule } from '../activity';\nimport { CaseEditorModule, CaseNotifier, ConvertHrefToRouterService } from '../case-editor';\nimport { CaseHeaderModule } from '../case-header';\nimport { CaseHistoryModule } from '../case-history';\nimport { EventMessageModule } from '../error-message/error-message.module';\nimport { ErrorsModule } from '../error/errors.module';\nimport { EventStartModule } from '../event-start/event-start.module';\nimport { EventTriggerModule } from '../event-trigger';\nimport { LoadingSpinnerModule } from '../loading-spinner/loading-spinner.module';\nimport { PaletteModule } from '../palette';\nimport { CaseBasicAccessViewComponent } from './case-basic-access-view';\nimport { CaseChallengedAccessRequestComponent } from './case-challenged-access-request/case-challenged-access-request.component';\nimport { CaseChallengedAccessSuccessComponent } from './case-challenged-access-success/case-challenged-access-success.component';\nimport { CaseEventTriggerComponent } from './case-event-trigger';\nimport { CaseFullAccessViewComponent } from './case-full-access-view/case-full-access-view.component';\nimport { CaseReviewSpecificAccessRejectComponent } from './case-review-specific-access-reject';\nimport { CaseReviewSpecificAccessRequestComponent } from './case-review-specific-access-request/case-review-specific-access-request.component';\nimport { CaseSpecificAccessRequestComponent } from './case-specific-access-request/case-specific-access-request.component';\nimport { CaseSpecificAccessSuccessComponent } from './case-specific-access-success/case-specific-access-success.component';\nimport { CaseViewComponent } from './case-view';\nimport { CaseViewerComponent } from './case-viewer.component';\nimport { CasePrinterComponent, PrintUrlPipe } from './printer';\nimport { CaseResolver, EventTriggerResolver } from './services';\n\n@NgModule({\n  imports: [\n    CommonModule,\n    RouterModule,\n    ErrorsModule,\n    ActivityModule,\n    CaseHeaderModule,\n    EventStartModule,\n    EventTriggerModule,\n    PaletteModule,\n    CaseEditorModule,\n    ConditionalShowModule,\n    CaseHistoryModule,\n    MatTabsModule,\n    ReactiveFormsModule,\n    AlertModule,\n    LabelSubstitutorModule,\n    RpxTranslationModule.forChild(),\n    BannersModule,\n    LabelSubstitutorModule,\n    LoadingSpinnerModule,\n    EventMessageModule\n  ],\n  declarations: [\n    CaseEventTriggerComponent,\n    CasePrinterComponent,\n    CaseViewerComponent,\n    CaseFullAccessViewComponent,\n    CaseViewComponent,\n    CaseBasicAccessViewComponent,\n    PrintUrlPipe,\n    CaseChallengedAccessRequestComponent,\n    CaseSpecificAccessRequestComponent,\n    CaseReviewSpecificAccessRequestComponent,\n    CaseChallengedAccessSuccessComponent,\n    CaseSpecificAccessSuccessComponent,\n    CaseReviewSpecificAccessRejectComponent\n  ],\n  exports: [\n    CaseViewerComponent,\n    CaseViewComponent\n  ],\n  providers: [\n    CaseNotifier,\n    ConvertHrefToRouterService,\n    NavigationNotifierService,\n    CaseReferencePipe,\n    EventTriggerResolver,\n    ActivityService,\n    ActivityPollingService,\n    OrderService,\n    DraftService,\n    HttpService,\n    CaseResolver,\n    ErrorNotifierService\n  ]\n})\nexport class CaseViewerModule {\n}\n"]}

package/esm2022/lib/shared/components/case-viewer/printer/case-printer.component.mjs

@@ -0,0 +1,116 @@
+import { Component } from '@angular/core';
+import { throwError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { HttpError } from '../../../domain/http/http-error.model';
+import { AlertService } from '../../../services/alert/alert.service';
+import { CaseNotifier } from '../../case-editor/services/case.notifier';
+import { CasesService } from '../../case-editor/services/cases.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../case-editor/services/case.notifier";
+import * as i2 from "../../case-editor/services/cases.service";
+import * as i3 from "../../../services/alert/alert.service";
+function CasePrinterComponent_div_0_tr_16_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "tr")(1, "td", 4)(2, "a", 5);
+    i0.ɵɵpipe(3, "ccdPrintUrl");
+    i0.ɵɵtext(4);
+    i0.ɵɵpipe(5, "rpxTranslate");
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementStart(6, "td", 6);
+    i0.ɵɵtext(7);
+    i0.ɵɵpipe(8, "rpxTranslate");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const document_r2 = ctx.$implicit;
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("href", i0.ɵɵpipeBind1(3, 3, document_r2.url), i0.ɵɵsanitizeUrl);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(5, 5, document_r2.name), " ");
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(8, 7, document_r2.type));
+} }
+function CasePrinterComponent_div_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div");
+    i0.ɵɵelement(1, "ccd-case-header", 1);
+    i0.ɵɵelementStart(2, "h2", 2);
+    i0.ɵɵtext(3);
+    i0.ɵɵpipe(4, "rpxTranslate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(5, "table");
+    i0.ɵɵpipe(6, "rpxTranslate");
+    i0.ɵɵelementStart(7, "thead")(8, "tr")(9, "th");
+    i0.ɵɵtext(10);
+    i0.ɵɵpipe(11, "rpxTranslate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(12, "th");
+    i0.ɵɵtext(13);
+    i0.ɵɵpipe(14, "rpxTranslate");
+    i0.ɵɵelementEnd()()();
+    i0.ɵɵelementStart(15, "tbody");
+    i0.ɵɵtemplate(16, CasePrinterComponent_div_0_tr_16_Template, 9, 9, "tr", 3);
+    i0.ɵɵelementEnd()()();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("caseDetails", ctx_r0.caseDetails);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(4, 6, "Print"));
+    i0.ɵɵadvance(2);
+    i0.ɵɵattribute("aria-describedby", i0.ɵɵpipeBind1(6, 8, "case print table"));
+    i0.ɵɵadvance(5);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(11, 10, "Name"));
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(14, 12, "Type"));
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("ngForOf", ctx_r0.documents);
+} }
+export class CasePrinterComponent {
+    caseNotifier;
+    casesService;
+    alertService;
+    ERROR_MESSAGE = 'No documents to print';
+    caseDetails;
+    documents;
+    caseSubscription;
+    constructor(caseNotifier, casesService, alertService) {
+        this.caseNotifier = caseNotifier;
+        this.casesService = casesService;
+        this.alertService = alertService;
+    }
+    ngOnInit() {
+        this.caseSubscription = this.caseNotifier.caseView.subscribe(caseDetails => {
+            this.caseDetails = caseDetails;
+            this.casesService
+                .getPrintDocuments(this.caseDetails.case_id)
+                .pipe(map(documents => {
+                if (!documents || !documents.length) {
+                    const error = new HttpError();
+                    error.message = this.ERROR_MESSAGE;
+                    throw error;
+                }
+                this.documents = documents;
+            }), catchError(error => {
+                this.alertService.error(error.message);
+                return throwError(error);
+            })).toPromise();
+        });
+    }
+    ngOnDestroy() {
+        if (this.caseSubscription) {
+            this.caseSubscription.unsubscribe();
+        }
+    }
+    isDataLoaded() {
+        return this.caseDetails && this.documents ? true : false;
+    }
+    static ɵfac = function CasePrinterComponent_Factory(t) { return new (t || CasePrinterComponent)(i0.ɵɵdirectiveInject(i1.CaseNotifier), i0.ɵɵdirectiveInject(i2.CasesService), i0.ɵɵdirectiveInject(i3.AlertService)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: CasePrinterComponent, selectors: [["ng-component"]], decls: 1, vars: 1, consts: [[4, "ngIf"], [3, "caseDetails"], [1, "heading-h2"], [4, "ngFor", "ngForOf"], [1, "document-name"], ["target", "_blank", "rel", "external", 3, "href"], [1, "document-type"]], template: function CasePrinterComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, CasePrinterComponent_div_0_Template, 17, 14, "div", 0);
+        } if (rf & 2) {
+            i0.ɵɵproperty("ngIf", ctx.isDataLoaded());
+        } }, encapsulation: 2 });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CasePrinterComponent, [{
+        type: Component,
+        args: [{ template: "<div *ngIf=\"isDataLoaded()\">\n  <ccd-case-header [caseDetails]=\"caseDetails\"></ccd-case-header>\n  <h2 class=\"heading-h2\">{{'Print' | rpxTranslate}}</h2>\n  <table [attr.aria-describedby]=\"'case print table' | rpxTranslate\">\n    <thead>\n      <tr>\n        <th>{{'Name' | rpxTranslate}}</th>\n        <th>{{'Type' | rpxTranslate}}</th>\n      </tr>\n    </thead>\n    <tbody>\n      <tr *ngFor=\"let document of documents\">\n        <td class=\"document-name\"><a [href]=\"document.url | ccdPrintUrl\" target=\"_blank\" rel=\"external\">\n          {{document.name | rpxTranslate}}\n        </a></td>\n        <td class=\"document-type\">{{document.type | rpxTranslate}}</td>\n      </tr>\n    </tbody>\n  </table>\n</div>\n" }]
+    }], function () { return [{ type: i1.CaseNotifier }, { type: i2.CasesService }, { type: i3.AlertService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/components/case-viewer/printer/pipes/print-url.pipe.mjs

@@ -0,0 +1,61 @@
+import { Pipe } from '@angular/core';
+import { AbstractAppConfig } from '../../../../../app.config';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../app.config";
+export class PrintUrlPipe {
+    appConfig;
+    static MSIE_BROWSER_NAME = 'MSIE';
+    static IE11_BROWSER_ENGINE = 'Trident';
+    constructor(appConfig) {
+        this.appConfig = appConfig;
+    }
+    /**
+     * Takes a "remote" Print Service URL (for example, as returned by calling the `/documents` CCD endpoint) and
+     * rewrites it into a "local", application-specific URL for the front-end. The resulting URL is of the form:
+     *
+     * Configurable "Local URL" (e.g. `/print`) + _pathname_ from original "remote URL"
+     * (e.g. `/jurisdictions/TEST/case-types/Test1/cases/1111222233334444`)
+     *
+     * @param remoteUrl The "remote" URL to rewrite
+     * @returns A rewritten URL as per the above description, or the original `remoteUrl` if it is `null`, `undefined`,
+     * or the empty string
+     */
+    transform(remoteUrl) {
+        if (remoteUrl?.length > 0) {
+            let printServiceUrlPathname;
+            /**
+             * Check navigator.userAgent to see if the browser is IE or not. Check for either the browser name, "MSIE", or
+             * the rendering engine, "Trident" (used to identify IE 11 because it no longer reports as "MSIE").
+             * Note: IE does not support the URL interface and requires a workaround to parse URLs.
+             */
+            if (navigator.userAgent.indexOf(PrintUrlPipe.MSIE_BROWSER_NAME) !== -1 ||
+                navigator.userAgent.indexOf(PrintUrlPipe.IE11_BROWSER_ENGINE) !== -1) {
+                // Workaround for not being able to use the URL interface
+                const urlParser = document.createElement('a');
+                urlParser.href = remoteUrl;
+                // Get the pathname from the anchor element with the "remote" Print Service URL
+                printServiceUrlPathname = urlParser.pathname;
+                if (printServiceUrlPathname[0] !== '/') {
+                    // Fix for IE11; it returns the pathname without leading slash
+                    printServiceUrlPathname = `/${printServiceUrlPathname}`;
+                }
+            }
+            else {
+                // Get the pathname parsed from the "remote" Print Service URL object
+                printServiceUrlPathname = new URL(remoteUrl).pathname;
+            }
+            // Return an amended URL comprising the "local" Print Service URL (usually /print) and the "remote" pathname
+            return this.appConfig.getPrintServiceUrl() + printServiceUrlPathname;
+        }
+        return remoteUrl;
+    }
+    static ɵfac = function PrintUrlPipe_Factory(t) { return new (t || PrintUrlPipe)(i0.ɵɵdirectiveInject(i1.AbstractAppConfig, 16)); };
+    static ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "ccdPrintUrl", type: PrintUrlPipe, pure: true });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PrintUrlPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'ccdPrintUrl'
+            }]
+    }], function () { return [{ type: i1.AbstractAppConfig }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/components/case-viewer/services/case.resolver.mjs

@@ -0,0 +1,141 @@
+import { Injectable } from '@angular/core';
+import { NavigationEnd, Router } from '@angular/router';
+import { plainToClassFromExist } from 'class-transformer';
+import { of, throwError } from 'rxjs';
+import { catchError, filter, map } from 'rxjs/operators';
+import { AbstractAppConfig } from '../../../../app.config';
+import { CaseView, Draft } from '../../../domain';
+import { DraftService, NavigationOrigin, SessionStorageService } from '../../../services';
+import { NavigationNotifierService } from '../../../services/navigation/navigation-notifier.service';
+import { CaseNotifier } from '../../case-editor';
+import * as i0 from "@angular/core";
+import * as i1 from "../../case-editor";
+import * as i2 from "../../../services";
+import * as i3 from "../../../services/navigation/navigation-notifier.service";
+import * as i4 from "@angular/router";
+import * as i5 from "../../../../app.config";
+export class CaseResolver {
+    caseNotifier;
+    draftService;
+    navigationNotifierService;
+    router;
+    sessionStorage;
+    appConfig;
+    static EVENT_REGEX = new RegExp('\/trigger\/.*?\/submit$');
+    static PARAM_CASE_ID = 'cid';
+    static CASE_CREATED_MSG = 'The case has been created successfully';
+    static defaultWAPage = '/work/my-work/list';
+    static defaultPage = '/cases';
+    // we need to run the CaseResolver on every child route of 'case/:jid/:ctid/:cid'
+    // this is achieved with runGuardsAndResolvers: 'always' configuration
+    // we cache the case view to avoid retrieving it for each child route
+    previousUrl;
+    constructor(caseNotifier, draftService, navigationNotifierService, router, sessionStorage, appConfig) {
+        this.caseNotifier = caseNotifier;
+        this.draftService = draftService;
+        this.navigationNotifierService = navigationNotifierService;
+        this.router = router;
+        this.sessionStorage = sessionStorage;
+        this.appConfig = appConfig;
+        router.events.pipe(filter(event => event instanceof NavigationEnd))
+            .subscribe((event) => {
+            this.previousUrl = event.url;
+        });
+    }
+    resolve(route) {
+        const cid = route.paramMap.get(CaseResolver.PARAM_CASE_ID);
+        if (!cid) {
+            console.info('No case ID available in the route. Will navigate to case list.');
+            // when redirected to case view after a case created, and the user has no READ access,
+            // the post returns no id
+            this.navigateToCaseList();
+        }
+        else {
+            return this.isRootCaseViewRoute(route) ? this.getAndCacheCaseView(cid)
+                : this.caseNotifier.cachedCaseView ? Promise.resolve(this.caseNotifier.cachedCaseView)
+                    : this.getAndCacheCaseView(cid);
+        }
+    }
+    navigateToCaseList() {
+        this.navigationNotifierService.announceNavigation({ action: NavigationOrigin.NO_READ_ACCESS_REDIRECTION });
+    }
+    isRootCaseViewRoute(route) {
+        // is route case/:jid/:ctid/:cid
+        return ((!route.firstChild || !route.firstChild.url.length) && !this.isTabViewRoute(route));
+    }
+    isTabViewRoute(route) {
+        // is route case/:jid/:ctid/:cid#fragment
+        return route.firstChild && route.firstChild.fragment;
+    }
+    getAndCacheCaseView(cid) {
+        console.info('getAndCacheCaseView started.');
+        if (this.caseNotifier.cachedCaseView && this.caseNotifier.cachedCaseView.case_id && this.caseNotifier.cachedCaseView.case_id === cid) {
+            this.caseNotifier.announceCase(this.caseNotifier.cachedCaseView);
+            console.info('getAndCacheCaseView - Path A.');
+            return of(this.caseNotifier.cachedCaseView).toPromise();
+        }
+        else {
+            if (Draft.isDraft(cid)) {
+                return this.getAndCacheDraft(cid);
+            }
+            else {
+                console.info('getAndCacheCaseView - Path B.');
+                return this.caseNotifier.fetchAndRefresh(cid)
+                    .pipe(catchError(error => this.processErrorInCaseFetch(error, cid)))
+                    .toPromise();
+            }
+        }
+    }
+    getAndCacheDraft(cid) {
+        return this.draftService
+            .getDraft(cid)
+            .pipe(map(caseView => {
+            this.caseNotifier.cachedCaseView = plainToClassFromExist(new CaseView(), caseView);
+            this.caseNotifier.announceCase(this.caseNotifier.cachedCaseView);
+            return this.caseNotifier.cachedCaseView;
+        }), catchError(error => this.processErrorInCaseFetch(error, cid))).toPromise();
+    }
+    processErrorInCaseFetch(error, caseReference) {
+        console.error('!!! processErrorInCaseFetch !!!');
+        console.error(error);
+        // TODO Should be logged to remote logging infrastructure
+        if (error.status === 400) {
+            this.router.navigate(['/search/noresults']);
+            return of(null);
+        }
+        if (CaseResolver.EVENT_REGEX.test(this.previousUrl) && error.status === 404) {
+            this.router.navigate(['/list/case']);
+            return of(null);
+        }
+        // Error 403 and enable-restricted-case-access Launch Darkly flag is enabled, navigate to restricted case access page
+        if (error.status === 403 && this.appConfig.getEnableRestrictedCaseAccessConfig()) {
+            this.router.navigate([`/cases/restricted-case-access/${caseReference}`]);
+            return of(null);
+        }
+        if (error.status !== 401) {
+            this.router.navigate(['/error']);
+        }
+        this.goToDefaultPage();
+        return throwError(error);
+    }
+    // as discussed for EUI-5456, need functionality to go to default page
+    goToDefaultPage() {
+        console.info('Going to default page!');
+        const userDetails = JSON.parse(this.sessionStorage.getItem('userDetails'));
+        userDetails && userDetails.roles
+            && !userDetails.roles.includes('pui-case-manager')
+            &&
+                (userDetails.roles.includes('caseworker-ia-iacjudge')
+                    || userDetails.roles.includes('caseworker-ia-caseofficer')
+                    || userDetails.roles.includes('caseworker-ia-admofficer')
+                    || userDetails.roles.includes('caseworker-civil')
+                    || userDetails.roles.includes('caseworker-privatelaw'))
+            ? this.router.navigate([CaseResolver.defaultWAPage]) : this.router.navigate([CaseResolver.defaultPage]);
+    }
+    static ɵfac = function CaseResolver_Factory(t) { return new (t || CaseResolver)(i0.ɵɵinject(i1.CaseNotifier), i0.ɵɵinject(i2.DraftService), i0.ɵɵinject(i3.NavigationNotifierService), i0.ɵɵinject(i4.Router), i0.ɵɵinject(i2.SessionStorageService), i0.ɵɵinject(i5.AbstractAppConfig)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CaseResolver, factory: CaseResolver.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CaseResolver, [{
+        type: Injectable
+    }], function () { return [{ type: i1.CaseNotifier }, { type: i2.DraftService }, { type: i3.NavigationNotifierService }, { type: i4.Router }, { type: i2.SessionStorageService }, { type: i5.AbstractAppConfig }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"case.resolver.js","sourceRoot":"","sources":["../../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/case-viewer/services/case.resolver.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ActivatedRouteSnapshot, NavigationEnd, Resolve, Router } from '@angular/router';\nimport { plainToClassFromExist } from 'class-transformer';\nimport { of, throwError } from 'rxjs';\nimport { catchError, filter, map } from 'rxjs/operators';\nimport { AbstractAppConfig } from '../../../../app.config';\nimport { CaseView, Draft } from '../../../domain';\nimport { DraftService, NavigationOrigin, SessionStorageService } from '../../../services';\nimport { NavigationNotifierService } from '../../../services/navigation/navigation-notifier.service';\nimport { CaseNotifier } from '../../case-editor';\n\n@Injectable()\nexport class CaseResolver implements Resolve<CaseView> {\n  public static readonly EVENT_REGEX = new RegExp('\\/trigger\\/.*?\\/submit$');\n  public static readonly PARAM_CASE_ID = 'cid';\n  public static readonly CASE_CREATED_MSG = 'The case has been created successfully';\n\n  public static defaultWAPage = '/work/my-work/list';\n  public static defaultPage = '/cases';\n  // we need to run the CaseResolver on every child route of 'case/:jid/:ctid/:cid'\n  // this is achieved with runGuardsAndResolvers: 'always' configuration\n  // we cache the case view to avoid retrieving it for each child route\n  public previousUrl: string;\n  constructor(private caseNotifier: CaseNotifier,\n              private draftService: DraftService,\n              private navigationNotifierService: NavigationNotifierService,\n              private router: Router,\n              private sessionStorage: SessionStorageService,\n              private readonly appConfig: AbstractAppConfig) {\n    router.events.pipe(filter(event => event instanceof NavigationEnd))\n      .subscribe((event: NavigationEnd) => {\n        this.previousUrl = event.url;\n      });\n  }\n\n  public resolve(route: ActivatedRouteSnapshot): Promise<CaseView> {\n    const cid = route.paramMap.get(CaseResolver.PARAM_CASE_ID);\n\n    if (!cid) {\n      console.info('No case ID available in the route. Will navigate to case list.');\n      // when redirected to case view after a case created, and the user has no READ access,\n      // the post returns no id\n      this.navigateToCaseList();\n    } else {\n      return this.isRootCaseViewRoute(route) ? this.getAndCacheCaseView(cid)\n        : this.caseNotifier.cachedCaseView ? Promise.resolve(this.caseNotifier.cachedCaseView)\n        : this.getAndCacheCaseView(cid);\n    }\n  }\n\n  private navigateToCaseList() {\n    this.navigationNotifierService.announceNavigation({action: NavigationOrigin.NO_READ_ACCESS_REDIRECTION});\n  }\n\n  private isRootCaseViewRoute(route: ActivatedRouteSnapshot) {\n    // is route case/:jid/:ctid/:cid\n    return ((!route.firstChild || !route.firstChild.url.length) && !this.isTabViewRoute(route));\n  }\n\n  private isTabViewRoute(route: ActivatedRouteSnapshot) {\n    // is route case/:jid/:ctid/:cid#fragment\n    return route.firstChild && route.firstChild.fragment;\n  }\n\n  private getAndCacheCaseView(cid): Promise<CaseView> {\n    console.info('getAndCacheCaseView started.');\n    if (this.caseNotifier.cachedCaseView && this.caseNotifier.cachedCaseView.case_id && this.caseNotifier.cachedCaseView.case_id === cid) {\n      this.caseNotifier.announceCase(this.caseNotifier.cachedCaseView);\n      console.info('getAndCacheCaseView - Path A.');\n      return of(this.caseNotifier.cachedCaseView).toPromise();\n    } else {\n      if (Draft.isDraft(cid)) {\n        return this.getAndCacheDraft(cid);\n      } else {\n      console.info('getAndCacheCaseView - Path B.');\n        return this.caseNotifier.fetchAndRefresh(cid)\n          .pipe(catchError(error => this.processErrorInCaseFetch(error, cid)))\n          .toPromise();\n      }\n    }\n  }\n\n  private getAndCacheDraft(cid): Promise<CaseView> {\n      return this.draftService\n      .getDraft(cid)\n      .pipe(\n        map(caseView => {\n          this.caseNotifier.cachedCaseView = plainToClassFromExist(new CaseView(), caseView);\n          this.caseNotifier.announceCase(this.caseNotifier.cachedCaseView);\n          return this.caseNotifier.cachedCaseView;\n        }),\n        catchError(error => this.processErrorInCaseFetch(error, cid))\n      ).toPromise();\n  }\n\n  private processErrorInCaseFetch(error: any, caseReference: string) {\n    console.error('!!! processErrorInCaseFetch !!!');\n    console.error(error);\n    // TODO Should be logged to remote logging infrastructure\n    if (error.status === 400) {\n      this.router.navigate(['/search/noresults']);\n      return of(null);\n    }\n    if (CaseResolver.EVENT_REGEX.test(this.previousUrl) && error.status === 404) {\n      this.router.navigate(['/list/case']);\n      return of(null);\n    }\n    // Error 403 and enable-restricted-case-access Launch Darkly flag is enabled, navigate to restricted case access page\n    if (error.status === 403 && this.appConfig.getEnableRestrictedCaseAccessConfig()) {\n      this.router.navigate([`/cases/restricted-case-access/${caseReference}`]);\n      return of(null);\n    }\n    if (error.status !== 401) {\n      this.router.navigate(['/error']);\n    }\n    this.goToDefaultPage();\n    return throwError(error);\n  }\n\n  // as discussed for EUI-5456, need functionality to go to default page\n  private goToDefaultPage(): void {\n    console.info('Going to default page!');\n    const userDetails = JSON.parse(this.sessionStorage.getItem('userDetails'));\n    userDetails && userDetails.roles\n        && !userDetails.roles.includes('pui-case-manager')\n        &&\n        (userDetails.roles.includes('caseworker-ia-iacjudge')\n          || userDetails.roles.includes('caseworker-ia-caseofficer')\n          || userDetails.roles.includes('caseworker-ia-admofficer')\n          || userDetails.roles.includes('caseworker-civil')\n          || userDetails.roles.includes('caseworker-privatelaw'))\n        ? this.router.navigate([CaseResolver.defaultWAPage]) : this.router.navigate([CaseResolver.defaultPage]);\n  }\n}\n"]}

package/esm2022/lib/shared/components/case-viewer/services/event-trigger.resolver.mjs

@@ -0,0 +1,70 @@
+import { Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { AlertService } from '../../../services/alert/alert.service';
+import { ProfileNotifier } from '../../../services/profile/profile.notifier';
+import { ProfileService } from '../../../services/profile/profile.service';
+import { CasesService } from '../../case-editor/services/cases.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../case-editor/services/cases.service";
+import * as i2 from "../../../services/alert/alert.service";
+import * as i3 from "../../../services/profile/profile.service";
+import * as i4 from "../../../services/profile/profile.notifier";
+export class EventTriggerResolver {
+    casesService;
+    alertService;
+    profileService;
+    profileNotifier;
+    static PARAM_CASE_ID = 'cid';
+    static PARAM_EVENT_ID = 'eid';
+    static IGNORE_WARNING = 'ignoreWarning';
+    static IGNORE_WARNING_VALUES = ['true', 'false'];
+    cachedEventTrigger;
+    cachedProfile;
+    constructor(casesService, alertService, profileService, profileNotifier) {
+        this.casesService = casesService;
+        this.alertService = alertService;
+        this.profileService = profileService;
+        this.profileNotifier = profileNotifier;
+    }
+    resolve(route) {
+        return this.isRootTriggerEventRoute(route) ? this.getAndCacheEventTrigger(route)
+            : this.cachedEventTrigger ? Promise.resolve(this.cachedEventTrigger)
+                : this.getAndCacheEventTrigger(route);
+    }
+    isRootTriggerEventRoute(route) {
+        // if route is 'trigger/:eid'
+        return !route.firstChild || !route.firstChild.url.length;
+    }
+    getAndCacheEventTrigger(route) {
+        const cid = route.parent.paramMap.get(EventTriggerResolver.PARAM_CASE_ID);
+        // tslint:disable-next-line: prefer-const
+        let caseTypeId;
+        const eventTriggerId = route.paramMap.get(EventTriggerResolver.PARAM_EVENT_ID);
+        let ignoreWarning = route.queryParamMap.get(EventTriggerResolver.IGNORE_WARNING);
+        if (-1 === EventTriggerResolver.IGNORE_WARNING_VALUES.indexOf(ignoreWarning)) {
+            ignoreWarning = 'false';
+        }
+        if (this.cachedProfile) {
+            this.profileNotifier.announceProfile(this.cachedProfile);
+        }
+        else {
+            this.profileService.get().subscribe(profile => {
+                this.cachedProfile = profile;
+                this.profileNotifier.announceProfile(profile);
+            });
+        }
+        return this.casesService
+            .getEventTrigger(caseTypeId, eventTriggerId, cid, ignoreWarning)
+            .pipe(map(eventTrigger => this.cachedEventTrigger = eventTrigger), catchError(error => {
+            this.alertService.error(error.message);
+            return throwError(error);
+        })).toPromise();
+    }
+    static ɵfac = function EventTriggerResolver_Factory(t) { return new (t || EventTriggerResolver)(i0.ɵɵinject(i1.CasesService), i0.ɵɵinject(i2.AlertService), i0.ɵɵinject(i3.ProfileService), i0.ɵɵinject(i4.ProfileNotifier)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: EventTriggerResolver, factory: EventTriggerResolver.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EventTriggerResolver, [{
+        type: Injectable
+    }], function () { return [{ type: i1.CasesService }, { type: i2.AlertService }, { type: i3.ProfileService }, { type: i4.ProfileNotifier }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/components/create-case-filters/create-case-filters-selection.model.mjs

@@ -0,0 +1,11 @@
+export class CreateCaseFiltersSelection {
+    jurisdictionId;
+    caseTypeId;
+    eventId;
+    constructor() {
+        this.jurisdictionId = 'TEST',
+            this.caseTypeId = 'TestAddressBookCase',
+            this.eventId = 'startCase';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLWNhc2UtZmlsdGVycy1zZWxlY3Rpb24ubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL2NvbXBvbmVudHMvY3JlYXRlLWNhc2UtZmlsdGVycy9jcmVhdGUtY2FzZS1maWx0ZXJzLXNlbGVjdGlvbi5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sMEJBQTBCO0lBQzVCLGNBQWMsQ0FBUztJQUN2QixVQUFVLENBQVM7SUFDbkIsT0FBTyxDQUFTO0lBRXZCO1FBQ0ksSUFBSSxDQUFDLGNBQWMsR0FBRyxNQUFNO1lBQzVCLElBQUksQ0FBQyxVQUFVLEdBQUcscUJBQXFCO1lBQ3ZDLElBQUksQ0FBQyxPQUFPLEdBQUcsV0FBVyxDQUFDO0lBQy9CLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBDcmVhdGVDYXNlRmlsdGVyc1NlbGVjdGlvbiB7XG4gICAgcHVibGljIGp1cmlzZGljdGlvbklkOiBzdHJpbmc7XG4gICAgcHVibGljIGNhc2VUeXBlSWQ6IHN0cmluZztcbiAgICBwdWJsaWMgZXZlbnRJZDogc3RyaW5nO1xuXG4gICAgY29uc3RydWN0b3IoKSB7XG4gICAgICAgIHRoaXMuanVyaXNkaWN0aW9uSWQgPSAnVEVTVCcsXG4gICAgICAgIHRoaXMuY2FzZVR5cGVJZCA9ICdUZXN0QWRkcmVzc0Jvb2tDYXNlJyxcbiAgICAgICAgdGhpcy5ldmVudElkID0gJ3N0YXJ0Q2FzZSc7XG4gICAgfVxufVxuIl19