@hmcts/ccd-case-ui-toolkit 7.0.36-angular-upgrade → 7.0.36-exui-1717-rc1

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

@@ -0,0 +1,110 @@
+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 {
+    constructor(caseNotifier, casesService, alertService) {
+        this.caseNotifier = caseNotifier;
+        this.casesService = casesService;
+        this.alertService = alertService;
+        this.ERROR_MESSAGE = 'No documents to print';
+    }
+    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;
+    }
+}
+CasePrinterComponent.ɵfac = function CasePrinterComponent_Factory(t) { return new (t || CasePrinterComponent)(i0.ɵɵdirectiveInject(i1.CaseNotifier), i0.ɵɵdirectiveInject(i2.CasesService), i0.ɵɵdirectiveInject(i3.AlertService)); };
+CasePrinterComponent.ɵ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/esm2020/lib/shared/components/case-viewer/printer/pipes/print-url.pipe.mjs

@@ -0,0 +1,60 @@
+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 {
+    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;
+    }
+}
+PrintUrlPipe.MSIE_BROWSER_NAME = 'MSIE';
+PrintUrlPipe.IE11_BROWSER_ENGINE = 'Trident';
+PrintUrlPipe.ɵfac = function PrintUrlPipe_Factory(t) { return new (t || PrintUrlPipe)(i0.ɵɵdirectiveInject(i1.AbstractAppConfig, 16)); };
+PrintUrlPipe.ɵ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/esm2020/lib/shared/components/case-viewer/services/case.resolver.mjs

@@ -0,0 +1,128 @@
+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 {
+    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) {
+        if (this.caseNotifier.cachedCaseView && this.caseNotifier.cachedCaseView.case_id && this.caseNotifier.cachedCaseView.case_id === cid) {
+            this.caseNotifier.announceCase(this.caseNotifier.cachedCaseView);
+            return of(this.caseNotifier.cachedCaseView).toPromise();
+        }
+        else {
+            if (Draft.isDraft(cid)) {
+                return this.getAndCacheDraft(cid);
+            }
+            else {
+                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]);
+    }
+}
+CaseResolver.EVENT_REGEX = new RegExp('\/trigger\/.*?\/submit$');
+CaseResolver.PARAM_CASE_ID = 'cid';
+CaseResolver.CASE_CREATED_MSG = 'The case has been created successfully';
+CaseResolver.defaultWAPage = '/work/my-work/list';
+CaseResolver.defaultPage = '/cases';
+CaseResolver.ɵ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)); };
+CaseResolver.ɵ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    if (this.caseNotifier.cachedCaseView && this.caseNotifier.cachedCaseView.case_id && this.caseNotifier.cachedCaseView.case_id === cid) {\n      this.caseNotifier.announceCase(this.caseNotifier.cachedCaseView);\n      return of(this.caseNotifier.cachedCaseView).toPromise();\n    } else {\n      if (Draft.isDraft(cid)) {\n        return this.getAndCacheDraft(cid);\n      } else {\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/esm2020/lib/shared/components/case-viewer/services/event-trigger.resolver.mjs

@@ -0,0 +1,64 @@
+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 {
+    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();
+    }
+}
+EventTriggerResolver.PARAM_CASE_ID = 'cid';
+EventTriggerResolver.PARAM_EVENT_ID = 'eid';
+EventTriggerResolver.IGNORE_WARNING = 'ignoreWarning';
+EventTriggerResolver.IGNORE_WARNING_VALUES = ['true', 'false'];
+EventTriggerResolver.ɵ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)); };
+EventTriggerResolver.ɵ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/esm2020/lib/shared/components/create-case-filters/create-case-filters-selection.model.mjs

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