common-header-lib 0.0.1

package/esm2020/lib/services/rest-login-form.service.mjs

@@ -0,0 +1,296 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { GlobalConstants } from '../model/data_model';
+import { throwError } from 'rxjs';
+import { map, catchError } from 'rxjs/operators';
+import { CookieStorageManagerService } from './cookie-storage-manager.service';
+import { EncrydecrydataService } from './encrydecrydata.service';
+import { decode } from '@msgpack/msgpack';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./cookie-storage-manager.service";
+import * as i3 from "./encrydecrydata.service";
+export class RESTLoginFormService {
+    constructor(_http, cookieService, _encryptDec) {
+        this._http = _http;
+        this.cookieService = cookieService;
+        this._encryptDec = _encryptDec;
+    }
+    /*Method : GET
+     Action : Fetch Domain List  */
+    fetchDomainList() {
+        return this._http
+            .get(GlobalConstants.baseURL + 'meta/api/Metadata/Domains')
+            .pipe(map((response) => {
+            let result = [];
+            if (response['statusCode'] === 200) {
+                if (response['result'].length > 0) {
+                    let result = response['result'];
+                    return result;
+                }
+                else {
+                    return [];
+                }
+            }
+        }), catchError((e) => throwError(this.errorHandler(e))));
+    }
+    errorHandler(e) {
+        throw new Error('Method not implemented.');
+    }
+    /*Method : POST
+    Parameter : subID  , id
+     Action : Get configuration ID based on to show hide DOMAIN dropdown
+       */
+    getglobalConfigDetails(subid, id) {
+        return this._http
+            .post(GlobalConstants.baseURL +
+            'meta/api/Metadata/GetArcosConfigsValues?subId=' +
+            subid, id)
+            .pipe(map((response) => {
+            let result = [];
+            if (response['statusCode'] === 200) {
+                let result = response['result'];
+                return result;
+            }
+        }), catchError((e) => throwError(this.errorHandler(e))));
+    }
+    /*Method : POST
+     Action : get login to user
+       */
+    // userAuthentication(userDetails: any) {
+    //   return this._http
+    //     .post(
+    //       GlobalConstants.baseURL + 'xaccess/api/SecureAccess/Authenticate',
+    //       userDetails
+    //     )
+    //     .pipe(
+    //       map((response: any) => {
+    //         if (response && response['data']) {
+    //           return this.getDecryptAPIResponse(response['data']);
+    //         }
+    //       }),
+    //       catchError((e) => throwError(this.errorHandler(e)))
+    //     );
+    // }
+    /*Method : POST
+     Action : RESET Password for First Time User
+       */
+    setNewpassword(loggedInUserDetails) {
+        return this._http
+            .post(GlobalConstants.baseURL +
+            'xaccess/api/SecureAccess/ChangeUserArcXwdManually', loggedInUserDetails)
+            .pipe(catchError((e) => throwError(this.errorHandler(e))));
+    }
+    /*Method : POST
+     Action :Will validate User entered PWD as
+    per Password Policy Set
+       */
+    validatePassword(userDetails) {
+        return this._http
+            .post(GlobalConstants.baseURL + 'xaccess/api/SecureAccess/ValidatePassword', userDetails)
+            .pipe(catchError((e) => throwError(this.errorHandler(e))));
+    }
+    /*Method : POST
+      Action : Get Public Key for encryption of Data  */
+    getPrivateKey(params) {
+        return this._http
+            .post(GlobalConstants.baseURL + 'xaccess/api/SecureAccess/XKEDSync', params)
+            .pipe(catchError((e) => throwError(this.errorHandler(e))));
+    }
+    /* Method : POST
+     Action : Send request for OTP of MFA Authenticator  */
+    sendMFAOTPRequest(mfaDetails) {
+        return this._http
+            .post(GlobalConstants.baseURL + 'xmfa/api/Mfa/mfa', mfaDetails)
+            .pipe(map((response) => {
+            let result = [];
+            if (response['success']) {
+                let result = response['result'];
+                return result;
+            }
+        }), catchError((e) => throwError(this.errorHandler(e))));
+    }
+    /* Method : POST
+     Action : Submit User Enter OTP of MFA Authenticator  */
+    submitOtpForMfaVerification(mfaDetails) {
+        return this._http
+            .post(GlobalConstants.baseURL + 'xmfa/api/Mfa/mfavalidation', mfaDetails)
+            .pipe(map((response) => {
+            let result = [];
+            if (response['success']) {
+                let result = response['result'];
+                return result;
+            }
+        }), catchError((e) => throwError(this.errorHandler(e))));
+    }
+    /*Method : POST
+     Action : It will provide Token which used for multiple Application access */
+    getAuthToken(userDetails) {
+        return this._http
+            .post(GlobalConstants.baseURL + 'xauth/api/Token/GenerateJwtTokenApplication', userDetails)
+            .pipe(map((response) => {
+            if (response) {
+                return response;
+            }
+            else {
+                return '';
+            }
+        }), catchError((e) => throwError(this.errorHandler(e))));
+    }
+    /* Method : GET
+     Action : It will provide Token which used to established MFA Method  */
+    // getMFAAccessTokenKey() {
+    //   return this._http
+    //     .get<any>(GlobalConstants.baseURL + 'xaccess/api/SecureAccess/GetMfaDetails')
+    //     .pipe(
+    //       map((response) => {
+    //         if (response && response['data']) {
+    //           return this.getDecryptAPIResponse(response['data']);
+    //         }
+    //         return {};
+    //       }),
+    //       catchError((e) => throwError(this.errorHandler(e)))
+    //     );
+    // }
+    /* Method : POST
+     Action : It will check Valida User or not  */
+    // checkUserExists(userDetails: any) {
+    //   return this._http
+    //     .post(
+    //       GlobalConstants.baseURL + 'xaccess/api/SecureAccess/ValidateUser',
+    //       userDetails
+    //     )
+    //     .pipe(
+    //       map((response: any) => {
+    //         if (response && response['data']) {
+    //           return this.getDecryptAPIResponse(response['data']);
+    //         }
+    //         return {};
+    //       }),
+    //       catchError((e) => throwError(this.errorHandler(e)))
+    //     );
+    // }
+    /* Method : POST
+     Action : Unlock User to enable login process */
+    unlockUserAccount(userDetails) {
+        return this._http
+            .post(GlobalConstants.baseURL + 'xaccess/api/SecureAccess/ValidateUser', userDetails)
+            .pipe(map((result) => {
+            return result;
+        }), catchError((e) => throwError(this.errorHandler(e))));
+    }
+    /* Method : GET
+     Action : It will provide Third Parth AUth Method etc. Google, Okta, Microsoft  */
+    // getThirdPartySignInMethods() {
+    //   return this._http
+    //     .get(
+    //       GlobalConstants.baseURL + 'xaccess/api/SecureAccess/GetThirdPartyDetail'
+    //     )
+    //     .pipe(
+    //       map((response: any) => {
+    //         let result: any = [];
+    //         if (response['success']) {
+    //           return response['result'];
+    //         }
+    //         return result;
+    //       }),
+    //       catchError((error: any) => throwError(this.errorHandler(error)))
+    //     );
+    // }
+    /* Method : POST
+     Action : It will Verify plugin version is correct or not */
+    // public verifyUserInstalledPluginVersion(pluginInfo: any) {
+    //   return this._http
+    //     .post(GlobalConstants.baseURL + 'xaccess/api/SecureAccess/CheckAutoUpdatePAMPlugin',
+    //       pluginInfo).pipe(
+    //         map((response: any) => {
+    //           return response['result'];
+    //         }),
+    //         catchError((error: any) => throwError(this.errorHandler(error)))
+    //       );
+    // }
+    /**
+     * Verifies user authentication using Windows credentials.
+     */
+    // public checkAuthenticateWithWindowsCredentials(pluginInfo: any) {
+    //   return this._http
+    //     .post(GlobalConstants.baseURL + 'xdomainauth/api/DomainAuthentication/DomainAuth',
+    //       // .post(GlobalConstants.baseURL + 'xaccess/api/SecureAccess/DomainAuth',
+    //       pluginInfo).pipe(
+    //         map((response: any) => {
+    //           if (response && response['data']) {
+    //             return this.getDecryptAPIResponse(response['data']);
+    //           }
+    //           return {};
+    //         }),
+    //         catchError((error: any) => throwError(this.errorHandler(error)))
+    //       );
+    // }
+    /*Method : GET
+     Action : Get User Background Image and Logo  */
+    getUserBackgroundImageAndLogo() {
+        return this._http
+            .get(GlobalConstants.baseURL + 'xaccess/api/SecureAccess/GetBackgroundImage')
+            .pipe(map((response) => {
+            return response;
+        }), catchError((error) => throwError(this.errorHandler(error))));
+    }
+    // public getVerifiedUserSessionDetails(authToken: string) {
+    //   return this._http.post(
+    //     GlobalConstants.baseURL + 'xaccess/api/SecureAccess/ValidateUserSessionDetail', { state: authToken }).pipe(
+    //       map((response: any) => {
+    //         if (response && response['data']) {
+    //           return this.getDecryptAPIResponse(response['data']);
+    //         }
+    //         return {};
+    //       }),
+    //       catchError((error: any) => throwError(this.errorHandler(error)))
+    //     );
+    // }
+    deleteCookieData(payload) {
+        const url = this.cookieService.getCookieValue('baseurl');
+        const delCookieEndpoint = `${url}xaccess/api/SecureAccess/cookiesUpdation`;
+        return this._http.post(delCookieEndpoint, payload);
+    }
+    /**
+     * Decrypts a base64-encoded, MessagePack-encoded ciphertext into its original tuple form.
+     *
+     * @param cipherText - The encrypted string received from the API.
+     * @returns The decoded tuple [key, value] if decryption is successful; otherwise, an empty object.
+     *
+     * Steps:
+     * 1. Decrypts the cipherText using custom crypto method.
+     * 2. Decodes the base64 response into a binary Uint8Array.
+     * 3. Deserializes the binary using MessagePack's decode to get the original data.
+     */
+    // private getDecryptAPIResponse_old(cipherText: string): any {
+    //   if (cipherText) {
+    //     const responseString =
+    //       this._encryptDec.decryptResponseViaCrypto(cipherText);
+    //     const binary = Uint8Array.from(atob(responseString), c => c.charCodeAt(0));
+    //     const decodedArray = decode(binary) as [string, string];
+    //     // console.log(decodedArray);
+    //     return decodedArray
+    //   }
+    //   return {};
+    // }
+    async getDecryptAPIResponse(cipherText) {
+        if (cipherText) {
+            const responseString = await this._encryptDec.decryptResponseViaCrypto(cipherText); // await here
+            const binary = Uint8Array.from(atob(responseString), (c) => c.charCodeAt(0));
+            const decodedArray = decode(binary);
+            // console.log(decodedArray);
+            return decodedArray;
+        }
+        return {};
+    }
+}
+RESTLoginFormService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RESTLoginFormService, deps: [{ token: i1.HttpClient }, { token: i2.CookieStorageManagerService }, { token: i3.EncrydecrydataService }], target: i0.ɵɵFactoryTarget.Injectable });
+RESTLoginFormService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RESTLoginFormService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RESTLoginFormService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.CookieStorageManagerService }, { type: i3.EncrydecrydataService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rest-login-form.service.js","sourceRoot":"","sources":["../../../../../projects/common-header-lib/src/lib/services/rest-login-form.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpParams } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { GlobalConstants } from '../model/data_model';\r\nimport { throwError } from 'rxjs';\r\nimport { map, catchError } from 'rxjs/operators';\r\nimport { CookieStorageManagerService } from './cookie-storage-manager.service';\r\nimport { EncrydecrydataService } from './encrydecrydata.service';\r\nimport { decode } from '@msgpack/msgpack';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class RESTLoginFormService {\r\n  constructor(\r\n    private readonly _http: HttpClient,\r\n    private readonly cookieService: CookieStorageManagerService,\r\n    private readonly _encryptDec: EncrydecrydataService\r\n  ) {}\r\n\r\n  /*Method : GET\r\n   Action : Fetch Domain List  */\r\n  fetchDomainList() {\r\n    return this._http\r\n      .get(GlobalConstants.baseURL + 'meta/api/Metadata/Domains')\r\n      .pipe(\r\n        map((response: any) => {\r\n          let result = [];\r\n          if (response['statusCode'] === 200) {\r\n            if (response['result'].length > 0) {\r\n              let result = response['result'];\r\n              return result;\r\n            } else {\r\n              return [];\r\n            }\r\n          }\r\n        }),\r\n        catchError((e) => throwError(this.errorHandler(e)))\r\n      );\r\n  }\r\n\r\n  errorHandler(e: any): any {\r\n    throw new Error('Method not implemented.');\r\n  }\r\n\r\n  /*Method : POST\r\n  Parameter : subID  , id\r\n   Action : Get configuration ID based on to show hide DOMAIN dropdown\r\n     */\r\n\r\n  getglobalConfigDetails(subid: string, id: number[]) {\r\n    return this._http\r\n      .post(\r\n        GlobalConstants.baseURL +\r\n          'meta/api/Metadata/GetArcosConfigsValues?subId=' +\r\n          subid,\r\n        id\r\n      )\r\n      .pipe(\r\n        map((response: any) => {\r\n          let result = [];\r\n          if (response['statusCode'] === 200) {\r\n            let result = response['result'];\r\n            return result;\r\n          }\r\n        }),\r\n        catchError((e) => throwError(this.errorHandler(e)))\r\n      );\r\n  }\r\n\r\n  /*Method : POST\r\n   Action : get login to user\r\n     */\r\n  // userAuthentication(userDetails: any) {\r\n  //   return this._http\r\n  //     .post(\r\n  //       GlobalConstants.baseURL + 'xaccess/api/SecureAccess/Authenticate',\r\n  //       userDetails\r\n  //     )\r\n  //     .pipe(\r\n  //       map((response: any) => {\r\n  //         if (response && response['data']) {\r\n\r\n  //           return this.getDecryptAPIResponse(response['data']);\r\n  //         }\r\n  //       }),\r\n  //       catchError((e) => throwError(this.errorHandler(e)))\r\n  //     );\r\n  // }\r\n\r\n  /*Method : POST\r\n   Action : RESET Password for First Time User\r\n     */\r\n  setNewpassword(loggedInUserDetails: any) {\r\n    return this._http\r\n      .post(\r\n        GlobalConstants.baseURL +\r\n          'xaccess/api/SecureAccess/ChangeUserArcXwdManually',\r\n        loggedInUserDetails\r\n      )\r\n      .pipe(catchError((e) => throwError(this.errorHandler(e))));\r\n  }\r\n\r\n  /*Method : POST\r\n   Action :Will validate User entered PWD as\r\n  per Password Policy Set\r\n     */\r\n  validatePassword(userDetails: any) {\r\n    return this._http\r\n      .post(\r\n        GlobalConstants.baseURL + 'xaccess/api/SecureAccess/ValidatePassword',\r\n        userDetails\r\n      )\r\n      .pipe(catchError((e) => throwError(this.errorHandler(e))));\r\n  }\r\n\r\n  /*Method : POST\r\n    Action : Get Public Key for encryption of Data  */\r\n  getPrivateKey(params: any) {\r\n    return this._http\r\n      .post(\r\n        GlobalConstants.baseURL + 'xaccess/api/SecureAccess/XKEDSync',\r\n        params\r\n      )\r\n      .pipe(catchError((e) => throwError(this.errorHandler(e))));\r\n  }\r\n\r\n  /* Method : POST\r\n   Action : Send request for OTP of MFA Authenticator  */\r\n  sendMFAOTPRequest(mfaDetails: any) {\r\n    return this._http\r\n      .post(GlobalConstants.baseURL + 'xmfa/api/Mfa/mfa', mfaDetails)\r\n      .pipe(\r\n        map((response: any) => {\r\n          let result = [];\r\n          if (response['success']) {\r\n            let result = response['result'];\r\n            return result;\r\n          }\r\n        }),\r\n        catchError((e) => throwError(this.errorHandler(e)))\r\n      );\r\n  }\r\n\r\n  /* Method : POST\r\n   Action : Submit User Enter OTP of MFA Authenticator  */\r\n  submitOtpForMfaVerification(mfaDetails: any) {\r\n    return this._http\r\n      .post(GlobalConstants.baseURL + 'xmfa/api/Mfa/mfavalidation', mfaDetails)\r\n      .pipe(\r\n        map((response: any) => {\r\n          let result = [];\r\n          if (response['success']) {\r\n            let result = response['result'];\r\n            return result;\r\n          }\r\n        }),\r\n        catchError((e) => throwError(this.errorHandler(e)))\r\n      );\r\n  }\r\n\r\n  /*Method : POST\r\n   Action : It will provide Token which used for multiple Application access */\r\n  getAuthToken(userDetails: {}) {\r\n    return this._http\r\n      .post(\r\n        GlobalConstants.baseURL + 'xauth/api/Token/GenerateJwtTokenApplication',\r\n        userDetails\r\n      )\r\n      .pipe(\r\n        map((response) => {\r\n          if (response) {\r\n            return response;\r\n          } else {\r\n            return '';\r\n          }\r\n        }),\r\n        catchError((e) => throwError(this.errorHandler(e)))\r\n      );\r\n  }\r\n\r\n  /* Method : GET\r\n   Action : It will provide Token which used to established MFA Method  */\r\n  // getMFAAccessTokenKey() {\r\n  //   return this._http\r\n  //     .get<any>(GlobalConstants.baseURL + 'xaccess/api/SecureAccess/GetMfaDetails')\r\n  //     .pipe(\r\n  //       map((response) => {\r\n  //         if (response && response['data']) {\r\n  //           return this.getDecryptAPIResponse(response['data']);\r\n  //         }\r\n  //         return {};\r\n  //       }),\r\n  //       catchError((e) => throwError(this.errorHandler(e)))\r\n  //     );\r\n  // }\r\n\r\n  /* Method : POST\r\n   Action : It will check Valida User or not  */\r\n  // checkUserExists(userDetails: any) {\r\n  //   return this._http\r\n  //     .post(\r\n  //       GlobalConstants.baseURL + 'xaccess/api/SecureAccess/ValidateUser',\r\n  //       userDetails\r\n  //     )\r\n  //     .pipe(\r\n  //       map((response: any) => {\r\n  //         if (response && response['data']) {\r\n  //           return this.getDecryptAPIResponse(response['data']);\r\n  //         }\r\n  //         return {};\r\n  //       }),\r\n  //       catchError((e) => throwError(this.errorHandler(e)))\r\n  //     );\r\n  // }\r\n\r\n  /* Method : POST\r\n   Action : Unlock User to enable login process */\r\n  unlockUserAccount(userDetails: any) {\r\n    return this._http\r\n      .post(\r\n        GlobalConstants.baseURL + 'xaccess/api/SecureAccess/ValidateUser',\r\n        userDetails\r\n      )\r\n      .pipe(\r\n        map((result) => {\r\n          return result;\r\n        }),\r\n        catchError((e) => throwError(this.errorHandler(e)))\r\n      );\r\n  }\r\n\r\n  /* Method : GET\r\n   Action : It will provide Third Parth AUth Method etc. Google, Okta, Microsoft  */\r\n  // getThirdPartySignInMethods() {\r\n  //   return this._http\r\n  //     .get(\r\n  //       GlobalConstants.baseURL + 'xaccess/api/SecureAccess/GetThirdPartyDetail'\r\n  //     )\r\n  //     .pipe(\r\n  //       map((response: any) => {\r\n  //         let result: any = [];\r\n  //         if (response['success']) {\r\n  //           return response['result'];\r\n  //         }\r\n  //         return result;\r\n  //       }),\r\n  //       catchError((error: any) => throwError(this.errorHandler(error)))\r\n  //     );\r\n  // }\r\n\r\n  /* Method : POST\r\n   Action : It will Verify plugin version is correct or not */\r\n  // public verifyUserInstalledPluginVersion(pluginInfo: any) {\r\n  //   return this._http\r\n  //     .post(GlobalConstants.baseURL + 'xaccess/api/SecureAccess/CheckAutoUpdatePAMPlugin',\r\n  //       pluginInfo).pipe(\r\n  //         map((response: any) => {\r\n  //           return response['result'];\r\n  //         }),\r\n  //         catchError((error: any) => throwError(this.errorHandler(error)))\r\n  //       );\r\n  // }\r\n\r\n  /**\r\n   * Verifies user authentication using Windows credentials.\r\n   */\r\n  // public checkAuthenticateWithWindowsCredentials(pluginInfo: any) {\r\n  //   return this._http\r\n  //     .post(GlobalConstants.baseURL + 'xdomainauth/api/DomainAuthentication/DomainAuth',\r\n  //       // .post(GlobalConstants.baseURL + 'xaccess/api/SecureAccess/DomainAuth',\r\n  //       pluginInfo).pipe(\r\n  //         map((response: any) => {\r\n  //           if (response && response['data']) {\r\n  //             return this.getDecryptAPIResponse(response['data']);\r\n  //           }\r\n  //           return {};\r\n  //         }),\r\n  //         catchError((error: any) => throwError(this.errorHandler(error)))\r\n  //       );\r\n  // }\r\n\r\n  /*Method : GET\r\n   Action : Get User Background Image and Logo  */\r\n  public getUserBackgroundImageAndLogo() {\r\n    return this._http\r\n      .get(\r\n        GlobalConstants.baseURL + 'xaccess/api/SecureAccess/GetBackgroundImage'\r\n      )\r\n      .pipe(\r\n        map((response: any) => {\r\n          return response;\r\n        }),\r\n        catchError((error: any) => throwError(this.errorHandler(error)))\r\n      );\r\n  }\r\n\r\n  // public getVerifiedUserSessionDetails(authToken: string) {\r\n  //   return this._http.post(\r\n  //     GlobalConstants.baseURL + 'xaccess/api/SecureAccess/ValidateUserSessionDetail', { state: authToken }).pipe(\r\n  //       map((response: any) => {\r\n  //         if (response && response['data']) {\r\n  //           return this.getDecryptAPIResponse(response['data']);\r\n  //         }\r\n  //         return {};\r\n  //       }),\r\n  //       catchError((error: any) => throwError(this.errorHandler(error)))\r\n  //     );\r\n  // }\r\n\r\n  deleteCookieData(payload: any) {\r\n    const url = this.cookieService.getCookieValue('baseurl');\r\n    const delCookieEndpoint = `${url}xaccess/api/SecureAccess/cookiesUpdation`;\r\n    return this._http.post(delCookieEndpoint, payload);\r\n  }\r\n\r\n  /**\r\n   * Decrypts a base64-encoded, MessagePack-encoded ciphertext into its original tuple form.\r\n   *\r\n   * @param cipherText - The encrypted string received from the API.\r\n   * @returns The decoded tuple [key, value] if decryption is successful; otherwise, an empty object.\r\n   *\r\n   * Steps:\r\n   * 1. Decrypts the cipherText using custom crypto method.\r\n   * 2. Decodes the base64 response into a binary Uint8Array.\r\n   * 3. Deserializes the binary using MessagePack's decode to get the original data.\r\n   */\r\n  // private getDecryptAPIResponse_old(cipherText: string): any {\r\n  //   if (cipherText) {\r\n  //     const responseString =\r\n  //       this._encryptDec.decryptResponseViaCrypto(cipherText);\r\n  //     const binary = Uint8Array.from(atob(responseString), c => c.charCodeAt(0));\r\n  //     const decodedArray = decode(binary) as [string, string];\r\n  //     // console.log(decodedArray);\r\n  //     return decodedArray\r\n  //   }\r\n  //   return {};\r\n  // }\r\n\r\n  private async getDecryptAPIResponse(cipherText: string): Promise<any> {\r\n    if (cipherText) {\r\n      const responseString = await this._encryptDec.decryptResponseViaCrypto(\r\n        cipherText\r\n      ); // await here\r\n      const binary = Uint8Array.from(atob(responseString), (c) =>\r\n        c.charCodeAt(0)\r\n      );\r\n      const decodedArray = decode(binary) as [string, string];\r\n      // console.log(decodedArray);\r\n      return decodedArray;\r\n    }\r\n    return {};\r\n  }\r\n}\r\n"]}

package/esm2020/lib/services/rest-signalr.service.mjs

@@ -0,0 +1,100 @@
+import { COOKIECONSTANT, GlobalConstants, } from '../model/data_model';
+import { Injectable } from '@angular/core';
+import * as signalR from '@microsoft/signalr';
+import { BehaviorSubject } from 'rxjs';
+import { StorageService } from './storage.service';
+import { EncrpdataService } from './encrpdata.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./storage.service";
+import * as i2 from "./encrpdata.service";
+// import { CookieStorageManagerService } from '../cookie-storage-manager.service';
+export class RestSignalRService {
+    constructor(_localStorage, _encrpdataService) {
+        this._localStorage = _localStorage;
+        this._encrpdataService = _encrpdataService;
+        this.eventMsg = new BehaviorSubject({});
+        this.AuthToken = "";
+        this.hubURLS = [];
+        //Method: Established the Connection With SignalR to get RealTime Data
+        this.establishedConnection = async () => {
+            // console.log('Token SingalR: ', this.AuthToken);
+            this.hubConnection = new signalR.HubConnectionBuilder()
+                .withUrl(`${GlobalConstants.signalRURL}/chatHub`, {
+                skipNegotiation: true,
+                transport: signalR.HttpTransportType.WebSockets,
+                headers: { Authorization: `Bearer ${this.AuthToken}` },
+            })
+                .build();
+            try {
+                await this.hubConnection.start();
+                console.log('SignalR connection established successfully');
+                this.addMessageListener();
+            }
+            catch (error) {
+                console.error('Error establishing SignalR connection:', error);
+                throw error;
+            }
+        };
+    }
+    async initializeSignalRConnection() {
+        if (!GlobalConstants.signalRURL) {
+            throw new Error('No hub URLs provided');
+        }
+        this.hubURLS = GlobalConstants.signalRURL ? GlobalConstants.signalRURL.split(',') : [];
+        if (this.hubURLS.length === 1) {
+            GlobalConstants.signalRURL = this.hubURLS[0];
+            await this.establishedConnection();
+            return;
+        }
+        let lastUsedIndex = this.getLastUsedIndex();
+        for (let i = 0; i < this.hubURLS.length; i++) {
+            const index = (lastUsedIndex + i) % this.hubURLS.length;
+            GlobalConstants.signalRURL = this.hubURLS[index];
+            try {
+                await this.establishedConnection();
+                this.setLastUsedIndex(index + 1); // Update for next round
+                break; // Exit the loop if connection is successful
+            }
+            catch (error) {
+                console.error(`Error connecting to hub ${this.hubURLS[index]}:`, error);
+            }
+        }
+        if (!this.hubConnection) {
+            throw new Error("All SignalR connections failed");
+        }
+    }
+    addMessageListener() {
+        this.hubConnection.on('ReceiveMessage', (user, data) => {
+            console.log('Rx SignalR: ', user, 'Data: ', data);
+            data = JSON.parse(data);
+            this.emitEventMsg(data);
+        });
+    }
+    emitEventMsg(data) {
+        this.eventMsg.next(data);
+    }
+    listenerEventMsg() {
+        return this.eventMsg.asObservable();
+    }
+    getLastUsedIndexv1() {
+        const lastIndex = this._localStorage.getData(COOKIECONSTANT.SIGNALR_INDEX);
+        return lastIndex ? Number(this._encrpdataService.decodeToBase64(lastIndex)) || 0 : 0;
+    }
+    getLastUsedIndex() {
+        const lastIndex = this._localStorage.getData(COOKIECONSTANT.SIGNALR_INDEX);
+        return lastIndex ? Number(this._encrpdataService.decodeToBase64(lastIndex)) || 0 : 0;
+    }
+    setLastUsedIndex(index) {
+        const lastIndex = this._encrpdataService.encodeToBase64(index.toString());
+        this._localStorage.saveData(COOKIECONSTANT.SIGNALR_INDEX, lastIndex);
+    }
+}
+RestSignalRService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RestSignalRService, deps: [{ token: i1.StorageService }, { token: i2.EncrpdataService }], target: i0.ɵɵFactoryTarget.Injectable });
+RestSignalRService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RestSignalRService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RestSignalRService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.StorageService }, { type: i2.EncrpdataService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rest-signalr.service.js","sourceRoot":"","sources":["../../../../../projects/common-header-lib/src/lib/services/rest-signalr.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  COOKIECONSTANT,\r\n  GlobalConstants,\r\n} from '../model/data_model';\r\nimport { Injectable } from '@angular/core';\r\nimport * as signalR from '@microsoft/signalr';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport { StorageService } from './storage.service';\r\nimport { EncrpdataService } from './encrpdata.service';\r\n// import { CookieStorageManagerService } from '../cookie-storage-manager.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class RestSignalRService {\r\n  private hubConnection!: signalR.HubConnection;\r\n  protected eventMsg = new BehaviorSubject<any>({});\r\n  protected AuthToken: string = \"\";\r\n  private hubURLS: string[] = [];\r\n\r\n  constructor(\r\n    private readonly _localStorage: StorageService, private readonly _encrpdataService: EncrpdataService\r\n  ) { }\r\n\r\n  //Method: Established the Connection With SignalR to get RealTime Data\r\n  public establishedConnection = async () => {\r\n    // console.log('Token SingalR: ', this.AuthToken);\r\n    this.hubConnection = new signalR.HubConnectionBuilder()\r\n      .withUrl(`${GlobalConstants.signalRURL}/chatHub`, {\r\n        skipNegotiation: true,\r\n        transport: signalR.HttpTransportType.WebSockets,\r\n        headers: { Authorization: `Bearer ${this.AuthToken}` },\r\n      })\r\n      .build();\r\n\r\n    try {\r\n      await this.hubConnection.start();\r\n      console.log('SignalR connection established successfully');\r\n      this.addMessageListener();\r\n    }\r\n    catch (error) {\r\n      console.error('Error establishing SignalR connection:', error);\r\n      throw error;\r\n    }\r\n\r\n\r\n  };\r\n\r\n  public async initializeSignalRConnection(): Promise<void> {\r\n\r\n    if (!GlobalConstants.signalRURL) {\r\n      throw new Error('No hub URLs provided');\r\n    }\r\n\r\n    this.hubURLS = GlobalConstants.signalRURL ? GlobalConstants.signalRURL.split(',') : [];\r\n    if (this.hubURLS.length === 1) {\r\n      GlobalConstants.signalRURL = this.hubURLS[0];\r\n      await this.establishedConnection();\r\n      return;\r\n    }\r\n\r\n    let lastUsedIndex = this.getLastUsedIndex();\r\n\r\n    for (let i = 0; i < this.hubURLS.length; i++) {\r\n      const index = (lastUsedIndex + i) % this.hubURLS.length;\r\n      GlobalConstants.signalRURL = this.hubURLS[index];\r\n      try {\r\n        await this.establishedConnection();\r\n        this.setLastUsedIndex(index + 1);  // Update for next round\r\n        break;                            // Exit the loop if connection is successful\r\n      } catch (error) {\r\n        console.error(`Error connecting to hub ${this.hubURLS[index]}:`, error);\r\n      }\r\n    }\r\n\r\n    if (!this.hubConnection) {\r\n      throw new Error(\"All SignalR connections failed\");\r\n    }\r\n  }\r\n\r\n  public addMessageListener() {\r\n    this.hubConnection.on('ReceiveMessage', (user: any, data: any) => {\r\n      console.log('Rx SignalR: ', user, 'Data: ', data);\r\n      data = JSON.parse(data);\r\n      this.emitEventMsg(data);\r\n    });\r\n  }\r\n\r\n  emitEventMsg(data: any) {\r\n    this.eventMsg.next(data);\r\n  }\r\n\r\n  listenerEventMsg() {\r\n    return this.eventMsg.asObservable();\r\n  }\r\n\r\n  private getLastUsedIndexv1(): Number {\r\n    const lastIndex = this._localStorage.getData(COOKIECONSTANT.SIGNALR_INDEX);\r\n    return lastIndex ? Number(this._encrpdataService.decodeToBase64(lastIndex)) || 0 : 0;\r\n  }\r\n  private getLastUsedIndex(): number {\r\n    const lastIndex = this._localStorage.getData(COOKIECONSTANT.SIGNALR_INDEX);\r\n    return lastIndex ? Number(this._encrpdataService.decodeToBase64(lastIndex)) || 0 : 0;\r\n  }\r\n\r\n  private setLastUsedIndex(index: number): void {\r\n    const lastIndex = this._encrpdataService.encodeToBase64(index.toString());\r\n    this._localStorage.saveData(COOKIECONSTANT.SIGNALR_INDEX, lastIndex);\r\n  }\r\n\r\n}\r\n"]}

package/esm2020/lib/services/storage.service.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class StorageService {
+    constructor() { }
+    saveData(key, value) {
+        localStorage.setItem(key, value);
+    }
+    getData(key) {
+        return localStorage.getItem(key);
+    }
+    removeData(key) {
+        localStorage.removeItem(key);
+    }
+    clearData() {
+        localStorage.clear();
+    }
+    checkData(key) {
+        const data = localStorage.getItem(key);
+        if (data) {
+            return true;
+        }
+        return false;
+    }
+}
+StorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: StorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+StorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: StorageService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: StorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29tbW9uLWhlYWRlci1saWIvc3JjL2xpYi9zZXJ2aWNlcy9zdG9yYWdlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFLM0MsTUFBTSxPQUFPLGNBQWM7SUFDekIsZ0JBQWUsQ0FBQztJQUVULFFBQVEsQ0FBQyxHQUFXLEVBQUUsS0FBYTtRQUN4QyxZQUFZLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsQ0FBQztJQUNuQyxDQUFDO0lBRU0sT0FBTyxDQUFDLEdBQVc7UUFDeEIsT0FBTyxZQUFZLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ25DLENBQUM7SUFDTSxVQUFVLENBQUMsR0FBVztRQUMzQixZQUFZLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQy9CLENBQUM7SUFFTSxTQUFTO1FBQ2QsWUFBWSxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ3ZCLENBQUM7SUFFTSxTQUFTLENBQUMsR0FBVztRQUMxQixNQUFNLElBQUksR0FBRyxZQUFZLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3ZDLElBQUksSUFBSSxFQUFFO1lBQ1IsT0FBTyxJQUFJLENBQUM7U0FDYjtRQUNELE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQzs7MkdBeEJVLGNBQWM7K0dBQWQsY0FBYyxjQUZiLE1BQU07MkZBRVAsY0FBYztrQkFIMUIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgU3RvcmFnZVNlcnZpY2Uge1xyXG4gIGNvbnN0cnVjdG9yKCkge31cclxuXHJcbiAgcHVibGljIHNhdmVEYXRhKGtleTogc3RyaW5nLCB2YWx1ZTogc3RyaW5nKSB7XHJcbiAgICBsb2NhbFN0b3JhZ2Uuc2V0SXRlbShrZXksIHZhbHVlKTtcclxuICB9XHJcblxyXG4gIHB1YmxpYyBnZXREYXRhKGtleTogc3RyaW5nKSB7XHJcbiAgICByZXR1cm4gbG9jYWxTdG9yYWdlLmdldEl0ZW0oa2V5KTtcclxuICB9XHJcbiAgcHVibGljIHJlbW92ZURhdGEoa2V5OiBzdHJpbmcpIHtcclxuICAgIGxvY2FsU3RvcmFnZS5yZW1vdmVJdGVtKGtleSk7XHJcbiAgfVxyXG5cclxuICBwdWJsaWMgY2xlYXJEYXRhKCkge1xyXG4gICAgbG9jYWxTdG9yYWdlLmNsZWFyKCk7XHJcbiAgfVxyXG5cclxuICBwdWJsaWMgY2hlY2tEYXRhKGtleTogc3RyaW5nKTogYm9vbGVhbiB7XHJcbiAgICBjb25zdCBkYXRhID0gbG9jYWxTdG9yYWdlLmdldEl0ZW0oa2V5KTtcclxuICAgIGlmIChkYXRhKSB7XHJcbiAgICAgIHJldHVybiB0cnVlO1xyXG4gICAgfVxyXG4gICAgcmV0dXJuIGZhbHNlO1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2020/lib/services/toast-msg.service.mjs

@@ -0,0 +1,95 @@
+import { Injectable } from '@angular/core';
+import { ToastrService } from 'ngx-toastr';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-toastr";
+export class ToastMsgService {
+    constructor(toastr) {
+        this.toastr = toastr;
+        this.toastType_sucess = 'toast-success';
+        this.toastType_info = 'toast-info';
+        this.toastType_error = 'toast-error';
+        this.toastType_warning = 'toast-warn';
+    }
+    success(textMessage) {
+        console.log(this.isToastMsgActive(), textMessage);
+        if (this.isToastMsgActive()) {
+            if (this.checkActiveToastMessagesByType(this.toastType_sucess)) {
+                this.updateActiveToastMessage(textMessage, this.toastType_sucess);
+            }
+            else {
+                this.toastr.success(textMessage);
+            }
+        }
+        else {
+            this.toastr.success(textMessage);
+        }
+    }
+    error(textMessage) {
+        if (this.isToastMsgActive()) {
+            if (this.checkActiveToastMessagesByType(this.toastType_error)) {
+                this.updateActiveToastMessage(textMessage, this.toastType_error);
+            }
+            else {
+                this.toastr.error(textMessage);
+            }
+        }
+        else {
+            this.toastr.error(textMessage);
+        }
+    }
+    info(textMessage) {
+        if (this.isToastMsgActive()) {
+            if (this.checkActiveToastMessagesByType(this.toastType_info)) {
+                this.updateActiveToastMessage(textMessage, this.toastType_info);
+            }
+            else {
+                this.toastr.info(textMessage);
+            }
+        }
+        else {
+            this.toastr.info(textMessage);
+        }
+    }
+    warning(textMessage) {
+        if (this.isToastMsgActive()) {
+            if (this.checkActiveToastMessagesByType(this.toastType_warning)) {
+                this.updateActiveToastMessage(textMessage, this.toastType_warning);
+            }
+            else {
+                this.toastr.warning(textMessage);
+            }
+        }
+        else {
+            this.toastr.warning(textMessage);
+        }
+    }
+    updateActiveToastMessage(textMessage, ToastType) {
+        const activeToasts = this.getActiveToastMessagesByType(ToastType);
+        if (activeToasts.length > 0) {
+            const toastObj = activeToasts[0];
+            toastObj.toastRef.componentInstance.message = textMessage;
+            // console.log('Updated Toast: ', toastObj.toastRef.componentInstance);
+        }
+    }
+    isToastMsgActive() {
+        return this.toastr.currentlyActive ? true : false;
+    }
+    getActiveToastMessagesByType(type) {
+        return this.toastr.toasts.filter((toastItem) => toastItem.toastRef.componentInstance.toastPackage.toastType.includes(type));
+    }
+    checkActiveToastMessagesByType(type) {
+        return this.toastr.toasts.some((toastItem) => toastItem.toastRef.componentInstance.toastPackage.toastType == type);
+    }
+    clear() {
+        this.toastr.clear();
+    }
+}
+ToastMsgService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ToastMsgService, deps: [{ token: i1.ToastrService }], target: i0.ɵɵFactoryTarget.Injectable });
+ToastMsgService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ToastMsgService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ToastMsgService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ToastrService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/vapt-validation.service.mjs

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class VaptValidationService {
+    constructor() { }
+    hasUnsafeInput(formData) {
+        const dangerousPattern = /<\s*(script|iframe|object|embed|link|style)\b[^>]*>(.*?)<\s*\/\s*\1\s*>|<\s*(script|iframe|object|embed|link|style)\b[^>]*\/?>|<[^>]+>/gi;
+        function checkValue(value) {
+            if (typeof value === 'string') {
+                return dangerousPattern.test(value);
+            }
+            if (Array.isArray(value)) {
+                return value.some(checkValue);
+            }
+            if (typeof value === 'object' && value !== null) {
+                return Object.values(value).some(checkValue);
+            }
+            // If it's a number, boolean, null, or undefined, ignore
+            return false;
+        }
+        return checkValue(formData);
+    }
+}
+VaptValidationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: VaptValidationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+VaptValidationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: VaptValidationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: VaptValidationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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