@hmcts/ccd-case-ui-toolkit 7.0.30 → 7.0.31-angular-upgrade

package/esm2022/lib/shared/components/case-editor/services/work-allocation.service.mjs

@@ -0,0 +1,215 @@
+import { Injectable } from '@angular/core';
+import { of, throwError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { AbstractAppConfig } from '../../../../app.config';
+import { AlertService, HttpErrorService, HttpService, SessionStorageService } from '../../../services';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services";
+import * as i2 from "../../../../app.config";
+export const MULTIPLE_TASKS_FOUND = 'More than one task found!';
+export class WorkAllocationService {
+    http;
+    appConfig;
+    errorService;
+    alertService;
+    sessionStorageService;
+    static iACCaseOfficer = 'caseworker-ia-caseofficer';
+    static iACAdmOfficer = 'caseworker-ia-admofficer';
+    features;
+    constructor(http, appConfig, errorService, alertService, sessionStorageService) {
+        this.http = http;
+        this.appConfig = appConfig;
+        this.errorService = errorService;
+        this.alertService = alertService;
+        this.sessionStorageService = sessionStorageService;
+        // Check to see if work allocation is enabled
+    }
+    /**
+     * Call the API to get tasks matching the search criteria.
+     * @param searchRequest The search parameters that specify which tasks to match.
+     */
+    searchTasks(searchRequest) {
+        // Do not need to check if WA enabled as parent method will do that
+        const url = `${this.appConfig.getWorkAllocationApiUrl()}/searchForCompletable`;
+        return this.http
+            .post(url, { searchRequest }, null, false)
+            .pipe(map(response => response), catchError(error => {
+            this.errorService.setError(error);
+            // explicitly eat away 401 error and 400 error
+            if (error && error.status && (error.status === 401 || error.status === 400)) {
+                // do nothing
+                console.log('error status 401 or 400', error);
+            }
+            else {
+                return throwError(error);
+            }
+        }));
+    }
+    isWAEnabled(jurisdiction, caseType) {
+        this.features = this.appConfig.getWAServiceConfig();
+        let enabled = false;
+        if (!jurisdiction || !caseType) {
+            const caseInfo = JSON.parse(this.sessionStorageService.getItem('caseInfo'));
+            jurisdiction = caseInfo.jurisdiction;
+            caseType = caseInfo.caseType;
+        }
+        if (!this.features || !this.features.configurations) {
+            return false;
+        }
+        this.features.configurations.forEach(serviceConfig => {
+            if (serviceConfig.serviceName === jurisdiction && (serviceConfig.caseTypes.indexOf(caseType) !== -1)) {
+                enabled = true;
+            }
+        });
+        return enabled;
+    }
+    /**
+     * Call the API to assign a task.
+     * @param taskId specifies which task should be assigned.
+     * @param userId specifies the user the task should be assigned to.
+     */
+    assignTask(taskId, userId) {
+        if (!this.isWAEnabled()) {
+            return of(null);
+        }
+        const url = `${this.appConfig.getWorkAllocationApiUrl()}/task/${taskId}/assign`;
+        return this.http
+            .post(url, { userId })
+            .pipe(catchError(error => {
+            this.errorService.setError(error);
+            return throwError(error);
+        }));
+    }
+    /**
+     * Call the API to complete a task.
+     * @param taskId specifies which task should be completed.
+     */
+    completeTask(taskId) {
+        if (!this.isWAEnabled()) {
+            return of(null);
+        }
+        const url = `${this.appConfig.getWorkAllocationApiUrl()}/task/${taskId}/complete`;
+        return this.http
+            .post(url, {})
+            .pipe(catchError(error => {
+            this.errorService.setError(error);
+            // this will subscribe to get the user details and decide whether to display an error message
+            this.http.get(this.appConfig.getUserInfoApiUrl()).pipe(map(response => response)).subscribe((response) => {
+                this.handleTaskCompletionError(response);
+            });
+            return throwError(error);
+        }));
+    }
+    /**
+     * Call the API to assign and complete a task.
+     * @param taskId specifies which task should be completed.
+     */
+    assignAndCompleteTask(taskId) {
+        if (!this.isWAEnabled()) {
+            return of(null);
+        }
+        const url = `${this.appConfig.getWorkAllocationApiUrl()}/task/${taskId}/complete`;
+        return this.http
+            .post(url, {
+            completion_options: {
+                assign_and_complete: true
+            }
+        })
+            .pipe(catchError(error => {
+            this.errorService.setError(error);
+            // this will subscribe to get the user details and decide whether to display an error message
+            this.http.get(this.appConfig.getUserInfoApiUrl()).pipe(map(response => response)).subscribe((response) => {
+                this.handleTaskCompletionError(response);
+            });
+            return throwError(error);
+        }));
+    }
+    /**
+     * Handles the response from the observable to get the user details when task is completed.
+     * @param response is the response given from the observable which contains the user detaild.
+     */
+    handleTaskCompletionError(response) {
+        const userDetails = response;
+        if (this.userIsCaseworker(userDetails.userInfo.roles)) {
+            // when submitting the completion of task if not yet rendered cases/case confirm then preserve the alert for re-rendering
+            this.alertService.setPreserveAlerts(true, ['cases/case', 'submit']);
+            this.alertService.warning({ phrase: 'A task could not be completed successfully. Please complete the task associated with the case manually.' });
+        }
+    }
+    /**
+     * Returns true if the user's role is equivalent to a caseworker.
+     * @param roles is the list of roles found from the current user.
+     */
+    userIsCaseworker(roles) {
+        const lowerCaseRoles = roles.map(role => role.toLowerCase());
+        // When/if lib & target permanently change to es2016, replace indexOf with includes
+        return (lowerCaseRoles.indexOf(WorkAllocationService.iACCaseOfficer) !== -1)
+            || (lowerCaseRoles.indexOf(WorkAllocationService.iACAdmOfficer) !== -1);
+    }
+    /**
+     * Look for open tasks for a case and event combination. There are 5 possible scenarios:
+     *   1. No tasks found                              => Success.
+     *   2. One task found => Mark as done              => Success.
+     *   3. One task found => Mark as done throws error => Failure.
+     *   4. More than one task found                    => Failure.
+     *   5. Search call throws an error                 => Failure.
+     * @param ccdId The ID of the case to find tasks for.
+     * @param eventId The ID of the event to find tasks for.
+     */
+    completeAppropriateTask(ccdId, eventId, jurisdiction, caseTypeId) {
+        if (!this.isWAEnabled(jurisdiction, caseTypeId)) {
+            return of(null);
+        }
+        const taskSearchParameter = {
+            ccdId,
+            eventId,
+            jurisdiction,
+            caseTypeId
+        };
+        return this.searchTasks(taskSearchParameter)
+            .pipe(map((response) => {
+            const tasks = response.tasks;
+            if (tasks && tasks.length > 0) {
+                if (tasks.length === 1) {
+                    this.completeTask(tasks[0].id).subscribe();
+                }
+                else {
+                    // This is a problem. Throw an appropriate error.
+                    throw new Error(MULTIPLE_TASKS_FOUND);
+                }
+            }
+            return true; // All good. Nothing to see here.
+        }), catchError(error => {
+            // Simply rethrow it.
+            return throwError(error);
+        }));
+    }
+    /**
+     * Return tasks for case and event.
+     */
+    getTasksByCaseIdAndEventId(eventId, caseId, caseType, jurisdiction) {
+        const defaultPayload = {
+            task_required_for_event: false,
+            tasks: []
+        };
+        if (!this.isWAEnabled()) {
+            return of(defaultPayload);
+        }
+        return this.http.get(`${this.appConfig.getWorkAllocationApiUrl()}/case/tasks/${caseId}/event/${eventId}/caseType/${caseType}/jurisdiction/${jurisdiction}`);
+    }
+    /**
+     * Call the API to get a task
+     */
+    getTask(taskId) {
+        if (!this.isWAEnabled()) {
+            return of({ task: null });
+        }
+        return this.http.get(`${this.appConfig.getWorkAllocationApiUrl()}/task/${taskId}`);
+    }
+    static ɵfac = function WorkAllocationService_Factory(t) { return new (t || WorkAllocationService)(i0.ɵɵinject(i1.HttpService), i0.ɵɵinject(i2.AbstractAppConfig), i0.ɵɵinject(i1.HttpErrorService), i0.ɵɵinject(i1.AlertService), i0.ɵɵinject(i1.SessionStorageService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WorkAllocationService, factory: WorkAllocationService.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WorkAllocationService, [{
+        type: Injectable
+    }], () => [{ type: i1.HttpService }, { type: i2.AbstractAppConfig }, { type: i1.HttpErrorService }, { type: i1.AlertService }, { type: i1.SessionStorageService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"work-allocation.service.js","sourceRoot":"","sources":["../../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/case-editor/services/work-allocation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable, of, throwError } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport { AbstractAppConfig } from '../../../../app.config';\nimport { TaskSearchParameter, WAFeatureConfig } from '../../../domain';\nimport { UserDetails } from '../../../domain/user/user-details.model';\nimport { TaskRespone } from '../../../domain/work-allocation/task-response.model';\nimport { TaskPayload } from '../../../domain/work-allocation/TaskPayload';\nimport { AlertService, HttpErrorService, HttpService, SessionStorageService } from '../../../services';\n\nexport const MULTIPLE_TASKS_FOUND = 'More than one task found!';\n\n@Injectable()\nexport class WorkAllocationService {\n  public static iACCaseOfficer = 'caseworker-ia-caseofficer';\n  public static iACAdmOfficer = 'caseworker-ia-admofficer';\n\n  private features: WAFeatureConfig;\n\n  constructor(\n    private readonly http: HttpService,\n    private readonly appConfig: AbstractAppConfig,\n    private readonly errorService: HttpErrorService,\n    private readonly alertService: AlertService,\n    private readonly sessionStorageService: SessionStorageService\n  ) {\n    // Check to see if work allocation is enabled\n  }\n\n  /**\n   * Call the API to get tasks matching the search criteria.\n   * @param searchRequest The search parameters that specify which tasks to match.\n   */\n  public searchTasks(searchRequest: TaskSearchParameter): Observable<object> {\n    // Do not need to check if WA enabled as parent method will do that\n    const url = `${this.appConfig.getWorkAllocationApiUrl()}/searchForCompletable`;\n    return this.http\n      .post(url, {searchRequest}, null, false)\n      .pipe(\n        map(response => response),\n        catchError(error => {\n          this.errorService.setError(error);\n          // explicitly eat away 401 error and 400 error\n          if (error && error.status && (error.status === 401 || error.status === 400)) {\n            // do nothing\n            console.log('error status 401 or 400', error);\n          } else {\n            return throwError(error);\n          }\n        })\n      );\n  }\n\n  private isWAEnabled(jurisdiction?: string, caseType?: string): boolean {\n    this.features = this.appConfig.getWAServiceConfig();\n    let enabled = false;\n    if (!jurisdiction || !caseType) {\n      const caseInfo = JSON.parse(this.sessionStorageService.getItem('caseInfo'));\n      jurisdiction = caseInfo.jurisdiction;\n      caseType = caseInfo.caseType;\n    }\n    if (!this.features || !this.features.configurations) {\n      return false;\n    }\n    this.features.configurations.forEach(serviceConfig => {\n      if (serviceConfig.serviceName === jurisdiction && (serviceConfig.caseTypes.indexOf(caseType) !== -1)) {\n          enabled = true;\n      }\n    });\n    return enabled;\n  }\n\n  /**\n   * Call the API to assign a task.\n   * @param taskId specifies which task should be assigned.\n   * @param userId specifies the user the task should be assigned to.\n   */\n  public assignTask(taskId: string, userId: string): Observable<any> {\n    if (!this.isWAEnabled()) {\n      return of(null);\n    }\n    const url = `${this.appConfig.getWorkAllocationApiUrl()}/task/${taskId}/assign`;\n    return this.http\n      .post(url, {userId})\n      .pipe(\n        catchError(error => {\n          this.errorService.setError(error);\n          return throwError(error);\n        })\n      );\n  }\n\n  /**\n   * Call the API to complete a task.\n   * @param taskId specifies which task should be completed.\n   */\n  public completeTask(taskId: string): Observable<any> {\n    if (!this.isWAEnabled()) {\n      return of(null);\n    }\n    const url = `${this.appConfig.getWorkAllocationApiUrl()}/task/${taskId}/complete`;\n    return this.http\n      .post(url, {})\n      .pipe(\n        catchError(error => {\n          this.errorService.setError(error);\n          // this will subscribe to get the user details and decide whether to display an error message\n          this.http.get(this.appConfig.getUserInfoApiUrl()).pipe(map(response => response)).subscribe((response) => {\n            this.handleTaskCompletionError(response);\n          });\n          return throwError(error);\n        })\n      );\n  }\n\n  /**\n   * Call the API to assign and complete a task.\n   * @param taskId specifies which task should be completed.\n   */\n  public assignAndCompleteTask(taskId: string): Observable<any> {\n    if (!this.isWAEnabled()) {\n      return of(null);\n    }\n    const url = `${this.appConfig.getWorkAllocationApiUrl()}/task/${taskId}/complete`;\n    return this.http\n      .post(url, {\n        completion_options: {\n          assign_and_complete: true\n        }\n      })\n      .pipe(\n        catchError(error => {\n          this.errorService.setError(error);\n          // this will subscribe to get the user details and decide whether to display an error message\n          this.http.get(this.appConfig.getUserInfoApiUrl()).pipe(map(response => response)).subscribe((response) => {\n            this.handleTaskCompletionError(response);\n          });\n          return throwError(error);\n        })\n      );\n  }\n\n  /**\n   * Handles the response from the observable to get the user details when task is completed.\n   * @param response is the response given from the observable which contains the user detaild.\n   */\n  public handleTaskCompletionError(response: any): void {\n    const userDetails = response as UserDetails;\n    if (this.userIsCaseworker(userDetails.userInfo.roles)) {\n      // when submitting the completion of task if not yet rendered cases/case confirm then preserve the alert for re-rendering\n      this.alertService.setPreserveAlerts(true, ['cases/case', 'submit']);\n      this.alertService.warning({ phrase:'A task could not be completed successfully. Please complete the task associated with the case manually.'});\n    }\n  }\n\n  /**\n   * Returns true if the user's role is equivalent to a caseworker.\n   * @param roles is the list of roles found from the current user.\n   */\n  public userIsCaseworker(roles: string[]): boolean {\n    const lowerCaseRoles = roles.map(role => role.toLowerCase());\n    // When/if lib & target permanently change to es2016, replace indexOf with includes\n    return (lowerCaseRoles.indexOf(WorkAllocationService.iACCaseOfficer) !== -1)\n      || (lowerCaseRoles.indexOf(WorkAllocationService.iACAdmOfficer) !== -1);\n  }\n\n  /**\n   * Look for open tasks for a case and event combination. There are 5 possible scenarios:\n   *   1. No tasks found                              => Success.\n   *   2. One task found => Mark as done              => Success.\n   *   3. One task found => Mark as done throws error => Failure.\n   *   4. More than one task found                    => Failure.\n   *   5. Search call throws an error                 => Failure.\n   * @param ccdId The ID of the case to find tasks for.\n   * @param eventId The ID of the event to find tasks for.\n   */\n  public completeAppropriateTask(ccdId: string, eventId: string, jurisdiction: string, caseTypeId: string): Observable<any> {\n    if (!this.isWAEnabled(jurisdiction, caseTypeId)) {\n      return of(null);\n    }\n    const taskSearchParameter: TaskSearchParameter = {\n      ccdId,\n      eventId,\n      jurisdiction,\n      caseTypeId\n    };\n    return this.searchTasks(taskSearchParameter)\n      .pipe(\n        map((response: any) => {\n          const tasks: any[] = response.tasks;\n          if (tasks && tasks.length > 0) {\n            if (tasks.length === 1) {\n              this.completeTask(tasks[0].id).subscribe();\n            } else {\n              // This is a problem. Throw an appropriate error.\n              throw new Error(MULTIPLE_TASKS_FOUND);\n            }\n          }\n          return true; // All good. Nothing to see here.\n        }),\n        catchError(error => {\n          // Simply rethrow it.\n          return throwError(error);\n        })\n      );\n  }\n\n  /**\n   * Return tasks for case and event.\n   */\n  public getTasksByCaseIdAndEventId(eventId: string, caseId: string, caseType: string, jurisdiction: string): Observable<TaskPayload> {\n    const defaultPayload: TaskPayload = {\n      task_required_for_event: false,\n      tasks: []\n    };\n    if (!this.isWAEnabled()) {\n      return of(defaultPayload);\n    }\n    return this.http.get(`${this.appConfig.getWorkAllocationApiUrl()}/case/tasks/${caseId}/event/${eventId}/caseType/${caseType}/jurisdiction/${jurisdiction}`);\n  }\n\n /**\n  * Call the API to get a task\n  */\n public getTask(taskId: string): Observable<TaskRespone> {\n  if (!this.isWAEnabled()) {\n    return of({task: null});\n  }\n  return this.http.get(`${this.appConfig.getWorkAllocationApiUrl()}/task/${taskId}`);\n }\n}\n"]}

package/esm2022/lib/shared/components/case-header/case-header.component.mjs

@@ -0,0 +1,64 @@
+import { Component, Input } from '@angular/core';
+import { CaseView } from '../../domain/case-view/case-view.model';
+import { CaseField } from '../../domain/definition/case-field.model';
+import { Draft } from '../../domain/draft.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../palette/label/label-field.component";
+import * as i3 from "../../pipes/case-reference/case-reference.pipe";
+function CaseHeaderComponent_h1_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "h1", 2);
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "ccdCaseReference");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate1("#", i0.ɵɵpipeBind1(2, 1, ctx_r0.caseDetails.case_id), "");
+} }
+function CaseHeaderComponent_div_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 3);
+    i0.ɵɵelement(1, "ccd-label-field", 4);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("caseField", ctx_r0.caseTitle)("caseFields", ctx_r0.caseFields);
+} }
+export class CaseHeaderComponent {
+    caseDetails;
+    caseTitle;
+    caseFields;
+    ngOnInit() {
+        this.caseTitle = new CaseField();
+        if (!this.isDraft() && this.caseDetails.state.title_display) {
+            this.caseTitle.label = this.caseDetails.state.title_display;
+            this.caseFields = this.getCaseFields();
+        }
+    }
+    isDraft() {
+        return Draft.isDraft(this.caseDetails.case_id);
+    }
+    getCaseFields() {
+        const caseDataFields = this.caseDetails.tabs.reduce((acc, tab) => {
+            return acc.concat(tab.fields);
+        }, []);
+        return caseDataFields.concat(this.caseDetails.metadataFields);
+    }
+    static ɵfac = function CaseHeaderComponent_Factory(t) { return new (t || CaseHeaderComponent)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: CaseHeaderComponent, selectors: [["ccd-case-header"]], inputs: { caseDetails: "caseDetails" }, decls: 2, vars: 2, consts: [["class", "heading-h1", 4, "ngIf"], ["class", "case-title", 4, "ngIf"], [1, "heading-h1"], [1, "case-title"], [3, "caseField", "caseFields"]], template: function CaseHeaderComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, CaseHeaderComponent_h1_0_Template, 3, 3, "h1", 0)(1, CaseHeaderComponent_div_1_Template, 2, 2, "div", 1);
+        } if (rf & 2) {
+            i0.ɵɵproperty("ngIf", !ctx.caseTitle.label);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("ngIf", ctx.caseTitle.label);
+        } }, dependencies: [i1.NgIf, i2.LabelFieldComponent, i3.CaseReferencePipe], styles: [".case-title[_ngcontent-%COMP%]{margin-top:47px;margin-bottom:10px}.heading-h1[_ngcontent-%COMP%]{margin-top:40px}"] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CaseHeaderComponent, [{
+        type: Component,
+        args: [{ selector: 'ccd-case-header', template: "<h1 *ngIf=\"!caseTitle.label\" class=\"heading-h1\">#{{ caseDetails.case_id | ccdCaseReference}}</h1>\n\n<div *ngIf=\"caseTitle.label\" class=\"case-title\">\n  <ccd-label-field [caseField]=\"caseTitle\" [caseFields]=\"caseFields\"></ccd-label-field>\n</div>\n", styles: [".case-title{margin-top:47px;margin-bottom:10px}.heading-h1{margin-top:40px}\n"] }]
+    }], null, { caseDetails: [{
+            type: Input
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(CaseHeaderComponent, { className: "CaseHeaderComponent", filePath: "lib/shared/components/case-header/case-header.component.ts", lineNumber: 12 }); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,33 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { PaletteModule } from '../palette';
+import { CaseHeaderComponent } from './case-header.component';
+import * as i0 from "@angular/core";
+export class CaseHeaderModule {
+    static ɵfac = function CaseHeaderModule_Factory(t) { return new (t || CaseHeaderModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: CaseHeaderModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
+            RouterModule,
+            PaletteModule] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CaseHeaderModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    RouterModule,
+                    PaletteModule
+                ],
+                declarations: [
+                    CaseHeaderComponent,
+                ],
+                exports: [
+                    CaseHeaderComponent,
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(CaseHeaderModule, { declarations: [CaseHeaderComponent], imports: [CommonModule,
+        RouterModule,
+        PaletteModule], exports: [CaseHeaderComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FzZS1oZWFkZXIubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NkLWNhc2UtdWktdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9jb21wb25lbnRzL2Nhc2UtaGVhZGVyL2Nhc2UtaGVhZGVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUMzQyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQzs7QUFlOUQsTUFBTSxPQUFPLGdCQUFnQjswRUFBaEIsZ0JBQWdCOzREQUFoQixnQkFBZ0I7Z0VBWHJCLFlBQVk7WUFDWixZQUFZO1lBQ1osYUFBYTs7aUZBU1IsZ0JBQWdCO2NBYjVCLFFBQVE7ZUFBQztnQkFDTixPQUFPLEVBQUU7b0JBQ0wsWUFBWTtvQkFDWixZQUFZO29CQUNaLGFBQWE7aUJBQ2hCO2dCQUNELFlBQVksRUFBRTtvQkFDVixtQkFBbUI7aUJBQ3RCO2dCQUNELE9BQU8sRUFBRTtvQkFDTCxtQkFBbUI7aUJBQ3RCO2FBQ0o7O3dGQUNZLGdCQUFnQixtQkFOckIsbUJBQW1CLGFBTG5CLFlBQVk7UUFDWixZQUFZO1FBQ1osYUFBYSxhQU1iLG1CQUFtQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUm91dGVyTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcbmltcG9ydCB7IFBhbGV0dGVNb2R1bGUgfSBmcm9tICcuLi9wYWxldHRlJztcbmltcG9ydCB7IENhc2VIZWFkZXJDb21wb25lbnQgfSBmcm9tICcuL2Nhc2UtaGVhZGVyLmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gICAgaW1wb3J0czogW1xuICAgICAgICBDb21tb25Nb2R1bGUsXG4gICAgICAgIFJvdXRlck1vZHVsZSxcbiAgICAgICAgUGFsZXR0ZU1vZHVsZVxuICAgIF0sXG4gICAgZGVjbGFyYXRpb25zOiBbXG4gICAgICAgIENhc2VIZWFkZXJDb21wb25lbnQsXG4gICAgXSxcbiAgICBleHBvcnRzOiBbXG4gICAgICAgIENhc2VIZWFkZXJDb21wb25lbnQsXG4gICAgXVxufSlcbmV4cG9ydCBjbGFzcyBDYXNlSGVhZGVyTW9kdWxlIHt9XG4iXX0=