@reusa/ngx-reusa-app-lib 0.0.999 → 0.1.101

package/esm2022/lib/components/lexis-nexis/lexis-nexis.component.mjs

@@ -0,0 +1,329 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { catchError, of, tap, throwError } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/util/util.service";
+import * as i2 from "../../services/lexis-nexis/lexis.nexis.service";
+import * as i3 from "@ionic/angular";
+import * as i4 from "@angular/common";
+import * as i5 from "primeng/api";
+import * as i6 from "@angular/material/form-field";
+import * as i7 from "@angular/forms";
+import * as i8 from "primeng/dialog";
+import * as i9 from "primeng/divider";
+const _c0 = a0 => ({ Choice: a0 });
+const _c1 = a0 => [a0];
+const _c2 = (a0, a1) => ({ Choices: a0, QuestionId: a1 });
+function LexisNexisComponent_div_3_div_1_div_3_Template(rf, ctx) { if (rf & 1) {
+    const _r10 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 11)(1, "input", 12);
+    i0.ɵɵlistener("ngModelChange", function LexisNexisComponent_div_3_div_1_div_3_Template_input_ngModelChange_1_listener($event) { i0.ɵɵrestoreView(_r10); const i_r5 = i0.ɵɵnextContext().index; const ctx_r9 = i0.ɵɵnextContext(2); return i0.ɵɵresetView((ctx_r9.answers["iidqa.answers"].Questions[i_r5] = $event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(2, "label", 13);
+    i0.ɵɵtext(3);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const choices_r7 = ctx.$implicit;
+    const j_r8 = ctx.index;
+    const ctx_r12 = i0.ɵɵnextContext();
+    const i_r5 = ctx_r12.index;
+    const q_r4 = ctx_r12.$implicit;
+    const ctx_r6 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("name", "question-" + i_r5)("id", "question-" + i_r5 + "-" + j_r8)("ngModel", ctx_r6.answers["iidqa.answers"].Questions[i_r5])("value", i0.ɵɵpureFunction2(10, _c2, i0.ɵɵpureFunction1(8, _c1, i0.ɵɵpureFunction1(6, _c0, choices_r7.ChoiceId)), q_r4.QuestionId));
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("for", "question-" + i_r5 + "-" + j_r8);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", choices_r7.Text.Statement, " ");
+} }
+function LexisNexisComponent_div_3_div_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 7)(1, "label", 8);
+    i0.ɵɵtext(2);
+    i0.ɵɵelementEnd();
+    i0.ɵɵtemplate(3, LexisNexisComponent_div_3_div_1_div_3_Template, 4, 13, "div", 9);
+    i0.ɵɵelementStart(4, "div", 10);
+    i0.ɵɵtext(5);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelement(6, "p-divider");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const q_r4 = ctx.$implicit;
+    const i_r5 = ctx.index;
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("for", "question-" + i_r5);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(q_r4.Text.Statement);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngForOf", q_r4.Choices);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", q_r4.HelpText.Statement, " ");
+} }
+function LexisNexisComponent_div_3_mat_error_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "mat-error", 14);
+    i0.ɵɵtext(1, " All fields are required. ");
+    i0.ɵɵelementEnd();
+} }
+function LexisNexisComponent_div_3_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div");
+    i0.ɵɵtemplate(1, LexisNexisComponent_div_3_div_1_Template, 7, 4, "div", 5)(2, LexisNexisComponent_div_3_mat_error_2_Template, 2, 0, "mat-error", 6);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const d_r1 = ctx.$implicit;
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngForOf", d_r1["iidqa.question_set"] == null ? null : d_r1["iidqa.question_set"].Questions);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r0.submitted && !ctx_r0.checkForm());
+} }
+const _c3 = () => ({ "1024px": "75vw", "768px": "85vw", "640px": "100vw" });
+/**
+ * To Activate this modal assign display=true, this will work as many times as needed
+ */
+export class LexisNexisComponent {
+    get blankAnswers() {
+        return JSON.parse(JSON.stringify({
+            auth_selection_id: null,
+            "iidqa.answers": {
+                QuestionSetId: null,
+                Questions: []
+            }
+        }));
+    }
+    ;
+    constructor(util, ln) {
+        this.util = util;
+        this.ln = ln;
+        this.display = false;
+        /*userDetails = null for normal flow, != for SignUp flow */
+        this.userDetails = null;
+        /*page = "345" for SignUp flow, null for others*/
+        this.page = null;
+        this.success = new EventEmitter();
+        this.close = new EventEmitter();
+        this.error = new EventEmitter();
+        this.usps = new EventEmitter();
+        this.submitted = false;
+        this.answers = this.blankAnswers;
+        this.answerArray = [];
+    }
+    /**
+     * will call api when display is set to true
+     * @param changes
+     * @returns
+     */
+    ngOnChanges(changes) {
+        if (!changes.display.currentValue) {
+            return;
+        }
+        this.display = false;
+        if (this.page === 345) {
+            this.lnQueryApiPI();
+        }
+        else {
+            this.lnQueryApi();
+        }
+    }
+    lnQueryApi() {
+        this.ln.getLnQueryApiResponse()
+            .pipe(catchError((error) => {
+            this.display = false;
+            if (error.msg.includes("Lexis Nexis Verification Failed. Status:Reject")) {
+                console.log('Lexis Nexis Verification Failed. Status:Reject');
+            }
+            else if (error.msg.includes("Lexis Nexis Verification Failed. Status:Review")) {
+                console.log('Lexis Nexis Verification Failed. Status:Review');
+            }
+            else if (error.msg.includes("fail_invalid_parameter")) {
+                console.log("fail invalid parameter");
+            }
+            else if (error.msg[0].includes('Claimant Account is Locked')) {
+                console.log("Claimant Account is Locked");
+            }
+            else {
+                console.log("LN failed for other reasons");
+            }
+            this.util.showError('We were not able to verify your identity. Please follow the instructions.');
+            setTimeout(() => this.usps.emit(), 1000);
+            return throwError(() => new Error(error));
+        }))
+            .subscribe((response) => {
+            if (response !== null) {
+                if (response?.request_result === "success" && (response?.review_status === "challenge")) {
+                    if (response?.auth_selection_methods[0]?.auth_selection_id) {
+                        this.authSelectionRequest = {
+                            auth_selection_id: response?.auth_selection_methods[0]?.auth_selection_id,
+                            'iidqa.answers': null
+                        };
+                        this.lnAuthenticationQA(this.authSelectionRequest);
+                    }
+                    else {
+                        console.log("auth selection id is missing");
+                        this.util.info('We were not able to verify your identity. Please follow the instructions.');
+                        setTimeout(() => this.usps.emit(), 1000);
+                    }
+                }
+            }
+            else {
+                console.log("Empty response received");
+                this.util.info('We were not able to verify your identity. Please follow the instructions.');
+                setTimeout(() => this.usps.emit(), 1000);
+            }
+        });
+    }
+    lnQueryApiPI() {
+        this.ln.getLnQueryApiPIResponse(this.userDetails)
+            .pipe(catchError((error) => {
+            this.display = false;
+            if (error.msg.includes("Lexis Nexis Verification Failed. Status:Reject")) {
+                console.log('Lexis Nexis Verification Failed. Status:Reject');
+            }
+            else if (error.msg.includes("Lexis Nexis Verification Failed. Status:Review")) {
+                console.log('Lexis Nexis Verification Failed. Status:Review');
+            }
+            else if (error.msg.includes("fail_invalid_parameter")) {
+                console.log("fail invalid parameter");
+            }
+            else if (error.msg[0].includes('Claimant Account is Locked')) {
+                console.log("Claimant Account is Locked");
+            }
+            else {
+                console.log("LN failed for other reason");
+            }
+            this.util.showError('We were not able to verify your identity. Please follow the instructions.');
+            setTimeout(() => this.usps.emit(), 1000);
+            return of(null);
+        }))
+            .subscribe((response) => {
+            if (response !== null) {
+                if (response?.request_result === "success" && (response?.review_status === "challenge")) {
+                    if (response?.auth_selection_methods[0]?.auth_selection_id) {
+                        this.authSelectionRequest = {
+                            auth_selection_id: response?.auth_selection_methods[0]?.auth_selection_id,
+                            'iidqa.answers': null
+                        };
+                        this.display = true;
+                        this.lnAuthenticationQA(this.authSelectionRequest);
+                    }
+                    else {
+                        console.log("auth selection id is missing");
+                        this.util.info('We were not able to verify your identity. Please follow the instructions.');
+                        setTimeout(() => this.usps.emit(), 1000);
+                    }
+                }
+            }
+            else {
+                console.log("Empty response received");
+                this.util.info('We were not able to verify your identity. Please follow the instructions.');
+            }
+        });
+    }
+    /**
+     * submit button and get new question in the beginning
+     * @param authSelectionRequest
+     */
+    lnAuthenticationQA(authSelectionRequest) {
+        this.data = this.ln.lnAuthenticationQA(authSelectionRequest)
+            .pipe(catchError((error) => {
+            this.display = false;
+            if (error.msg.includes("Lexis Nexis Verified")) {
+                this.display = false;
+                setTimeout(() => this.success.emit(), 1000);
+            }
+            else if (error.msg.includes("Lexis Nexis Verification Failed. Status:Reject")) {
+                this.display = false;
+                this.util.showError('We were not able to verify your identity. Please follow the instructions.');
+                setTimeout(() => this.usps.emit(), 1000);
+            }
+            else if (error.msg.includes("fail_invalid_parameter")) {
+                this.util.showError('We were not able to verify your identity. Please follow the instructions.');
+                setTimeout(() => this.usps.emit(), 1000);
+            }
+            else if (error.msg[0].includes('Claimant Account is Locked')) {
+                this.display = false;
+                this.util.showError('We were not able to verify your identity. Please follow the instructions.');
+                setTimeout(() => this.usps.emit(), 1000);
+            }
+            else {
+                this.display = false;
+                this.util.showError('We were not able to verify your identity. Please follow the instructions.');
+                setTimeout(() => this.usps.emit(), 1000);
+            }
+            return of(null);
+        }), tap(x => {
+            if (!x) {
+                this.display = false;
+                this.util.showError('We were not able to verify your identity. Please follow the instructions.');
+                setTimeout(() => this.usps.emit(), 1000);
+                return;
+            }
+            if (x?.review_status == "pass") {
+                this.display = false;
+                setTimeout(() => this.success.emit(), 1000);
+                return;
+            }
+            this.display = true;
+            this.submitted = false;
+            this.answers = this.blankAnswers;
+            this.questionLength = x['iidqa.question_set'].Questions.length;
+            this.answers.auth_selection_id = x.auth_selection_id;
+            this.answers['iidqa.answers'].QuestionSetId = x['iidqa.question_set'].QuestionSetId;
+        }));
+    }
+    /**
+     * The submit button press
+     */
+    submit() {
+        this.submitted = true;
+        if (!this.checkForm()) {
+            return;
+        }
+        this.lnAuthenticationQA(this.answers);
+    }
+    /**
+     *
+     * @returns is form valid
+     */
+    checkForm() {
+        if (this.answers['iidqa.answers'].Questions.length !== this.questionLength) {
+            return false;
+        }
+        return this.answers['iidqa.answers'].Questions.map(x => !!x).reduce((x, y) => x && y);
+    }
+    static { this.ɵfac = function LexisNexisComponent_Factory(t) { return new (t || LexisNexisComponent)(i0.ɵɵdirectiveInject(i1.UtilService), i0.ɵɵdirectiveInject(i2.LexisNexisService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LexisNexisComponent, selectors: [["app-lexis-nexis"]], inputs: { display: "display", userDetails: "userDetails", page: "page" }, outputs: { success: "success", close: "close", error: "error", usps: "usps" }, features: [i0.ɵɵNgOnChangesFeature], decls: 8, vars: 6, consts: [["modal", "true", "appendTo", "body", "position", "top", 3, "visible", "breakpoints", "visibleChange"], [1, "dialog-content"], ["name", "help-outline"], [4, "ngIf"], ["shape", "round", "type", "submit", 1, "ionButton", 3, "click"], ["class", "question-field", 4, "ngFor", "ngForOf"], ["class", "validator", 4, "ngIf"], [1, "question-field"], [1, "question", 3, "for"], ["class", "answer", 4, "ngFor", "ngForOf"], [1, "hint"], [1, "answer"], ["type", "radio", 3, "name", "id", "ngModel", "value", "ngModelChange"], [3, "for"], [1, "validator"]], template: function LexisNexisComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "p-dialog", 0);
+            i0.ɵɵlistener("visibleChange", function LexisNexisComponent_Template_p_dialog_visibleChange_0_listener($event) { return ctx.display = $event; });
+            i0.ɵɵelementStart(1, "form", 1);
+            i0.ɵɵelement(2, "ion-icon", 2);
+            i0.ɵɵtemplate(3, LexisNexisComponent_div_3_Template, 3, 2, "div", 3);
+            i0.ɵɵpipe(4, "async");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(5, "p-footer")(6, "ion-button", 4);
+            i0.ɵɵlistener("click", function LexisNexisComponent_Template_ion_button_click_6_listener() { return ctx.submit(); });
+            i0.ɵɵtext(7, "Submit");
+            i0.ɵɵelementEnd()()();
+        } if (rf & 2) {
+            i0.ɵɵproperty("visible", ctx.display)("breakpoints", i0.ɵɵpureFunction0(5, _c3));
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(4, 3, ctx.data));
+        } }, dependencies: [i3.IonButton, i3.IonIcon, i4.NgForOf, i4.NgIf, i5.Footer, i6.MatError, i7.ɵNgNoValidate, i7.DefaultValueAccessor, i7.RadioControlValueAccessor, i7.NgControlStatus, i7.NgControlStatusGroup, i7.NgModel, i7.NgForm, i8.Dialog, i9.Divider, i4.AsyncPipe], styles: [".dialog-content[_ngcontent-%COMP%] > *[_ngcontent-%COMP%]{display:inline-block}ion-icon[_ngcontent-%COMP%]{font-size:90px;vertical-align:top}.question-field[_ngcontent-%COMP%]{margin:10px 0}.question-field[_ngcontent-%COMP%]   .question[_ngcontent-%COMP%]{font-size:20px}.question-field[_ngcontent-%COMP%]   .answer[_ngcontent-%COMP%]{margin-left:8px}.hint[_ngcontent-%COMP%]{font-weight:600}"] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LexisNexisComponent, [{
+        type: Component,
+        args: [{ selector: 'app-lexis-nexis', template: "<p-dialog [(visible)]=\"display\" modal=\"true\" appendTo=\"body\" [breakpoints]=\"{'1024px': '75vw', '768px': '85vw', '640px': '100vw'}\" position=\"top\">\r\n   <form class=\"dialog-content\">\r\n      <ion-icon name=\"help-outline\"></ion-icon>\r\n       <div *ngIf=\"data | async; let d\">\r\n            <div *ngFor=\"let q of d['iidqa.question_set']?.Questions; let i = index\" class=\"question-field\">\r\n                <label class=\"question\" [for]=\"'question-' + i\">{{q.Text.Statement}}</label>\r\n                <div class=\"answer\" *ngFor=\"let choices of q.Choices; let j = index\">\r\n                   <input [name]=\"'question-' + i\" type=\"radio\" [id]=\"'question-'+i+'-'+j\" [(ngModel)]=\"answers['iidqa.answers'].Questions[i]\" [value]=\"{Choices: [{Choice: choices.ChoiceId}], QuestionId: q.QuestionId}\">\r\n                   <label [for]=\"'question-'+i+'-'+j\">\r\n                       {{choices.Text.Statement}}\r\n                    </label>\r\n                </div>\r\n                <div class=\"hint\">\r\n                    {{q.HelpText.Statement}}\r\n                </div>\r\n                <p-divider></p-divider>\r\n            </div>\r\n            <mat-error class=\"validator\" *ngIf=\"submitted && !checkForm()\">\r\n                All fields are required.\r\n            </mat-error>\r\n        </div>\r\n    </form>\r\n    <p-footer>\r\n        <ion-button shape=\"round\" type=\"submit\" class=\"ionButton\" (click)=\"submit()\">Submit</ion-button>\r\n    </p-footer>\r\n</p-dialog>", styles: [".dialog-content>*{display:inline-block}ion-icon{font-size:90px;vertical-align:top}.question-field{margin:10px 0}.question-field .question{font-size:20px}.question-field .answer{margin-left:8px}.hint{font-weight:600}\n"] }]
+    }], () => [{ type: i1.UtilService }, { type: i2.LexisNexisService }], { display: [{
+            type: Input
+        }], userDetails: [{
+            type: Input
+        }], page: [{
+            type: Input
+        }], success: [{
+            type: Output
+        }], close: [{
+            type: Output
+        }], error: [{
+            type: Output
+        }], usps: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LexisNexisComponent, { className: "LexisNexisComponent", filePath: "lib\\components\\lexis-nexis\\lexis-nexis.component.ts", lineNumber: 16 }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lexis-nexis.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-reusa-app-lib/src/lib/components/lexis-nexis/lexis-nexis.component.ts","../../../../../../projects/ngx-reusa-app-lib/src/lib/components/lexis-nexis/lexis-nexis.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAa,MAAM,EAAiB,MAAM,eAAe,CAAC;AAGjG,OAAO,EAAE,UAAU,EAAc,EAAE,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;;;;;;;;;;;;;;;;ICGnD,+BAAqE,gBAAA;IACM,yQAAqB,eAAe,gCAAe;IAA3H,iBAAwM;IACxM,iCAAmC;IAC/B,YACH;IAAA,iBAAQ,EAAA;;;;;;;;IAHF,eAAwB;IAAxB,yCAAwB,uCAAA,4DAAA,oIAAA;IACxB,eAA2B;IAA3B,qDAA2B;IAC9B,eACH;IADG,0DACH;;;IANR,8BAAgG,eAAA;IAC5C,YAAoB;IAAA,iBAAQ;IAC5E,iFAKM;IACN,+BAAkB;IACd,YACJ;IAAA,iBAAM;IACN,4BAAuB;IAC3B,iBAAM;;;;IAXsB,eAAuB;IAAvB,wCAAuB;IAAC,eAAoB;IAApB,yCAAoB;IAC5B,eAAc;IAAd,sCAAc;IAOlD,eACJ;IADI,wDACJ;;;IAGJ,qCAA+D;IAC3D,0CACJ;IAAA,iBAAY;;;IAhBjB,2BAAiC;IAC5B,0EAYM,yEAAA;IAIV,iBAAM;;;;IAhBiB,eAAuC;IAAvC,0GAAuC;IAa5B,eAA+B;IAA/B,8DAA+B;;;ADVzE;;GAEG;AAMH,MAAM,OAAO,mBAAmB;IAsB9B,IAAI,YAAY;QAAwC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC;YACvF,iBAAiB,EAAE,IAAI;YACvB,eAAe,EAAE;gBACf,aAAa,EAAE,IAAI;gBACnB,SAAS,EAAE,EAAE;aAChB;SAAC,CAAC,CAAC,CAAA;IAAA,CAAC;IAAA,CAAC;IAON,YACS,IAAiB,EACjB,EAAqB;QADrB,SAAI,GAAJ,IAAI,CAAa;QACjB,OAAE,GAAF,EAAE,CAAmB;QAlCd,YAAO,GAAG,KAAK,CAAC;QAEhC,2DAA2D;QAC3C,gBAAW,GAAoC,IAAI,CAAC;QAEpE,iDAAiD;QACjC,SAAI,GAAY,IAAI,CAAC;QAE3B,YAAO,GAAsB,IAAI,YAAY,EAAE,CAAC;QAEhD,UAAK,GAAsB,IAAI,YAAY,EAAE,CAAC;QAE9C,UAAK,GAAsB,IAAI,YAAY,EAAE,CAAC;QAE9C,SAAI,GAAsB,IAAI,YAAY,EAAE,CAAC;QAGhD,cAAS,GAAG,KAAK,CAAC;QAUlB,YAAO,GAAwC,IAAI,CAAC,YAAY,CAAC;QAGjE,gBAAW,GAAc,EAAE,CAAC;IAKhC,CAAC;IACJ;;;;OAIG;IACH,WAAW,CAAC,OAAsB;QAChC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE;YACjC,OAAO;SACR;QACD,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,IAAI,CAAC,IAAI,KAAK,GAAG,EAAE;YACrB,IAAI,CAAC,YAAY,EAAE,CAAC;SACrB;aAAM;YACL,IAAI,CAAC,UAAU,EAAE,CAAC;SACnB;IACH,CAAC;IAED,UAAU;QACR,IAAI,CAAC,EAAE,CAAC,qBAAqB,EAAE;aAC9B,IAAI,CACH,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACrB,IAAI,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,gDAAgD,CAAC,EAAE;gBACxE,OAAO,CAAC,GAAG,CAAC,gDAAgD,CAAC,CAAC;aAC/D;iBAAM,IAAI,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,gDAAgD,CAAC,EAAE;gBAC/E,OAAO,CAAC,GAAG,CAAC,gDAAgD,CAAC,CAAC;aAC/D;iBAAM,IAAI,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,wBAAwB,CAAC,EAAE;gBACvD,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;aACvC;iBAAM,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,4BAA4B,CAAC,EAAC;gBAC7D,OAAO,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAC;aAC3C;iBAAM;gBACL,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAC,CAAC;aAC5C;YACD,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,2EAA2E,CAAC,CAAC;YACjG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;YACzC,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5C,CAAC,CAAC,CACH;aACA,SAAS,CAAC,CAAC,QAAoB,EAAE,EAAE;YAClC,IAAI,QAAQ,KAAK,IAAI,EAAE;gBACrB,IAAG,QAAQ,EAAE,cAAc,KAAK,SAAS,IAAI,CAAC,QAAQ,EAAE,aAAa,KAAK,WAAW,CAAC,EAAC;oBACrF,IAAG,QAAQ,EAAE,sBAAsB,CAAC,CAAC,CAAC,EAAE,iBAAiB,EAAC;wBACxD,IAAI,CAAC,oBAAoB,GAAG;4BAC1B,iBAAiB,EAAG,QAAQ,EAAE,sBAAsB,CAAC,CAAC,CAAC,EAAE,iBAAiB;4BAC1E,eAAe,EAAE,IAAI;yBACtB,CAAC;wBACF,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;qBACpD;yBAAK;wBACJ,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC,CAAC;wBAC5C,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,2EAA2E,CAAC,CAAC;wBAC5F,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;qBAC1C;iBACF;aACF;iBAAM;gBACL,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;gBACvC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,2EAA2E,CAAC,CAAC;gBAC5F,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;aAC1C;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,YAAY;QACV,IAAI,CAAC,EAAE,CAAC,uBAAuB,CAAC,IAAI,CAAC,WAAW,CAAC;aAChD,IAAI,CACH,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACrB,IAAI,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,gDAAgD,CAAC,EAAE;gBACxE,OAAO,CAAC,GAAG,CAAC,gDAAgD,CAAC,CAAC;aAC/D;iBAAM,IAAI,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,gDAAgD,CAAC,EAAE;gBAC/E,OAAO,CAAC,GAAG,CAAC,gDAAgD,CAAC,CAAC;aAC/D;iBAAM,IAAI,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,wBAAwB,CAAC,EAAE;gBACvD,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;aACvC;iBAAM,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,4BAA4B,CAAC,EAAC;gBAC7D,OAAO,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAC;aAC3C;iBAAM;gBACL,OAAO,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAC;aAC3C;YACD,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,2EAA2E,CAAC,CAAC;YACjG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;YACzC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;QAClB,CAAC,CAAC,CACH;aACA,SAAS,CAAC,CAAC,QAAoB,EAAE,EAAE;YAClC,IAAI,QAAQ,KAAK,IAAI,EAAE;gBACrB,IAAG,QAAQ,EAAE,cAAc,KAAK,SAAS,IAAI,CAAC,QAAQ,EAAE,aAAa,KAAK,WAAW,CAAC,EAAC;oBACrF,IAAG,QAAQ,EAAE,sBAAsB,CAAC,CAAC,CAAC,EAAE,iBAAiB,EAAC;wBACxD,IAAI,CAAC,oBAAoB,GAAG;4BAC1B,iBAAiB,EAAG,QAAQ,EAAE,sBAAsB,CAAC,CAAC,CAAC,EAAE,iBAAiB;4BAC1E,eAAe,EAAE,IAAI;yBACtB,CAAC;wBACF,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;wBACpB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;qBACpD;yBAAK;wBACJ,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC,CAAC;wBAC5C,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,2EAA2E,CAAC,CAAC;wBAC5F,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;qBAC1C;iBACF;aACF;iBAAM;gBACL,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;gBACvC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,2EAA2E,CAAC,CAAC;aAC7F;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IACD;;;OAGG;IACH,kBAAkB,CAAC,oBAA0D;QAC3E,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,kBAAkB,CAAC,oBAAoB,CAAC;aAC3D,IAAI,CACH,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACrB,IAAG,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,sBAAsB,CAAC,EAAC;gBAC5C,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;gBACrB,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;aAC7C;iBAAM,IAAG,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,gDAAgD,CAAC,EAAC;gBAC7E,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;gBACrB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,2EAA2E,CAAC,CAAC;gBACjG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;aAC1C;iBAAM,IAAI,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,wBAAwB,CAAC,EAAE;gBACvD,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,2EAA2E,CAAC,CAAC;gBACjG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;aAC1C;iBAAM,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,4BAA4B,CAAC,EAAC;gBAC7D,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;gBACrB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,2EAA2E,CAAC,CAAC;gBACjG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;aAC1C;iBAAM;gBACL,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;gBACrB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,2EAA2E,CAAC,CAAC;gBACjG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;aAC1C;YACD,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;QAClB,CAAC,CAAC,EACF,GAAG,CAAC,CAAC,CAAC,EAAE;YACN,IAAI,CAAC,CAAC,EAAE;gBACN,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;gBACrB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,2EAA2E,CAAC,CAAC;gBACjG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;gBACzC,OAAO;aACR;YACD,IAAG,CAAC,EAAE,aAAa,IAAI,MAAM,EAAC;gBAC5B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;gBACrB,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;gBAC5C,OAAO;aACR;YACD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YACvB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC;YACjC,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC,oBAAoB,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC;YAC/D,IAAI,CAAC,OAAO,CAAC,iBAAiB,GAAG,CAAC,CAAC,iBAAiB,CAAC;YACrD,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,aAAa,GAAG,CAAC,CAAC,oBAAoB,CAAC,CAAC,aAAa,CAAC;QACtF,CAAC,CAAC,CACH,CAAA;IACH,CAAC;IACD;;OAEG;IACH,MAAM;QACJ,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QAEtB,IAAG,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE;YACpB,OAAO;SACR;QACD,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;IACD;;;OAGG;IACH,SAAS;QACP,IAAI,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,SAAS,CAAC,MAAM,KAAK,IAAI,CAAC,cAAc,EAAE;YAC1E,OAAO,KAAK,CAAC;SACd;QAED,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAE,CAAC,CAAC,CAAC;IACrF,CAAC;oFAtNU,mBAAmB;oEAAnB,mBAAmB;YCfhC,mCAAkJ;YAAxI,gJAAqB;YAC5B,+BAA6B;YAC1B,8BAAyC;YACxC,oEAiBO;;YACV,iBAAO;YACP,gCAAU,oBAAA;YACoD,oGAAS,YAAQ,IAAC;YAAC,sBAAM;YAAA,iBAAa,EAAA,EAAA;;YAvB9F,qCAAqB,2CAAA;YAGlB,eAAoB;YAApB,qDAAoB;;;iFDYpB,mBAAmB;cAL/B,SAAS;2BACE,iBAAiB;4EAMX,OAAO;kBAAtB,KAAK;YAGU,WAAW;kBAA1B,KAAK;YAGU,IAAI;kBAAnB,KAAK;YAEI,OAAO;kBAAhB,MAAM;YAEG,KAAK;kBAAd,MAAM;YAEG,KAAK;kBAAd,MAAM;YAEG,IAAI;kBAAb,MAAM;;kFAhBI,mBAAmB","sourcesContent":["import { Component, EventEmitter, Input, OnChanges, Output, SimpleChanges } from '@angular/core';\r\nimport { UtilService } from '../../services/util/util.service';\r\nimport { LexisNexisService } from '../../services/lexis-nexis/lexis.nexis.service';\r\nimport { catchError, Observable, of, tap, throwError } from 'rxjs';\r\nimport { LexisNexisAuthSelectionRequestModel } from '../../models/LexisNexisAuthSelectionRequestModel';\r\nimport { LexisNexisAccountCreationModel } from '../../models/LexisNexisAccountCreationModel';\r\nimport { LexisNexisAuthSelectionResponseModel } from '../../models/LexisNexisAuthSelectionResponseModel';\r\n/**\r\n * To Activate this modal assign display=true, this will work as many times as needed\r\n */\r\n@Component({\r\n  selector: 'app-lexis-nexis',\r\n  templateUrl: './lexis-nexis.component.html',\r\n  styleUrls: ['./lexis-nexis.component.scss'],\r\n})\r\nexport class LexisNexisComponent implements OnChanges {\r\n\r\n  @Input() public display = false;\r\n\r\n  /*userDetails = null for normal flow, != for SignUp flow */\r\n  @Input() public userDetails : LexisNexisAccountCreationModel = null;\r\n\r\n  /*page = \"345\" for SignUp flow, null for others*/\r\n  @Input() public page : number = null;\r\n\r\n  @Output() success: EventEmitter<any> = new EventEmitter();\r\n\r\n  @Output() close: EventEmitter<any> = new EventEmitter();\r\n\r\n  @Output() error: EventEmitter<any> = new EventEmitter();\r\n\r\n  @Output() usps: EventEmitter<any> = new EventEmitter();\r\n\r\n  questionLength: number;\r\n  public submitted = false;\r\n  public authSelectionRequest : LexisNexisAuthSelectionRequestModel;\r\n\r\n  get blankAnswers(): LexisNexisAuthSelectionRequestModel{return JSON.parse(JSON.stringify({\r\n    auth_selection_id: null, \r\n    \"iidqa.answers\": {\r\n      QuestionSetId: null,\r\n      Questions: []\r\n  }}))};\r\n\r\n  public answers: LexisNexisAuthSelectionRequestModel = this.blankAnswers;\r\n\r\n  public data : Observable<LexisNexisAuthSelectionResponseModel>;\r\n  public answerArray: string[] =  [];\r\n\r\n  constructor(\r\n    public util: UtilService,\r\n    public ln: LexisNexisService\r\n  ) {}\r\n  /**\r\n   * will call api when display is set to true\r\n   * @param changes \r\n   * @returns \r\n   */\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (!changes.display.currentValue) {\r\n      return;\r\n    }\r\n    this.display = false;\r\n    if (this.page === 345) {\r\n      this.lnQueryApiPI();\r\n    } else {\r\n      this.lnQueryApi();\r\n    }\r\n  }\r\n\r\n  lnQueryApi(){\r\n    this.ln.getLnQueryApiResponse()\r\n    .pipe(\r\n      catchError((error) => {\r\n        this.display = false;\r\n        if (error.msg.includes(\"Lexis Nexis Verification Failed. Status:Reject\")) {\r\n          console.log('Lexis Nexis Verification Failed. Status:Reject');\r\n        } else if (error.msg.includes(\"Lexis Nexis Verification Failed. Status:Review\")) {\r\n          console.log('Lexis Nexis Verification Failed. Status:Review');\r\n        } else if (error.msg.includes(\"fail_invalid_parameter\")) {\r\n          console.log(\"fail invalid parameter\");\r\n        } else if (error.msg[0].includes('Claimant Account is Locked')){    \r\n          console.log(\"Claimant Account is Locked\");\r\n        } else {\r\n          console.log(\"LN failed for other reasons\");\r\n        }\r\n        this.util.showError('We were not able to verify your identity. Please follow the instructions.');\r\n        setTimeout(() => this.usps.emit(), 1000);\r\n        return throwError(() => new Error(error));\r\n      })\r\n    )\r\n    .subscribe((response: any | null) => {\r\n      if (response !== null) {\r\n        if(response?.request_result === \"success\" && (response?.review_status === \"challenge\")){\r\n          if(response?.auth_selection_methods[0]?.auth_selection_id){\r\n            this.authSelectionRequest = {\r\n              auth_selection_id : response?.auth_selection_methods[0]?.auth_selection_id,\r\n              'iidqa.answers': null\r\n            };\r\n            this.lnAuthenticationQA(this.authSelectionRequest);\r\n          } else{\r\n            console.log(\"auth selection id is missing\");\r\n            this.util.info('We were not able to verify your identity. Please follow the instructions.');\r\n            setTimeout(() => this.usps.emit(), 1000);\r\n          }\r\n        }\r\n      } else {\r\n        console.log(\"Empty response received\");\r\n        this.util.info('We were not able to verify your identity. Please follow the instructions.');\r\n        setTimeout(() => this.usps.emit(), 1000);\r\n      }\r\n    });\r\n  }\r\n\r\n  lnQueryApiPI(){\r\n    this.ln.getLnQueryApiPIResponse(this.userDetails)\r\n    .pipe(\r\n      catchError((error) => {\r\n        this.display = false;\r\n        if (error.msg.includes(\"Lexis Nexis Verification Failed. Status:Reject\")) {\r\n          console.log('Lexis Nexis Verification Failed. Status:Reject');\r\n        } else if (error.msg.includes(\"Lexis Nexis Verification Failed. Status:Review\")) {\r\n          console.log('Lexis Nexis Verification Failed. Status:Review');\r\n        } else if (error.msg.includes(\"fail_invalid_parameter\")) {\r\n          console.log(\"fail invalid parameter\");\r\n        } else if (error.msg[0].includes('Claimant Account is Locked')){    \r\n          console.log(\"Claimant Account is Locked\");\r\n        } else {\r\n          console.log(\"LN failed for other reason\");\r\n        }\r\n        this.util.showError('We were not able to verify your identity. Please follow the instructions.');\r\n        setTimeout(() => this.usps.emit(), 1000);\r\n        return of(null);\r\n      })\r\n    )\r\n    .subscribe((response: any | null) => {\r\n      if (response !== null) {\r\n        if(response?.request_result === \"success\" && (response?.review_status === \"challenge\")){\r\n          if(response?.auth_selection_methods[0]?.auth_selection_id){\r\n            this.authSelectionRequest = {\r\n              auth_selection_id : response?.auth_selection_methods[0]?.auth_selection_id,\r\n              'iidqa.answers': null\r\n            };\r\n            this.display = true;\r\n            this.lnAuthenticationQA(this.authSelectionRequest);\r\n          } else{\r\n            console.log(\"auth selection id is missing\");\r\n            this.util.info('We were not able to verify your identity. Please follow the instructions.');\r\n            setTimeout(() => this.usps.emit(), 1000);\r\n          }\r\n        }\r\n      } else {\r\n        console.log(\"Empty response received\");\r\n        this.util.info('We were not able to verify your identity. Please follow the instructions.');\r\n      }\r\n    });\r\n  }\r\n  /**\r\n   * submit button and get new question in the beginning\r\n   * @param authSelectionRequest \r\n   */\r\n  lnAuthenticationQA(authSelectionRequest : LexisNexisAuthSelectionRequestModel){\r\n    this.data = this.ln.lnAuthenticationQA(authSelectionRequest)\r\n    .pipe(\r\n      catchError((error) => {\r\n        this.display = false;\r\n        if(error.msg.includes(\"Lexis Nexis Verified\")){\r\n          this.display = false;\r\n          setTimeout(() => this.success.emit(), 1000);\r\n        } else if(error.msg.includes(\"Lexis Nexis Verification Failed. Status:Reject\")){\r\n          this.display = false;\r\n          this.util.showError('We were not able to verify your identity. Please follow the instructions.');\r\n          setTimeout(() => this.usps.emit(), 1000);\r\n        } else if (error.msg.includes(\"fail_invalid_parameter\")) {\r\n          this.util.showError('We were not able to verify your identity. Please follow the instructions.');\r\n          setTimeout(() => this.usps.emit(), 1000);\r\n        } else if (error.msg[0].includes('Claimant Account is Locked')){\r\n          this.display = false;\r\n          this.util.showError('We were not able to verify your identity. Please follow the instructions.');\r\n          setTimeout(() => this.usps.emit(), 1000);\r\n        } else {\r\n          this.display = false;\r\n          this.util.showError('We were not able to verify your identity. Please follow the instructions.');\r\n          setTimeout(() => this.usps.emit(), 1000);\r\n        }\r\n        return of(null);\r\n      }),\r\n      tap(x => { \r\n        if (!x) {\r\n          this.display = false;\r\n          this.util.showError('We were not able to verify your identity. Please follow the instructions.');\r\n          setTimeout(() => this.usps.emit(), 1000);\r\n          return;\r\n        } \r\n        if(x?.review_status == \"pass\"){\r\n          this.display = false;\r\n          setTimeout(() => this.success.emit(), 1000);\r\n          return;\r\n        }\r\n        this.display = true;\r\n        this.submitted = false;\r\n        this.answers = this.blankAnswers;\r\n        this.questionLength = x['iidqa.question_set'].Questions.length;\r\n        this.answers.auth_selection_id = x.auth_selection_id;\r\n        this.answers['iidqa.answers'].QuestionSetId = x['iidqa.question_set'].QuestionSetId;\r\n      })\r\n    )\r\n  }\r\n  /**\r\n   * The submit button press\r\n   */\r\n  submit() {\r\n    this.submitted = true;\r\n\r\n    if(!this.checkForm()) {\r\n      return;\r\n    }\r\n    this.lnAuthenticationQA(this.answers);\r\n  }\r\n  /**\r\n   * \r\n   * @returns is form valid\r\n   */\r\n  checkForm(): boolean {\r\n    if (this.answers['iidqa.answers'].Questions.length !== this.questionLength) {\r\n      return false;\r\n    }\r\n\r\n    return this.answers['iidqa.answers'].Questions.map(x => !!x).reduce((x,y) => x&&y);\r\n  }\r\n  \r\n}","<p-dialog [(visible)]=\"display\" modal=\"true\" appendTo=\"body\" [breakpoints]=\"{'1024px': '75vw', '768px': '85vw', '640px': '100vw'}\" position=\"top\">\r\n   <form class=\"dialog-content\">\r\n      <ion-icon name=\"help-outline\"></ion-icon>\r\n       <div *ngIf=\"data | async; let d\">\r\n            <div *ngFor=\"let q of d['iidqa.question_set']?.Questions; let i = index\" class=\"question-field\">\r\n                <label class=\"question\" [for]=\"'question-' + i\">{{q.Text.Statement}}</label>\r\n                <div class=\"answer\" *ngFor=\"let choices of q.Choices; let j = index\">\r\n                   <input [name]=\"'question-' + i\" type=\"radio\" [id]=\"'question-'+i+'-'+j\" [(ngModel)]=\"answers['iidqa.answers'].Questions[i]\" [value]=\"{Choices: [{Choice: choices.ChoiceId}], QuestionId: q.QuestionId}\">\r\n                   <label [for]=\"'question-'+i+'-'+j\">\r\n                       {{choices.Text.Statement}}\r\n                    </label>\r\n                </div>\r\n                <div class=\"hint\">\r\n                    {{q.HelpText.Statement}}\r\n                </div>\r\n                <p-divider></p-divider>\r\n            </div>\r\n            <mat-error class=\"validator\" *ngIf=\"submitted && !checkForm()\">\r\n                All fields are required.\r\n            </mat-error>\r\n        </div>\r\n    </form>\r\n    <p-footer>\r\n        <ion-button shape=\"round\" type=\"submit\" class=\"ionButton\" (click)=\"submit()\">Submit</ion-button>\r\n    </p-footer>\r\n</p-dialog>"]}

package/esm2022/lib/components/link/link.component.mjs

@@ -128,4 +128,4 @@ export class LinkComponent {
             type: Input
         }] }); })();
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LinkComponent, { className: "LinkComponent", filePath: "lib\\components\\link\\link.component.ts", lineNumber: 21 }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"link.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-reusa-app-lib/src/lib/components/link/link.component.ts","../../../../../../projects/ngx-reusa-app-lib/src/lib/components/link/link.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAU,SAAS,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EAAyC,aAAa,EAAE,iBAAiB,EAA6E,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEhM,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;;;;;;;;AAiBrE,MAAM,OAAO,aAAa;IA8BxB,YAAmB,EAAsB;QAAtB,OAAE,GAAF,EAAE,CAAoB;QAvBzC,8CAA8C;QACrC,eAAU,GAAa,KAAK,CAAC;QActC,cAAS,GAAa,GAAG,EAAE,GAAG,CAAC,CAAC;QAEhC,iBAAY,GAAmB,EAAE,CAAC;QAE1B,aAAQ,GAAG,CAAC,KAAc,EAAE,EAAE;QAEtC,CAAC,CAAC;IAIF,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC;YACxB,SAAS,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC;SAChE,CAAC,CAAC;QAEH,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;YACrC,IAAG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAC;gBACjB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;aACrC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;IACzC,CAAC;IAED,WAAW;QACT,KAAK,IAAI,GAAG,IAAI,IAAI,CAAC,YAAY,EAAE;YACjC,GAAG,CAAC,WAAW,EAAE,CAAC;SACnB;IACH,CAAC;IAED,gBAAgB,CAAC,QAAa;QAC5B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED,iBAAiB,CAAC,SAAmB;QACnC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED,UAAU,CAAC,KAAa;QACtB,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;IAChC,CAAC;IAED,gBAAgB,CAAE,UAAmB;QACnC,IAAI,UAAU,EAAE;YACd,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;SACrB;aACI;YACH,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;SACpB;IACH,CAAC;IAED,QAAQ,CAAC,OAAkC;QACzC,OAAO,OAAO,CAAC,MAAM,CAAC;IACxB,CAAC;IAED,QAAQ;QACN,IAAG,IAAI,CAAC,GAAG,EAAC;YACV,MAAM,CAAC,IAAI,CAAC,GAAG,UAAU,EAAE,kBAAkB,YAAY,CAAC,KAAK,IAAI,IAAI,CAAC,GAAG,EAAE,EAAE,QAAQ,CAAC,CAAC;SAC1F;aAAM,IAAG,IAAI,CAAC,WAAW,EAAC;YACzB,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,EAAE,QAAQ,CAAC,CAAC;SAC9C;QACD,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IAC/B,CAAC;8EAxFU,aAAa;oEAAb,aAAa;;;;;wJAXb,CAAC;oBACV,OAAO,EAAE,iBAAiB;oBAC1B,WAAW,EAAE,aAAa;oBAC1B,KAAK,EAAE,IAAI;iBACZ;gBACD;oBACE,OAAO,EAAE,aAAa;oBACtB,KAAK,EAAE,IAAI;oBACX,WAAW,EAAE,aAAa;iBAC3B,CAAC;YClBJ,iCAAgD,aAAA,aAAA;YAGpC,2BAA0F;YAC1F,qCAA0H;YAAvE,8FAAS,cAAU,IAAC;YACnE,8BAC2D;YAC3D,YACJ;YAAA,iBAAa;YACb,+BAEe;YACnB,iBAAM,EAAA,EAAA;;;YAZT,oCAAkB;YAKgB,eAAiF;YAAjF,mGAAiF;YAExG,eACJ;YADI,yCACJ;YACW,eAAmB;YAAnB,qCAAmB,aAAA,sCAAA;;;iFDW7B,aAAa;cAfzB,SAAS;2BACE,UAAU,aAGT,CAAC;wBACV,OAAO,EAAE,iBAAiB;wBAC1B,WAAW,eAAe;wBAC1B,KAAK,EAAE,IAAI;qBACZ;oBACD;wBACE,OAAO,EAAE,aAAa;wBACtB,KAAK,EAAE,IAAI;wBACX,WAAW,eAAe;qBAC3B,CAAC;mDAKK,aAAa;kBADnB,SAAS;mBAAC,eAAe,EAAE,EAAC,MAAM,EAAG,KAAK,EAAC;YAMnC,UAAU;kBAAlB,KAAK;YAGG,IAAI;kBAAZ,KAAK;YAGG,GAAG;kBAAX,KAAK;YAGG,WAAW;kBAAnB,KAAK;YAGG,IAAI;kBAAZ,KAAK;;kFApBK,aAAa","sourcesContent":["import { Component, Input, OnInit, ViewChild } from '@angular/core';\nimport { AbstractControl, ControlValueAccessor, NG_VALIDATORS, NG_VALUE_ACCESSOR, NgForm, UntypedFormBuilder, UntypedFormGroup, ValidationErrors, Validator, Validators } from '@angular/forms';\nimport { Subscription } from 'rxjs';\nimport { LibConstants, getBaseUrl } from '../../models/LibConstants';\n\n@Component({\n  selector: 'app-link',\n  templateUrl: './link.component.html',\n  styleUrl: './link.component.scss',\n  providers: [{\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: LinkComponent,\n    multi: true\n  },\n  {\n    provide: NG_VALIDATORS,\n    multi: true,\n    useExisting: LinkComponent\n  }],\n})\nexport class LinkComponent implements OnInit, ControlValueAccessor, Validator{\n\n  @ViewChild('formDirective', {static : false}) \n  public formDirective: NgForm;\n\n  form: UntypedFormGroup;\n\n  /** denote if the control is required or not*/\n  @Input() isRequired : boolean = false;\n\n  /** Text to be displayed in link or button*/\n  @Input() text : string;\n\n  /** URI of the page to be opened */\n  @Input() uri : string;\n\n  /** URL of the external page to be opened */\n  @Input() externalUrl : string;\n\n  /** Render text as link*/\n  @Input() link : boolean;\n\n  onTouched: Function = () => { };\n\n  onChangeSubs: Subscription[] = [];\n\n  private onChange = (value : String) => {\n  \n  };\n\n  constructor(public fb: UntypedFormBuilder){\n\n  }\n\n  ngOnInit(): void {\n    this.form = this.fb.group({\n      isClicked: [null, this.isRequired ? Validators.required : null]\n    });\n\n    this.form.valueChanges.subscribe(val => {\n      if(this.form.valid){\n        this.onChange(this.isClicked.value);\n      }\n    })\n  }\n\n  get isClicked(){\n    return this.form.controls['isClicked'];\n  }\n\n  ngOnDestroy() {\n    for (let sub of this.onChangeSubs) {\n      sub.unsubscribe();\n    }\n  }\n\n  registerOnChange(onChange: any) {\n    this.onChange = onChange;\n  }\n\n  registerOnTouched(onTouched: Function) {\n    this.onTouched = onTouched;\n  } \n\n  writeValue(value: string): void {\n    this.isClicked.setValue(value)\n  }\n\n  setDisabledState?(isDisabled: boolean): void {\n    if (isDisabled) {\n      this.form.disable();\n    }\n    else {\n      this.form.enable();\n    }\n  }\n\n  validate(control: AbstractControl<any, any>): ValidationErrors {\n    return control.errors;\n  }\n\n  openLink(){\n    if(this.uri){\n      window.open(`${getBaseUrl()}/static-webapp/${LibConstants.state}/${this.uri}`, '_blank');\n    } else if(this.externalUrl){\n      window.open(`${this.externalUrl}`, '_blank');\n    }\n    this.isClicked.setValue('Y');\n  }\n}\n","<div [formGroup]=\"form\" #formDirective=\"ngForm\">\r\n    <div class=\"grid p-nogutter\">\r\n        <div class=\"col-12\">\r\n            <input type=\"text\" id=\"hidIsClickedBtnId\" pInputText formControlName=\"isClicked\" hidden />\r\n            <ion-button id=\"btnOpenExternalLink\" shape=\"round\" (click)=\"openLink()\" type=\"submit\" fill=\"outline\" style=\"margin: 0px;\">\r\n                <ion-icon slot=\"start\" [name]=\"isClicked.value === 'Y' ? 'checkmark-circle-outline' : 'ellipse-outline'\"\r\n                    style=\"font-size: 25px; font-weight: bold;\"></ion-icon>\r\n                {{text}}\r\n            </ion-button>\r\n            <app-error [field]='isClicked' [form]=\"formDirective\" [errDef]=\"{\r\n            required: 'required.'\r\n            }\"></app-error>\r\n        </div>\r\n    </div>\r\n</div>\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"link.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-reusa-app-lib/src/lib/components/link/link.component.ts","../../../../../../projects/ngx-reusa-app-lib/src/lib/components/link/link.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit, ViewChild } from '@angular/core';\r\nimport { AbstractControl, ControlValueAccessor, NG_VALIDATORS, NG_VALUE_ACCESSOR, NgForm, UntypedFormBuilder, UntypedFormGroup, ValidationErrors, Validator, Validators } from '@angular/forms';\r\nimport { Subscription } from 'rxjs';\r\nimport { LibConstants, getBaseUrl } from '../../models/LibConstants';\r\n\r\n@Component({\r\n  selector: 'app-link',\r\n  templateUrl: './link.component.html',\r\n  styleUrl: './link.component.scss',\r\n  providers: [{\r\n    provide: NG_VALUE_ACCESSOR,\r\n    useExisting: LinkComponent,\r\n    multi: true\r\n  },\r\n  {\r\n    provide: NG_VALIDATORS,\r\n    multi: true,\r\n    useExisting: LinkComponent\r\n  }],\r\n})\r\nexport class LinkComponent implements OnInit, ControlValueAccessor, Validator{\r\n\r\n  @ViewChild('formDirective', {static : false}) \r\n  public formDirective: NgForm;\r\n\r\n  form: UntypedFormGroup;\r\n\r\n  /** denote if the control is required or not*/\r\n  @Input() isRequired : boolean = false;\r\n\r\n  /** Text to be displayed in link or button*/\r\n  @Input() text : string;\r\n\r\n  /** URI of the page to be opened */\r\n  @Input() uri : string;\r\n\r\n  /** URL of the external page to be opened */\r\n  @Input() externalUrl : string;\r\n\r\n  /** Render text as link*/\r\n  @Input() link : boolean;\r\n\r\n  onTouched: Function = () => { };\r\n\r\n  onChangeSubs: Subscription[] = [];\r\n\r\n  private onChange = (value : String) => {\r\n  \r\n  };\r\n\r\n  constructor(public fb: UntypedFormBuilder){\r\n\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.form = this.fb.group({\r\n      isClicked: [null, this.isRequired ? Validators.required : null]\r\n    });\r\n\r\n    this.form.valueChanges.subscribe(val => {\r\n      if(this.form.valid){\r\n        this.onChange(this.isClicked.value);\r\n      }\r\n    })\r\n  }\r\n\r\n  get isClicked(){\r\n    return this.form.controls['isClicked'];\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    for (let sub of this.onChangeSubs) {\r\n      sub.unsubscribe();\r\n    }\r\n  }\r\n\r\n  registerOnChange(onChange: any) {\r\n    this.onChange = onChange;\r\n  }\r\n\r\n  registerOnTouched(onTouched: Function) {\r\n    this.onTouched = onTouched;\r\n  } \r\n\r\n  writeValue(value: string): void {\r\n    this.isClicked.setValue(value)\r\n  }\r\n\r\n  setDisabledState?(isDisabled: boolean): void {\r\n    if (isDisabled) {\r\n      this.form.disable();\r\n    }\r\n    else {\r\n      this.form.enable();\r\n    }\r\n  }\r\n\r\n  validate(control: AbstractControl<any, any>): ValidationErrors {\r\n    return control.errors;\r\n  }\r\n\r\n  openLink(){\r\n    if(this.uri){\r\n      window.open(`${getBaseUrl()}/static-webapp/${LibConstants.state}/${this.uri}`, '_blank');\r\n    } else if(this.externalUrl){\r\n      window.open(`${this.externalUrl}`, '_blank');\r\n    }\r\n    this.isClicked.setValue('Y');\r\n  }\r\n}\r\n","<div [formGroup]=\"form\" #formDirective=\"ngForm\">\r\n    <div class=\"grid p-nogutter\">\r\n        <div class=\"col-12\">\r\n            <input type=\"text\" id=\"hidIsClickedBtnId\" pInputText formControlName=\"isClicked\" hidden />\r\n            <ion-button id=\"btnOpenExternalLink\" shape=\"round\" (click)=\"openLink()\" type=\"submit\" fill=\"outline\" style=\"margin: 0px;\">\r\n                <ion-icon slot=\"start\" [name]=\"isClicked.value === 'Y' ? 'checkmark-circle-outline' : 'ellipse-outline'\"\r\n                    style=\"font-size: 25px; font-weight: bold;\"></ion-icon>\r\n                {{text}}\r\n            </ion-button>\r\n            <app-error [field]='isClicked' [form]=\"formDirective\" [errDef]=\"{\r\n            required: 'required.'\r\n            }\"></app-error>\r\n        </div>\r\n    </div>\r\n</div>\r\n"]}

package/esm2022/lib/components/maintenance-detector/maintenance-detector.component.mjs

@@ -40,4 +40,4 @@ export class MaintenanceDetectorComponent {
         args: [{ selector: 'app-maintenance-detector', template: "<p-blockUI [blocked]=\"blockUi\">\r\n    <ion-spinner name=\"crescent\"></ion-spinner>\r\n</p-blockUI>\r\n" }]
     }], () => [{ type: i1.MaintenanceService }, { type: i2.NavController }], null); })();
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(MaintenanceDetectorComponent, { className: "MaintenanceDetectorComponent", filePath: "lib\\components\\maintenance-detector\\maintenance-detector.component.ts", lineNumber: 12 }); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/mask/mask.component.mjs

@@ -45,4 +45,4 @@ export class MaskComponent {
             args: ['value']
         }] }); })();
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(MaskComponent, { className: "MaskComponent", filePath: "lib\\components\\mask\\mask.component.ts", lineNumber: 9 }); })();
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFzay5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtcmV1c2EtYXBwLWxpYi9zcmMvbGliL2NvbXBvbmVudHMvbWFzay9tYXNrLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1yZXVzYS1hcHAtbGliL3NyYy9saWIvY29tcG9uZW50cy9tYXNrL21hc2suY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQVUsTUFBTSxlQUFlLENBQUM7Ozs7Ozs7O0lDRXJELFlBQ0E7SUFBQSw0QkFBeUQ7OztJQUR6RCx3RkFDQTs7O0lBRkYsZ0ZBR2M7OztJQUVaLFlBQ0Y7OztJQURFLDZDQUNGOztBRENGLE1BQU0sT0FBTyxhQUFhO0lBSXhCLFlBQW1CLElBQWtCO1FBQWxCLFNBQUksR0FBSixJQUFJLENBQWM7SUFBSSxDQUFDO0lBRTFDLFFBQVE7SUFDUixDQUFDOzhFQVBVLGFBQWE7b0VBQWIsYUFBYTtZQ1IxQixvQ0FBdUQ7WUFDckQseURBR2MsaUVBQUE7WUFJaEIsaUJBQVk7O1lBUHdCLGVBQVc7WUFBWCxnQ0FBVzs7O2lGRE9sQyxhQUFhO2NBTHpCLFNBQVM7MkJBQ0UsVUFBVTs0Q0FNSixLQUFLO2tCQUFwQixLQUFLO21CQUFDLE9BQU87O2tGQUZILGFBQWEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIElucHV0LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFV0aWxTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vc2VydmljZXMvdXRpbC91dGlsLnNlcnZpY2UnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdhcHAtbWFzaycsXG4gIHRlbXBsYXRlVXJsOiAnLi9tYXNrLmNvbXBvbmVudC5odG1sJyxcbiAgc3R5bGVVcmxzOiBbJy4vbWFzay5jb21wb25lbnQuc2NzcyddXG59KVxuZXhwb3J0IGNsYXNzIE1hc2tDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuXG4gIEBJbnB1dCgndmFsdWUnKSB2YWx1ZSA6IHN0cmluZztcbiAgXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyB1dGlsIDogVXRpbFNlcnZpY2UpIHsgfVxuXG4gIG5nT25Jbml0KCk6IHZvaWQge1xuICB9XG59XG4iLCI8cC1pbnBsYWNlIGNsb3NhYmxlPVwidHJ1ZVwiIGNsb3NlSWNvbj1cInBpIHBpLWV5ZS1zbGFzaFwiPlxyXG4gIDxuZy10ZW1wbGF0ZSBwVGVtcGxhdGU9XCJkaXNwbGF5XCIgKm5nSWY9XCJ2YWx1ZVwiPlxyXG4gICAge3t1dGlsLm1hc2sodmFsdWUsIHZhbHVlLmxlbmd0aC8yKX19XHJcbiAgICA8YnV0dG9uIHBCdXR0b24gdHlwZT1cImJ1dHRvblwiIGljb249XCJwaSBwaS1leWVcIiA+PC9idXR0b24+XHJcbiAgPC9uZy10ZW1wbGF0ZT5cclxuICA8bmctdGVtcGxhdGUgcFRlbXBsYXRlPVwiY29udGVudFwiPlxyXG4gICAge3t2YWx1ZX19XHJcbiAgPC9uZy10ZW1wbGF0ZT5cclxuPC9wLWlucGxhY2U+Il19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFzay5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtcmV1c2EtYXBwLWxpYi9zcmMvbGliL2NvbXBvbmVudHMvbWFzay9tYXNrLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1yZXVzYS1hcHAtbGliL3NyYy9saWIvY29tcG9uZW50cy9tYXNrL21hc2suY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQVUsTUFBTSxlQUFlLENBQUM7Ozs7Ozs7O0lDRXJELFlBQ0E7SUFBQSw0QkFBeUQ7OztJQUR6RCx3RkFDQTs7O0lBRkYsZ0ZBR2M7OztJQUVaLFlBQ0Y7OztJQURFLDZDQUNGOztBRENGLE1BQU0sT0FBTyxhQUFhO0lBSXhCLFlBQW1CLElBQWtCO1FBQWxCLFNBQUksR0FBSixJQUFJLENBQWM7SUFBSSxDQUFDO0lBRTFDLFFBQVE7SUFDUixDQUFDOzhFQVBVLGFBQWE7b0VBQWIsYUFBYTtZQ1IxQixvQ0FBdUQ7WUFDckQseURBR2MsaUVBQUE7WUFJaEIsaUJBQVk7O1lBUHdCLGVBQVc7WUFBWCxnQ0FBVzs7O2lGRE9sQyxhQUFhO2NBTHpCLFNBQVM7MkJBQ0UsVUFBVTs0Q0FNSixLQUFLO2tCQUFwQixLQUFLO21CQUFDLE9BQU87O2tGQUZILGFBQWEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIElucHV0LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgVXRpbFNlcnZpY2UgfSBmcm9tICcuLi8uLi9zZXJ2aWNlcy91dGlsL3V0aWwuc2VydmljZSc7XHJcblxyXG5AQ29tcG9uZW50KHtcclxuICBzZWxlY3RvcjogJ2FwcC1tYXNrJyxcclxuICB0ZW1wbGF0ZVVybDogJy4vbWFzay5jb21wb25lbnQuaHRtbCcsXHJcbiAgc3R5bGVVcmxzOiBbJy4vbWFzay5jb21wb25lbnQuc2NzcyddXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBNYXNrQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0IHtcclxuXHJcbiAgQElucHV0KCd2YWx1ZScpIHZhbHVlIDogc3RyaW5nO1xyXG4gIFxyXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyB1dGlsIDogVXRpbFNlcnZpY2UpIHsgfVxyXG5cclxuICBuZ09uSW5pdCgpOiB2b2lkIHtcclxuICB9XHJcbn1cclxuIiwiPHAtaW5wbGFjZSBjbG9zYWJsZT1cInRydWVcIiBjbG9zZUljb249XCJwaSBwaS1leWUtc2xhc2hcIj5cclxuICA8bmctdGVtcGxhdGUgcFRlbXBsYXRlPVwiZGlzcGxheVwiICpuZ0lmPVwidmFsdWVcIj5cclxuICAgIHt7dXRpbC5tYXNrKHZhbHVlLCB2YWx1ZS5sZW5ndGgvMil9fVxyXG4gICAgPGJ1dHRvbiBwQnV0dG9uIHR5cGU9XCJidXR0b25cIiBpY29uPVwicGkgcGktZXllXCIgPjwvYnV0dG9uPlxyXG4gIDwvbmctdGVtcGxhdGU+XHJcbiAgPG5nLXRlbXBsYXRlIHBUZW1wbGF0ZT1cImNvbnRlbnRcIj5cclxuICAgIHt7dmFsdWV9fVxyXG4gIDwvbmctdGVtcGxhdGU+XHJcbjwvcC1pbnBsYWNlPiJdfQ==