@ksremp/ngx-ksremp-app-lib 1.0.0

package/esm2022/lib/services/util/util.service.mjs

@@ -0,0 +1,450 @@
+import { Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { Validators } from '@angular/forms';
+import { ErrorModel } from '../../models/ErrorModel';
+import { getBaseUrl, LibConstants } from '../../models/LibConstants';
+import { ActivationEnd, NavigationEnd, NavigationStart } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+import * as i2 from "@angular/common/http";
+import * as i3 from "primeng/api";
+import * as i4 from "ngx-spinner";
+import * as i5 from "@ngx-loading-bar/core";
+import * as i6 from "../logger/logger.service";
+import * as i7 from "@angular/router";
+import * as i8 from "@angular/platform-browser";
+import * as i9 from "../tour/tour.service";
+export class UtilService {
+    constructor(alertController, httpClient, lc, toastController, msgService, spinner, loader, logger, router, titleService, ar, tourService, platform) {
+        this.alertController = alertController;
+        this.httpClient = httpClient;
+        this.lc = lc;
+        this.toastController = toastController;
+        this.msgService = msgService;
+        this.spinner = spinner;
+        this.loader = loader;
+        this.logger = logger;
+        this.router = router;
+        this.titleService = titleService;
+        this.ar = ar;
+        this.tourService = tourService;
+        this.platform = platform;
+        this.focusables = ["pinputtext", "p-inputmask", "input", "select", "textarea", "p-calendar", "radio", "p-dropdown", "p-selectButton", "p-autocomplete", "p-password", "p-checkbox", "p-inputtextarea"];
+        /*To display various messages*/
+        this.msgs = [];
+        this.options = {};
+        this.loading = null;
+        let headers = new HttpHeaders({
+            'Content-Type': 'application/json',
+            "Accept": 'application/json'
+        });
+        this.options = { headers: headers };
+    }
+    async toast(msg) {
+        const toast = await this.toastController.create({
+            message: msg,
+            position: 'bottom',
+            duration: 2000,
+            keyboardClose: true,
+            buttons: [
+                {
+                    text: 'Done',
+                    role: 'cancel',
+                    handler: () => {
+                    }
+                }
+            ]
+        });
+        toast.present();
+    }
+    async presentToast(msg) {
+        const toast = await this.toastController.create({
+            message: msg,
+            color: 'danger',
+            duration: 3000,
+            keyboardClose: true,
+            buttons: [
+                {
+                    text: 'Done',
+                    role: 'cancel',
+                    handler: () => {
+                    }
+                }
+            ]
+        });
+        toast.present();
+    }
+    baseUrl() {
+        return getBaseUrl();
+    }
+    async presentAlert(header, subMsg, errDtl) {
+        const alert = await this.alertController.create({
+            header: header,
+            subHeader: subMsg,
+            message: errDtl,
+            buttons: ['OK']
+        });
+        await alert.present();
+    }
+    error(header, subMsg, errDtl) {
+        this.presentAlert(header, subMsg, errDtl);
+    }
+    showError(msg) {
+        let errDtl = new ErrorModel();
+        errDtl.msg = msg;
+        this.errorMsg(errDtl);
+    }
+    errorMsg(errDtl) {
+        this.msgs.push({ severity: 'error', summary: 'Error', detail: errDtl.msg });
+        this.msgService.clear();
+        if (errDtl.errorId) {
+            //this.msgService.add({severity:'error', summary:'Error', detail: errDtl.msg + `( error id : ${errDtl.errorId})`, life: 7000, id : errDtl.errorId});
+            this.msgService.add({ severity: 'error', summary: 'Error', detail: errDtl.msg, life: 7000, id: errDtl.errorId });
+        }
+        else {
+            this.msgService.add({ severity: 'error', summary: 'Error', detail: errDtl.msg, life: 7000, id: errDtl.errorId });
+        }
+    }
+    async success(msg) {
+        this.msgs = [];
+        this.msgs.push({ severity: 'success', summary: 'Success', detail: msg });
+        this.msgService.clear();
+        this.msgService.add({ severity: 'success', summary: 'Success', detail: msg, life: 7000 });
+    }
+    info(msg) {
+        this.presentAlert('Info', '', msg);
+    }
+    get(endPoint, options, serviceName) {
+        return this.httpClient.get(this.getUrl(endPoint, serviceName), options != null ? options : this.options);
+    }
+    post(url, body, options, serviceName) {
+        return this.httpClient.post(this.getUrl(url, serviceName), JSON.stringify(body), options != null ? options : this.options);
+    }
+    postFormData(url, body, options, serviceName) {
+        // alert(this.getFullUrl(url));
+        return this.httpClient.post(this.getUrl(url, serviceName), body, options);
+    }
+    delete(url, options, serviceName) {
+        return this.httpClient.delete(this.getUrl(url, serviceName), options != null ? options : this.options);
+    }
+    patch(url, body, options, serviceName) {
+        return this.httpClient.patch(this.getUrl(url, serviceName), body, options != null ? options : this.options);
+    }
+    errorHandler(error) {
+        this.msgs = [];
+        this.logger.error('error ---->', error);
+        this.errorMsg(error);
+    }
+    getFullUrl(endPoint) {
+        return this.baseUrl() + endPoint;
+    }
+    getUrl(endPoint, serviceName) {
+        if (serviceName) {
+            this.baseUrl() + LibConstants.forwardSlash + serviceName + LibConstants.forwardSlash + endPoint;
+        }
+        else {
+            return this.baseUrl() + (LibConstants.context == ''
+                ? LibConstants.forwardSlash
+                : LibConstants.forwardSlash + LibConstants.context + LibConstants.forwardSlash) + endPoint;
+        }
+    }
+    async showLoader() {
+        this.spinner.show();
+    }
+    async hideLoader() {
+        this.spinner.hide();
+    }
+    /**
+     * @decription This method will find difference of dates by specified interval
+     * @author Prerak Tiwari
+     * @version 1.0
+     * @param fromDate in miliseconds
+     * @param todate in miliseconds
+     * @param interval : valid values are --> "years", "months", "weeks", "days", "hours", "minutes", "seconds"
+     * @returns difference of date as per interval specified.
+     **/
+    findDifferenceIndate(fromDate, todate, interval) {
+        let second = 1000, minute = second * 60, hour = minute * 60, day = hour * 24, week = day * 7;
+        let timediff = todate - fromDate;
+        if (isNaN(timediff))
+            return NaN;
+        switch (interval) {
+            case "years": return todate.getFullYear() - fromDate.getFullYear();
+            case "months": return ((todate.getFullYear() * 12 + todate.getMonth())
+                -
+                    (fromDate.getFullYear() * 12 + fromDate.getMonth()));
+            case "weeks": return Math.round(timediff / week);
+            case "days": return Math.round(timediff / day);
+            case "hours": return Math.round(timediff / hour);
+            case "minutes": return Math.round(timediff / minute);
+            case "seconds": return Math.round(timediff / second);
+            default: return undefined;
+        }
+    }
+    /**
+     * @decription This method will return date in ddMMyyyy format.
+     * @author Prerak Tiwari
+     * @version 1.0
+     * @returns string
+     **/
+    getDateInMMDDYYYYFormat(date) {
+        let dd = date.getDate();
+        let MM = date.getMonth() + 1;
+        let yyyy = date.getFullYear();
+        let dateToReturn = MM + '/' + dd + '/' + yyyy;
+        return dateToReturn;
+    }
+    /**
+     * @decription This method will return Date object (for yyyy/MM/dd)
+     * @author Prerak Tiwari
+     * @version 1.0
+     * @param value : date separated with '-'
+     * @returns Date
+     **/
+    getEnteredDate(value) {
+        var dateArray = value.split("-");
+        var dd = parseInt(this.prepedZeroIfSingleDigit(dateArray[2]));
+        var MM = parseInt(this.prepedZeroIfSingleDigit(dateArray[1])) - 1;
+        var yyyy = parseInt(this.prepedZeroIfSingleDigit(dateArray[0]));
+        return new Date(yyyy, MM, dd);
+    }
+    /**
+     * @decription This method will return Date object (for MM/dd/yyyy).
+     * @author Prerak Tiwari
+     * @version 1.0
+     * @param value : date separated with '-'
+     * @returns Date
+     **/
+    getDateFromString(value) {
+        var dateArray = value.split("-");
+        var dd = parseInt(this.prepedZeroIfSingleDigit(dateArray[2]));
+        var MM = parseInt(this.prepedZeroIfSingleDigit(dateArray[1])) - 1;
+        var yyyy = parseInt(this.prepedZeroIfSingleDigit(dateArray[0]));
+        return new Date(yyyy, MM, dd);
+    }
+    getEnteredDateFromString(value) {
+        var dateArray = value.split("/");
+        var MM = parseInt(this.prepedZeroIfSingleDigit(dateArray[0])) - 1;
+        var dd = parseInt(this.prepedZeroIfSingleDigit(dateArray[1]));
+        var yyyy = parseInt(this.prepedZeroIfSingleDigit(dateArray[2]));
+        return new Date(yyyy, MM, dd);
+    }
+    getDateInMMDDYYYY(value) {
+        var dateArray = value.split("-");
+        var dd = parseInt(this.prepedZeroIfSingleDigit(dateArray[2]));
+        var MM = parseInt(this.prepedZeroIfSingleDigit(dateArray[1]));
+        var yyyy = parseInt(this.prepedZeroIfSingleDigit(dateArray[0]));
+        return MM + '/' + dd + '/' + yyyy;
+    }
+    prepedZeroIfSingleDigit(number) {
+        number = number + LibConstants.blankString;
+        if (number.length < 2) {
+            number = "0" + number;
+        }
+        return number;
+    }
+    /**
+    * @decription This method check if entered number is valid or not.
+    * @author Prerak Tiwari
+    * @version 1.0
+    * @returns true : number is valid </br> false : number is invalid
+    */
+    validateNumber(number) {
+        var reg = new RegExp("^[0-9]*$");
+        return reg.test(number);
+    }
+    /**
+    * @decription This method check if entered number is valid or not.
+    * @author Prerak Tiwari
+    * @version 1.0
+    * @returns true : number is valid </br> false : number is invalid
+    */
+    validateEmail(email) {
+        var reg = new RegExp('/^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/');
+        return reg.test(email);
+    }
+    setValidation(control, newValidator) {
+        control.setValidators(newValidator);
+        control.updateValueAndValidity();
+    }
+    clearValidation(control) {
+        control.clearValidators();
+        control.updateValueAndValidity();
+    }
+    setRequiredValidator(control) {
+        this.setValidation(control, Validators.required);
+    }
+    // @dynamic
+    static patternValidator(regex, error) {
+        const res = (control) => {
+            if (!control.value) {
+                // if control is empty return no error
+                return null;
+            }
+            // test the value of the control against the regexp supplied
+            const valid = regex.test(control.value);
+            // if true, return no error (no error), else return error passed in the second parameter
+            return valid ? null : error;
+        };
+        return res;
+    }
+    static passwordMatchValidator(control) {
+        const password = control.get('password').value; // get password from our password form control
+        const confirmPassword = control.get('confirmPassword').value; // get password from our confirmPassword form control
+        // compare is the password math
+        if (password !== confirmPassword) {
+            // if they don't match, set an error in our confirmPassword form control
+            control.get('confirmPassword').setErrors({ NoPassswordMatch: true });
+        }
+    }
+    formatSsn(ssn) {
+        return ssn.substr(0, 3) + '-' + ssn.substr(3, 2) + '-' + ssn.substr(5, 4);
+    }
+    maskSsn(ssn) {
+        return 'XXX-XX-' + ssn.substr(5, 4);
+    }
+    mask(value, charToHide) {
+        if (!value) {
+            return;
+        }
+        if (value.length > charToHide) {
+            var xxx = '';
+            for (var count = 1; count <= charToHide; count++) {
+                xxx = 'X' + xxx;
+            }
+            return xxx + value.substr(value.length - charToHide + 1, charToHide);
+        }
+        else {
+            return value;
+        }
+    }
+    clearMessages() {
+        this.msgs = [];
+    }
+    isState(state) {
+        return this.getStateLowercase() == state.toLowerCase();
+    }
+    getState() {
+        return LibConstants.STATE;
+    }
+    getStateLowercase() {
+        return LibConstants.state;
+    }
+    setupNavigationBasedEvents() {
+        this.router.events.subscribe(val => {
+            if (val instanceof NavigationStart) {
+                this.msgs = [];
+                this.msgService.clear(); //Clear Error/Success Messages
+                this.tourService.setCurrentStepsCount(20); //Joyride Setup
+            }
+            if (val instanceof NavigationEnd) {
+                gtag('config', LibConstants.gaId, { 'page_path': val.urlAfterRedirects }); //Send to Goole Analytics
+            }
+            if (val instanceof ActivationEnd) {
+                this.setPageTitle(val.snapshot); //Set Page Title
+                this.tourService.setSetpsCount(val.snapshot.data['pageId']);
+                this.hideLoader();
+            }
+        });
+    }
+    setPageTitle(snapshot) {
+        let title = snapshot.data['title'];
+        if (title) {
+            this.titleService.setTitle(title);
+        }
+        else {
+            throw "Please specify page title in app-routing.module.ts file for page :: " + this.ar.firstChild.snapshot.url;
+        }
+    }
+    /**
+     * @decription This method will return context root of the application
+     * @author Prerak Tiwari
+     * @version 1.0
+     * @param value : context root of application. e.g if application is running on 'http://localhost:9080/cp/page' then this method will return 'cp'
+     * @returns String
+     **/
+    getContextRoot() {
+        return window.location.pathname.substring(0, window.location.pathname.indexOf("/", 2));
+    }
+    getClaimantAppContextRoot() {
+        return "/cp";
+    }
+    getSecurityAppContextRoot() {
+        return "/ss";
+    }
+    openPageByContextRoot(context, uri, nav) {
+        if (!context.startsWith('/')) {
+            context = '/' + context;
+        }
+        if (nav && context.includes(this.getContextRoot())) {
+            nav.navigateForward(uri);
+        }
+        else {
+            window.open(location.origin + `${context}/${uri}`, '_self');
+        }
+    }
+    openPageByContextRootWithData(context, uri, data, nav) {
+        if (!context.startsWith('/')) {
+            context = '/' + context;
+        }
+        let separator = '&';
+        if (!uri.includes('?')) {
+            separator = "?";
+        }
+        if (nav && context.includes(this.getContextRoot())) {
+            nav.navigateForward(`${uri}${separator}data=${btoa(JSON.stringify(data))}`);
+        }
+        else {
+            window.open(location.origin + `${context}/${uri}${separator}data=${btoa(JSON.stringify(data))}`, '_self');
+        }
+    }
+    maskExceptFirstAndLastChar(value) {
+        return value[0] + "*".repeat(value.length - 2) + value.slice(-1);
+    }
+    maskEmail(email) {
+        var parts = email.split("@");
+        if (parts.length == 2) {
+            return this.maskExceptFirstAndLastChar(parts[0]) + "@" + this.maskExceptFirstAndLastChar(parts[1]);
+        }
+        return this.maskExceptFirstAndLastChar(parts[0]);
+    }
+    isPlayformCapacitor() {
+        return this.platform.is('capacitor');
+    }
+    isNewPasswordPolicyEnabled() {
+        return LibConstants.isNewPasswordPolicyEnabled == 'true';
+    }
+    isSameSymbolPolicyForClaimantAndAgency() {
+        return LibConstants.isSameSymbolPolicyForClaimantAndAgency == 'true';
+    }
+    focusOnSubmit(el) {
+        var element = el.nativeElement.querySelector(this.focusables.map(x => `${x}.ng-invalid`).join(","));
+        if (element) {
+            var primeNgComponent = element.querySelector(this.focusables.map(x => `${x}.p-component`).join(","));
+            if (primeNgComponent) {
+                primeNgComponent.focus();
+            }
+            else {
+                element.focus();
+            }
+            //Block for Radio Button Start
+            var primeNgComponent1 = element.querySelector("div.p-selectbutton");
+            if (primeNgComponent1) {
+                var primeNgComponent2 = primeNgComponent1.querySelector("div.p-component");
+                if (primeNgComponent2) {
+                    primeNgComponent2.focus();
+                }
+            }
+            //Block for Radio Button End
+        }
+    }
+    static { this.ɵfac = function UtilService_Factory(t) { return new (t || UtilService)(i0.ɵɵinject(i1.AlertController), i0.ɵɵinject(i2.HttpClient), i0.ɵɵinject(i1.LoadingController), i0.ɵɵinject(i1.ToastController), i0.ɵɵinject(i3.MessageService), i0.ɵɵinject(i4.NgxSpinnerService), i0.ɵɵinject(i5.LoadingBarService), i0.ɵɵinject(i6.LoggerService), i0.ɵɵinject(i7.Router), i0.ɵɵinject(i8.Title), i0.ɵɵinject(i7.ActivatedRoute), i0.ɵɵinject(i9.TourService), i0.ɵɵinject(i1.Platform)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: UtilService, factory: UtilService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(UtilService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.AlertController }, { type: i2.HttpClient }, { type: i1.LoadingController }, { type: i1.ToastController }, { type: i3.MessageService }, { type: i4.NgxSpinnerService }, { type: i5.LoadingBarService }, { type: i6.LoggerService }, { type: i7.Router }, { type: i8.Title }, { type: i7.ActivatedRoute }, { type: i9.TourService }, { type: i1.Platform }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-reusa-app-lib/src/lib/services/util/util.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef, Injectable } from '@angular/core';\r\nimport { AlertController, LoadingController, NavController, Platform, ToastController } from '@ionic/angular';\r\nimport { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';\r\nimport { Observable } from 'rxjs';\r\nimport { AbstractControl, ValidatorFn, Validators, ValidationErrors } from '@angular/forms';\r\nimport {Message} from 'primeng/api';\r\nimport {MessageService} from 'primeng/api';\r\nimport { NgxSpinnerService } from \"ngx-spinner\";\r\nimport { LoadingBarService } from '@ngx-loading-bar/core';\r\nimport { ErrorModel } from '../../models/ErrorModel';\r\nimport { getBaseUrl, LibConstants } from '../../models/LibConstants';\r\nimport { LoggerService } from '../logger/logger.service';\r\nimport { ActivatedRoute, ActivationEnd, NavigationEnd, NavigationStart, Router } from '@angular/router';\r\nimport { Title } from '@angular/platform-browser';\r\nimport { TourService } from '../tour/tour.service';\r\n\r\ndeclare let gtag: any;\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class UtilService {\r\n\r\n  focusables = [\"pinputtext\", \"p-inputmask\", \"input\", \"select\", \"textarea\", \"p-calendar\", \"radio\", \"p-dropdown\", \"p-selectButton\", \"p-autocomplete\", \"p-password\",\"p-checkbox\", \"p-inputtextarea\"];\r\n\r\n  /*To display various messages*/\r\n  public msgs: Message[] = [];\r\n\r\n  options = {};\r\n\r\n  loading  = null;\r\n  \r\n  constructor(public alertController: AlertController, public httpClient: HttpClient, public lc : LoadingController, \r\n              public toastController: ToastController, public msgService: MessageService, private spinner: NgxSpinnerService,\r\n              public loader: LoadingBarService, private logger: LoggerService, private router: Router, \r\n              private titleService: Title, private ar: ActivatedRoute, private tourService: TourService,\r\n              private platform: Platform) { \r\n    let headers = new HttpHeaders({\r\n      'Content-Type': 'application/json',\r\n      \"Accept\": 'application/json'});\r\n    this.options = { headers: headers };\r\n  }\r\n\r\n  async toast(msg : string){\r\n    const toast = await this.toastController.create({\r\n      message: msg,\r\n      position: 'bottom',\r\n      duration: 2000,\r\n      keyboardClose: true,\r\n      buttons: [\r\n        {\r\n          text: 'Done',\r\n          role: 'cancel',\r\n          handler: () => {\r\n          }\r\n        }\r\n      ]\r\n    });\r\n    toast.present();\r\n  }\r\n\r\n  async presentToast(msg : string) {\r\n    const toast = await this.toastController.create({\r\n      message: msg,\r\n      color: 'danger',\r\n      duration: 3000,\r\n      keyboardClose: true,\r\n      buttons: [\r\n        {\r\n          text: 'Done',\r\n          role: 'cancel',\r\n          handler: () => {\r\n          }\r\n        }\r\n      ]\r\n    });\r\n    toast.present();\r\n  }\r\n\r\n  baseUrl() : string{\r\n    return getBaseUrl();\r\n  }\r\n\r\n  async presentAlert(header, subMsg, errDtl) {\r\n    const alert = await this.alertController.create({\r\n      header: header,\r\n      subHeader: subMsg,\r\n      message: errDtl,\r\n      buttons: ['OK']\r\n    });\r\n\r\n    await alert.present();\r\n  }\r\n\r\n  error(header, subMsg, errDtl){\r\n    this.presentAlert(header, subMsg, errDtl);\r\n  }\r\n\r\n  showError(msg : string){\r\n    let errDtl : ErrorModel = new ErrorModel();\r\n    errDtl.msg = msg;\r\n    this.errorMsg(errDtl);\r\n  }\r\n\r\n  errorMsg(errDtl : ErrorModel){\r\n    this.msgs.push({severity: 'error', summary : 'Error', detail : errDtl.msg});\r\n    this.msgService.clear();\r\n    if(errDtl.errorId){\r\n      //this.msgService.add({severity:'error', summary:'Error', detail: errDtl.msg + `( error id : ${errDtl.errorId})`, life: 7000, id : errDtl.errorId});\r\n      this.msgService.add({severity:'error', summary:'Error', detail: errDtl.msg, life: 7000, id : errDtl.errorId});\r\n    }else{\r\n      this.msgService.add({severity:'error', summary:'Error', detail: errDtl.msg, life: 7000, id : errDtl.errorId});\r\n    }\r\n  }\r\n\r\n  async success(msg){\r\n    this.msgs = [];\r\n    this.msgs.push({severity: 'success', summary : 'Success', detail : msg});\r\n\r\n    this.msgService.clear();\r\n    this.msgService.add({severity:'success', summary:'Success', detail: msg, life: 7000});\r\n  }\r\n\r\n  info(msg){\r\n    this.presentAlert('Info', '', msg);\r\n  }\r\n\r\n  get<T>(endPoint : string, options?: {\r\n      headers?: HttpHeaders | {\r\n          [header: string]: string | string[];\r\n      };\r\n      observe?: 'body';\r\n      params?: HttpParams | {\r\n          [param: string]: string | string[];\r\n      };\r\n      reportProgress?: boolean;\r\n      responseType?: 'json';\r\n      withCredentials?: boolean;\r\n  }, serviceName? : string): Observable<T>{\r\n    return this.httpClient.get<T>(this.getUrl(endPoint, serviceName), options != null ? options : this.options);\r\n  }\r\n\r\n  post<T>(url: string, body: any | null, options?: {\r\n      headers?: HttpHeaders | {\r\n          [header: string]: string | string[];\r\n      };\r\n      observe?: 'body';\r\n      params?: HttpParams | {\r\n          [param: string]: string | string[];\r\n      };\r\n      reportProgress?: boolean;\r\n      responseType?: 'json';\r\n      withCredentials?: boolean;\r\n    }, serviceName? : string): Observable<T> {\r\n    return this.httpClient.post<T>(this.getUrl(url, serviceName), JSON.stringify(body), options != null ? options : this.options);\r\n  }\r\n\r\n  postFormData<T>(url: string, body: any | null, options?: {\r\n    headers?: HttpHeaders | {\r\n        [header: string]: string | string[];\r\n    };\r\n    observe?: 'body';\r\n    params?: HttpParams | {\r\n        [param: string]: string | string[];\r\n    };\r\n    reportProgress?: boolean;\r\n    responseType?: 'json';\r\n    withCredentials?: boolean;\r\n  }, serviceName? : string): Observable<T> {\r\n   // alert(this.getFullUrl(url));\r\n    return this.httpClient.post<T>(this.getUrl(url, serviceName), body, options);\r\n  }\r\n\r\n  delete<T>(url: string, options?: {\r\n    headers?: HttpHeaders | {\r\n        [header: string]: string | string[];\r\n    };\r\n    observe?: 'body';\r\n    params?: HttpParams | {\r\n        [param: string]: string | string[];\r\n    };\r\n    reportProgress?: boolean;\r\n    responseType?: 'json';\r\n    withCredentials?: boolean;\r\n  }, serviceName? : string): Observable<T> {\r\n    return this.httpClient.delete<T>(this.getUrl(url, serviceName), options != null ? options : this.options);\r\n  }\r\n\r\n  patch<T>(url: string, body: any | null, options?: {\r\n    headers?: HttpHeaders | {\r\n        [header: string]: string | string[];\r\n    };\r\n    observe?: 'body';\r\n    params?: HttpParams | {\r\n        [param: string]: string | string[];\r\n    };\r\n    reportProgress?: boolean;\r\n    responseType?: 'json';\r\n    withCredentials?: boolean;\r\n}, serviceName ?: string): Observable<T> {\r\n    return this.httpClient.patch<T>(this.getUrl(url, serviceName), body, options != null ? options : this.options);\r\n  }\r\n\r\n  errorHandler(error){\r\n    this.msgs = [];\r\n    this.logger.error('error ---->', error);\r\n    this.errorMsg(error);\r\n  }\r\n\r\n  getFullUrl(endPoint : string){\r\n    return this.baseUrl() + endPoint;\r\n  }\r\n\r\n  getUrl(endPoint : string, serviceName : string){\r\n    if(serviceName){\r\n      this.baseUrl() + LibConstants.forwardSlash + serviceName + LibConstants.forwardSlash + endPoint;\r\n    }else{\r\n      return this.baseUrl() + (LibConstants.context == '' \r\n                              ? LibConstants.forwardSlash \r\n                              : LibConstants.forwardSlash + LibConstants.context + LibConstants.forwardSlash) + endPoint;\r\n    }\r\n  }\r\n\r\nasync showLoader() {\r\n  this.spinner.show()\r\n}\r\n\r\n  async hideLoader(){\r\n    this.spinner.hide();\r\n  }\r\n\r\n  /**\r\n   * @decription This method will find difference of dates by specified interval\r\n   * @author Prerak Tiwari\r\n   * @version 1.0\r\n   * @param fromDate in miliseconds\r\n   * @param todate in miliseconds\r\n   * @param interval : valid values are --> \"years\", \"months\", \"weeks\", \"days\", \"hours\", \"minutes\", \"seconds\"\r\n   * @returns difference of date as per interval specified.\r\n   **/\r\n  findDifferenceIndate(fromDate,todate,interval){\r\n    let second=1000, minute=second*60, hour=minute*60, day=hour*24, week=day*7;\r\n    let timediff = todate - fromDate;\r\n    \r\n    if (isNaN(timediff)) \r\n      return NaN;\r\n    \r\n    switch (interval) {\r\n        case \"years\": return todate.getFullYear() - fromDate.getFullYear();\r\n        case \"months\": return (\r\n            ( todate.getFullYear() * 12 + todate.getMonth() )\r\n            -\r\n            ( fromDate.getFullYear() * 12 + fromDate.getMonth() )\r\n        );\r\n        case \"weeks\"  : return Math.round(timediff / week);\r\n        case \"days\"   : return Math.round(timediff / day); \r\n        case \"hours\"  : return Math.round(timediff / hour); \r\n        case \"minutes\": return Math.round(timediff / minute);\r\n        case \"seconds\": return Math.round(timediff / second);\r\n        default: return undefined;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @decription This method will return date in ddMMyyyy format.\r\n   * @author Prerak Tiwari\r\n   * @version 1.0\r\n   * @returns string\r\n   **/\r\n  getDateInMMDDYYYYFormat(date : Date){\r\n    let dd = date.getDate();\r\n    let MM = date.getMonth() + 1;\r\n    let yyyy = date.getFullYear();\r\n    \r\n    let dateToReturn =  MM + '/' + dd + '/' + yyyy;\r\n    return dateToReturn;\r\n  }\r\n\r\n  /**\r\n   * @decription This method will return Date object (for yyyy/MM/dd)\r\n   * @author Prerak Tiwari\r\n   * @version 1.0\r\n   * @param value : date separated with '-'\r\n   * @returns Date\r\n   **/\r\n  getEnteredDate(value){\r\n    var dateArray = value.split(\"-\");\r\n    var dd = parseInt(this.prepedZeroIfSingleDigit(dateArray[2]));\r\n    var MM = parseInt(this.prepedZeroIfSingleDigit(dateArray[1])) - 1;\r\n    var yyyy = parseInt(this.prepedZeroIfSingleDigit(dateArray[0]));\r\n    return new Date(yyyy,MM,dd);\r\n  }\r\n\r\n  /**\r\n   * @decription This method will return Date object (for MM/dd/yyyy).\r\n   * @author Prerak Tiwari\r\n   * @version 1.0\r\n   * @param value : date separated with '-'\r\n   * @returns Date\r\n   **/\r\n  getDateFromString(value){\r\n    var dateArray = value.split(\"-\");\r\n    var dd = parseInt(this.prepedZeroIfSingleDigit(dateArray[2]));\r\n    var MM = parseInt(this.prepedZeroIfSingleDigit(dateArray[1])) - 1;\r\n    var yyyy = parseInt(this.prepedZeroIfSingleDigit(dateArray[0]));\r\n    return new Date(yyyy,MM,dd);\r\n  }\r\n\r\n  getEnteredDateFromString(value){\r\n    var dateArray = value.split(\"/\");\r\n    var MM = parseInt(this.prepedZeroIfSingleDigit(dateArray[0])) - 1;\r\n    var dd = parseInt(this.prepedZeroIfSingleDigit(dateArray[1]));\r\n    var yyyy = parseInt(this.prepedZeroIfSingleDigit(dateArray[2]));\r\n    return new Date(yyyy,MM,dd);\r\n  }\r\n\r\n  getDateInMMDDYYYY(value){\r\n    var dateArray = value.split(\"-\");\r\n    var dd = parseInt(this.prepedZeroIfSingleDigit(dateArray[2]));\r\n    var MM = parseInt(this.prepedZeroIfSingleDigit(dateArray[1]));\r\n    var yyyy = parseInt(this.prepedZeroIfSingleDigit(dateArray[0]));\r\n    return MM + '/' + dd + '/' + yyyy;\r\n  }\r\n\r\n  prepedZeroIfSingleDigit(number){\r\n    number = number + LibConstants.blankString;\r\n    if(number.length < 2){\r\n      number = \"0\" + number;\r\n    }\r\n    return number;\r\n  }\r\n\r\n  /**\r\n  * @decription This method check if entered number is valid or not.\r\n  * @author Prerak Tiwari\r\n  * @version 1.0\r\n  * @returns true : number is valid </br> false : number is invalid\r\n  */\r\n  validateNumber(number) {\r\n    var reg = new RegExp(\"^[0-9]*$\"); \r\n    return reg.test(number);\r\n  }\r\n\r\n  /**\r\n  * @decription This method check if entered number is valid or not.\r\n  * @author Prerak Tiwari\r\n  * @version 1.0\r\n  * @returns true : number is valid </br> false : number is invalid\r\n  */\r\n  validateEmail(email) {\r\n    var reg = new RegExp('/^(([^<>()\\[\\]\\\\.,;:\\s@\"]+(\\.[^<>()\\[\\]\\\\.,;:\\s@\"]+)*)|(\".+\"))@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$/'); \r\n    return reg.test(email);\r\n  }\r\n\r\n  setValidation(control : AbstractControl, newValidator : ValidatorFn  | ValidatorFn[] | null){\r\n    control.setValidators(newValidator);\r\n    control.updateValueAndValidity();\r\n  }\r\n\r\n  clearValidation(control : AbstractControl){\r\n    control.clearValidators();\r\n    control.updateValueAndValidity();\r\n  }\r\n\r\n  setRequiredValidator(control : AbstractControl){\r\n    this.setValidation(control, Validators.required);\r\n  }\r\n\r\n  // @dynamic\r\n  static patternValidator(regex: RegExp, error: ValidationErrors): ValidatorFn {\r\n    const res = (control: AbstractControl): { [key: string]: any } => {\r\n      if (!control.value) {\r\n        // if control is empty return no error\r\n        return null;\r\n      }\r\n  \r\n      // test the value of the control against the regexp supplied\r\n      const valid = regex.test(control.value);\r\n  \r\n      // if true, return no error (no error), else return error passed in the second parameter\r\n      return valid ? null : error;\r\n    };\r\n    return res;\r\n  }\r\n\r\n  static passwordMatchValidator(control: AbstractControl) {\r\n    const password: string = control.get('password').value; // get password from our password form control\r\n    const confirmPassword: string = control.get('confirmPassword').value; // get password from our confirmPassword form control\r\n    // compare is the password math\r\n    if (password !== confirmPassword) {\r\n      // if they don't match, set an error in our confirmPassword form control\r\n      control.get('confirmPassword').setErrors({ NoPassswordMatch: true });\r\n    }\r\n  }\r\n\r\n  formatSsn(ssn : string){\r\n    return ssn.substr(0, 3) + '-' + ssn.substr(3, 2) + '-' + ssn.substr(5, 4)\r\n  }\r\n\r\n  maskSsn(ssn : string){\r\n    return 'XXX-XX-' + ssn.substr(5, 4)\r\n  }\r\n\r\n  mask(value : string, charToHide : number){\r\n    if(!value){\r\n      return;\r\n    }\r\n    if(value.length > charToHide){\r\n      var xxx = '';\r\n      for(var count = 1 ; count <= charToHide ; count++){\r\n        xxx = 'X' + xxx;\r\n      }\r\n      return xxx + value.substr(value.length - charToHide + 1, charToHide)\r\n    }else{\r\n      return value;\r\n    }\r\n  }\r\n\r\n  clearMessages(){\r\n    this.msgs = [];\r\n  }\r\n\r\n  isState(state : string) : boolean{\r\n    return this.getStateLowercase() == state.toLowerCase();\r\n  }\r\n\r\n  getState(){\r\n    return LibConstants.STATE;\r\n  }\r\n\r\n  getStateLowercase(){\r\n    return LibConstants.state;\r\n  }\r\n\r\n  public setupNavigationBasedEvents() {\r\n    this.router.events.subscribe(\r\n      val => {\r\n        if (val instanceof NavigationStart) {\r\n          this.msgs = [];\r\n          this.msgService.clear(); //Clear Error/Success Messages\r\n          this.tourService.setCurrentStepsCount(20); //Joyride Setup\r\n        }\r\n        if (val instanceof NavigationEnd) {\r\n          gtag('config', LibConstants.gaId, { 'page_path': val.urlAfterRedirects }); //Send to Goole Analytics\r\n        }\r\n        if (val instanceof ActivationEnd) {\r\n          this.setPageTitle(val.snapshot); //Set Page Title\r\n          this.tourService.setSetpsCount(val.snapshot.data['pageId']);\r\n          this.hideLoader();\r\n        }\r\n      }\r\n    )\r\n  }\r\n\r\n  private setPageTitle(snapshot) {\r\n    let title = snapshot.data['title'];\r\n    if (title) {\r\n      this.titleService.setTitle(title);\r\n    } else {\r\n      throw \"Please specify page title in app-routing.module.ts file for page :: \" + this.ar.firstChild.snapshot.url;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @decription This method will return context root of the application\r\n   * @author Prerak Tiwari\r\n   * @version 1.0\r\n   * @param value : context root of application. e.g if application is running on 'http://localhost:9080/cp/page' then this method will return 'cp'\r\n   * @returns String\r\n   **/\r\n  getContextRoot() : string{\r\n    return window.location.pathname.substring(0, window.location.pathname.indexOf(\"/\",2));\r\n  }\r\n\r\n  getClaimantAppContextRoot() : string{\r\n    return \"/cp\";\r\n  }\r\n\r\n  getSecurityAppContextRoot() : string{\r\n    return \"/ss\";\r\n  }\r\n\r\n\r\n  openPageByContextRoot(context: string, uri: string, nav?: NavController){\r\n    if(!context.startsWith('/')){\r\n      context = '/' + context;\r\n    }\r\n    if(nav && context.includes(this.getContextRoot())){\r\n      nav.navigateForward(uri);\r\n    } else {\r\n      window.open(location.origin + `${context}/${uri}` , '_self');\r\n    }\r\n  }\r\n\r\n  openPageByContextRootWithData(context: string, uri: string, data, nav?: NavController){\r\n    if(!context.startsWith('/')){\r\n      context = '/' + context;\r\n    }\r\n    let separator = '&';\r\n    if(!uri.includes('?')){\r\n      separator = \"?\";\r\n    }\r\n    if(nav && context.includes(this.getContextRoot())){\r\n      nav.navigateForward(`${uri}${separator}data=${btoa(JSON.stringify(data))}`);\r\n    } else {\r\n      window.open(location.origin + `${context}/${uri}${separator}data=${btoa(JSON.stringify(data))}`,'_self');\r\n    }\r\n  }\r\n\r\n  maskExceptFirstAndLastChar(value : string) {\r\n      return value[0] + \"*\".repeat(value.length - 2) + value.slice(-1);\r\n  }\r\n\r\n  maskEmail(email : string){\r\n    var parts = email.split(\"@\");\r\n    if(parts.length == 2){\r\n      return this.maskExceptFirstAndLastChar(parts[0]) + \"@\" + this.maskExceptFirstAndLastChar(parts[1]);\r\n    }\r\n    return this.maskExceptFirstAndLastChar(parts[0]);\r\n  }\r\n\r\n  isPlayformCapacitor(){\r\n    return this.platform.is('capacitor');\r\n  }\r\n\r\n  isNewPasswordPolicyEnabled() : boolean {\r\n    return LibConstants.isNewPasswordPolicyEnabled == 'true';\r\n  }\r\n\r\n  isSameSymbolPolicyForClaimantAndAgency() : boolean {\r\n    return LibConstants.isSameSymbolPolicyForClaimantAndAgency == 'true';\r\n  }\r\n\r\n  focusOnSubmit(el: ElementRef){\r\n    var element = el.nativeElement.querySelector(\r\n      this.focusables.map(x => `${x}.ng-invalid`).join(\",\")\r\n    );\r\n\r\n    if (element) {\r\n      var primeNgComponent = element.querySelector(\r\n        this.focusables.map(x => `${x}.p-component`).join(\",\")\r\n      );\r\n      if (primeNgComponent) {\r\n        primeNgComponent.focus();\r\n      } else {\r\n        element.focus();\r\n      }\r\n\r\n      //Block for Radio Button Start\r\n      var primeNgComponent1 = element.querySelector(\"div.p-selectbutton\");\r\n      if (primeNgComponent1) {\r\n        var primeNgComponent2 = primeNgComponent1.querySelector(\"div.p-component\");\r\n        if (primeNgComponent2) {\r\n          primeNgComponent2.focus();\r\n        }\r\n      }\r\n      //Block for Radio Button End\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/lib/services/weekly-cert/weekly-cert-v2.service.mjs

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import { LibConstants } from '../../models/LibConstants';
+import { BaseService } from '../base-service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class WeeklyCertServiceV2 extends BaseService {
+    setServiceContext() {
+        this.serviceContext = LibConstants.weeklycert_service.context;
+    }
+    setServicePort() {
+        this.servicePort = LibConstants.weeklycert_service.port;
+    }
+    setServiceProtocol() {
+        this.protocol = LibConstants.weeklycert_service.protocol;
+    }
+    setServiceHost() {
+        this.host = LibConstants.weeklycert_service.host;
+    }
+    constructor(http) {
+        super(http);
+        this.http = http;
+    }
+    generateEventForReopenAicFlow(ssnInput) {
+        //  console.log("check the Aic Events for creation of this SSN:::"+ssnInput);
+        let paramsVal = null;
+        console.log("check the Aic Events for creation of this SSN::: 6...." + paramsVal);
+        return this.get(`weeklycert/events/${ssnInput}`).toPromise();
+    }
+    getPartialEmployment() {
+        console.log("Calling to get the IF any partial employment");
+        return this.get('weeklycert/partial-employment');
+    }
+    static { this.ɵfac = function WeeklyCertServiceV2_Factory(t) { return new (t || WeeklyCertServiceV2)(i0.ɵɵinject(i1.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WeeklyCertServiceV2, factory: WeeklyCertServiceV2.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WeeklyCertServiceV2, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.HttpClient }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/validations/AppRegex.mjs

@@ -0,0 +1,51 @@
+/***
+ *
+ * @description Class Contains all regular expressions used in the project.
+ * @author Prerak Tiwari
+ */
+// @dynamic
+export class AppRegex {
+    /**
+     * @description Regular Expression to validate username
+    */
+    static { this.USERNAME_REGEX = /^[a-zA-Z]{1}[\w\@\.]*$/; }
+    /**
+     * @description Regular Expression to validate First Name, Last Name
+    */
+    static { this.NAME_REGEX = /^[A-Za-z%][A-Za-z\s'-]*$/; }
+    /**
+     * @description Regular Expression to validate if at least 1 of the following character is present or not : '_' '@' '*' '$' '!' '#' '.'
+    */
+    static { this.CLAIMANT_SYMBOL_REGEX = /.*[_@*$!#.]+.*/; }
+    /**
+     * @description Regular Expression to validate if at least 2 of the following character is present or not : '_' '@' '*' '$' '!' '#' '.'
+    */
+    static { this.AGENCY_SYMBOL_REGEX = /.*[_@*$!#.]+.*[_@*$!#.]+.*/; }
+    /**
+     * @description Regular Expression to validate if small case letter is present or not
+    */
+    static { this.LOWER_CASE_REGEX = /.*[a-z]+.*/; }
+    /**
+     * @description Regular Expression to validate if upper case letter is present or not
+    */
+    static { this.UPPER_CASE_REGEX = /.*[A-Z]+.*/; }
+    /**
+     * @description Regular Expression to validate if numbber is present or not
+    */
+    static { this.NUMBER_REGEX = /.*[0-9]+.*/; }
+    /**
+     * @description Regular Expression to validate if accountnumber has only numbers present or not
+    */
+    static { this.ACCOUNT_NUMBER_REGEX = /^\d+$/; }
+    /**
+     * @description Regular Expression to validate email format
+    */
+    static { this.EMAIL_REGEX = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/; }
+    /**
+     * @description Regular Expression to station no. format
+     */
+    static { this.STATION_NO_REGEX = /^[A-Za-z0-9]{4}$/; }
+    static { this.ACCOUNT_NUMBER_REGEX_MIN = /^\d{8,17}$/; }
+    static { this.ROUTING_NUMBER_REGEX = /^[0-4]{1}[0-9]{8}$/; }
+}
+//# sourceMappingURL=data:application/json;base64,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