common-header-lib 0.0.1

package/esm2020/lib/pipes/slice-to-two.pipe.mjs

@@ -0,0 +1,34 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SliceToTwoPipe {
+    transform(textName) {
+        if (textName === null || textName === '') {
+            return 'NA';
+        }
+        textName = textName?.trim();
+        let result = '';
+        if (textName && textName.includes(' ')) {
+            let splitStringArr = textName.split(' ');
+            result =
+                splitStringArr[0][0] + splitStringArr[splitStringArr.length - 1][0];
+        }
+        else if (textName && textName.includes('_')) {
+            let splitStringArr = textName.split('_');
+            result =
+                splitStringArr[0][0] + splitStringArr[splitStringArr.length - 1][0];
+        }
+        else {
+            result = textName[0] + textName[1];
+        }
+        return result.toLocaleUpperCase();
+    }
+}
+SliceToTwoPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SliceToTwoPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+SliceToTwoPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: SliceToTwoPipe, name: "sliceToTwo" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SliceToTwoPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'sliceToTwo',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,100 @@
+import { Injectable } from '@angular/core';
+import * as CryptoJS from 'crypto-js';
+import JSEncrypt from 'jsencrypt';
+import * as i0 from "@angular/core";
+export class EncrydecryRSAdataService {
+    generateAESKey() {
+        const publicKey = this.getPublicKey();
+        const symmetricKey = this.generateKeyAndIV();
+        const gkey = symmetricKey.key.toString();
+        const giv = symmetricKey.iv.toString();
+        const key = gkey + ',' + giv;
+        const encryptedSymmetricKey = this.encryptSymmetricKey(gkey, publicKey);
+        const encryptedSymmetriciv = this.encryptSymmetricKey(giv, publicKey);
+        return String(encryptedSymmetricKey + ',' + encryptedSymmetriciv);
+    }
+    encryptViaRSA(simpleText) {
+        const { symmKey, symmIV } = this.getRSAsymmetricKeyIV();
+        const encryptedText = this.encryptText(simpleText, symmKey, symmIV);
+        return encryptedText;
+    }
+    decryptViaRSA(encrpyText) {
+        const { symmKey, symmIV } = this.getRSAsymmetricKeyIV();
+        const decryptedText = this.decryptText(encrpyText, symmKey, symmIV);
+        return decryptedText;
+    }
+    generateKeyAndIV() {
+        const key = CryptoJS.lib.WordArray.random(32); // 32 bytes for AES-256
+        const iv = CryptoJS.lib.WordArray.random(16); // 16 bytes IV
+        return { key, iv };
+    }
+    encryptText(plaintext, hkey, hiv) {
+        //* If the data is Object then converting the object into JSON.stringify()
+        if (typeof plaintext === 'object' && plaintext !== null) {
+            plaintext = JSON.stringify(plaintext);
+        }
+        const key = CryptoJS.enc.Hex.parse(hkey);
+        const iv = CryptoJS.enc.Hex.parse(hiv);
+        const encrypted = CryptoJS.AES.encrypt(plaintext, key, {
+            iv: iv,
+            mode: CryptoJS.mode.CBC,
+            padding: CryptoJS.pad.Pkcs7,
+        });
+        return encrypted.toString();
+    }
+    encryptSymmetricKey(key, publicKey) {
+        try {
+            const rsa = new JSEncrypt();
+            rsa.setPublicKey(publicKey);
+            const encryptedKey = rsa.encrypt(key);
+            if (!encryptedKey)
+                throw new Error('Encryption failed. The key might be improperly formatted.');
+            return encryptedKey;
+        }
+        catch (error) {
+            console.error(`Encryption error: ${error.message}`);
+            return '';
+        }
+    }
+    decryptText(encryptedBase64, hkey, hiv) {
+        const key = CryptoJS.enc.Hex.parse(hkey);
+        const iv = CryptoJS.enc.Hex.parse(hiv);
+        const decrypted = CryptoJS.AES.decrypt(encryptedBase64, key, {
+            iv: iv,
+            mode: CryptoJS.mode.CBC,
+            padding: CryptoJS.pad.Pkcs7,
+        });
+        return decrypted.toString(CryptoJS.enc.Utf8);
+    }
+    getPublicKey() {
+        const publicKey = this.base64ToPem(localStorage.getItem('001-SAC-GEC') || '');
+        return publicKey;
+    }
+    getRSAsymmetricKeyIV() {
+        let symmKey = '';
+        let symmIV = '';
+        const key = localStorage.getItem('001-SAC-GEC');
+        if (key?.includes(',')) {
+            const syymArr = key.split(',');
+            symmKey = syymArr[0];
+            symmIV = syymArr[1];
+        }
+        return { symmKey, symmIV };
+    }
+    base64ToPem(base64Key) {
+        const pemHeader = '-----BEGIN PUBLIC KEY-----';
+        const pemFooter = '-----END PUBLIC KEY-----';
+        const chunkSize = 64; // Standard line length for PEM files
+        const formattedKey = base64Key.match(new RegExp(`.{1,${chunkSize}}`, 'g'))?.join('\n') || '';
+        return `${pemHeader}\n${formattedKey}\n${pemFooter}`;
+    }
+}
+EncrydecryRSAdataService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EncrydecryRSAdataService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+EncrydecryRSAdataService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EncrydecryRSAdataService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EncrydecryRSAdataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EncrypDecryp_RSA.service.js","sourceRoot":"","sources":["../../../../../projects/common-header-lib/src/lib/services/EncrypDecryp_RSA.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport * as CryptoJS from 'crypto-js';\r\nimport JSEncrypt from 'jsencrypt';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class EncrydecryRSAdataService {\r\n  public generateAESKey() {\r\n    const publicKey = this.getPublicKey();\r\n    const symmetricKey = this.generateKeyAndIV();\r\n    const gkey = symmetricKey.key.toString();\r\n    const giv = symmetricKey.iv.toString();\r\n    const key = gkey + ',' + giv;\r\n\r\n    const encryptedSymmetricKey = this.encryptSymmetricKey(gkey, publicKey);\r\n    const encryptedSymmetriciv = this.encryptSymmetricKey(giv, publicKey);\r\n    return String(encryptedSymmetricKey + ',' + encryptedSymmetriciv);\r\n  }\r\n\r\n  public encryptViaRSA(simpleText: any) {\r\n    const { symmKey, symmIV } = this.getRSAsymmetricKeyIV();\r\n    const encryptedText = this.encryptText(simpleText, symmKey, symmIV);\r\n    return encryptedText;\r\n  }\r\n\r\n  public decryptViaRSA(encrpyText: string) {\r\n    const { symmKey, symmIV } = this.getRSAsymmetricKeyIV();\r\n    const decryptedText = this.decryptText(encrpyText, symmKey, symmIV);\r\n    return decryptedText;\r\n  }\r\n\r\n  private generateKeyAndIV() {\r\n    const key = CryptoJS.lib.WordArray.random(32); // 32 bytes for AES-256\r\n    const iv = CryptoJS.lib.WordArray.random(16); // 16 bytes IV\r\n    return { key, iv };\r\n  }\r\n\r\n  private encryptText(plaintext: any, hkey: string, hiv: string) {\r\n    //* If the data is Object then converting the object into JSON.stringify()\r\n    if (typeof plaintext === 'object' && plaintext !== null) {\r\n      plaintext = JSON.stringify(plaintext);\r\n    }\r\n\r\n    const key = CryptoJS.enc.Hex.parse(hkey);\r\n    const iv = CryptoJS.enc.Hex.parse(hiv);\r\n    const encrypted = CryptoJS.AES.encrypt(plaintext, key, {\r\n      iv: iv,\r\n      mode: CryptoJS.mode.CBC,\r\n      padding: CryptoJS.pad.Pkcs7,\r\n    });\r\n    return encrypted.toString();\r\n  }\r\n\r\n  private encryptSymmetricKey(key: string, publicKey: string) {\r\n    try {\r\n      const rsa = new JSEncrypt();\r\n      rsa.setPublicKey(publicKey);\r\n      const encryptedKey = rsa.encrypt(key);\r\n      if (!encryptedKey)\r\n        throw new Error(\r\n          'Encryption failed. The key might be improperly formatted.'\r\n        );\r\n      return encryptedKey;\r\n    } catch (error) {\r\n      console.error(`Encryption error: ${(error as Error).message}`);\r\n      return '';\r\n    }\r\n  }\r\n\r\n  private decryptText(encryptedBase64: string, hkey: string, hiv: string) {\r\n    const key = CryptoJS.enc.Hex.parse(hkey);\r\n    const iv = CryptoJS.enc.Hex.parse(hiv);\r\n    const decrypted = CryptoJS.AES.decrypt(encryptedBase64, key, {\r\n      iv: iv,\r\n      mode: CryptoJS.mode.CBC,\r\n      padding: CryptoJS.pad.Pkcs7,\r\n    });\r\n    return decrypted.toString(CryptoJS.enc.Utf8);\r\n  }\r\n\r\n  private getPublicKey() {\r\n    const publicKey = this.base64ToPem(\r\n      localStorage.getItem('001-SAC-GEC') || ''\r\n    );\r\n    return publicKey;\r\n  }\r\n\r\n  private getRSAsymmetricKeyIV() {\r\n    let symmKey = '';\r\n    let symmIV = '';\r\n    const key = localStorage.getItem('001-SAC-GEC');\r\n    if (key?.includes(',')) {\r\n      const syymArr = key.split(',');\r\n      symmKey = syymArr[0];\r\n      symmIV = syymArr[1];\r\n    }\r\n    return { symmKey, symmIV };\r\n  }\r\n\r\n  base64ToPem(base64Key: string): string {\r\n    const pemHeader = '-----BEGIN PUBLIC KEY-----';\r\n    const pemFooter = '-----END PUBLIC KEY-----';\r\n    const chunkSize = 64; // Standard line length for PEM files\r\n    const formattedKey =\r\n      base64Key.match(new RegExp(`.{1,${chunkSize}}`, 'g'))?.join('\\n') || '';\r\n    return `${pemHeader}\\n${formattedKey}\\n${pemFooter}`;\r\n  }\r\n}\r\n"]}

package/esm2020/lib/services/async-passwordcheck.service.mjs

@@ -0,0 +1,72 @@
+import { Injectable } from '@angular/core';
+import { catchError, debounceTime, switchMap, take, map } from 'rxjs/operators';
+import { Subject, of } from 'rxjs';
+import { EncrydecryRSAdataService } from './EncrypDecryp_RSA.service';
+import { HttpCommonService } from './http/http-common.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./http/http-common.service";
+import * as i2 from "./EncrypDecryp_RSA.service";
+export class ASYNCPasswordcheckService {
+    constructor(httpCommonService, encryptService) {
+        this.httpCommonService = httpCommonService;
+        this.encryptService = encryptService;
+        this.pwdErrorMsg = '';
+        this.pwdValidation = new Subject();
+    }
+    createValidator() {
+        return (control) => {
+            //For AES Encrp/Dec
+            const userPassword = this.encryptService.encryptViaRSA(control.value);
+            let useDetails = {
+                userARCXWD: userPassword,
+                // userId: LoggedInUserInfo.userId,
+                // userName: LoggedInUserInfo.userName,
+            };
+            return control.valueChanges.pipe(debounceTime(500), take(1), switchMap((_) => this.httpCommonService.validatePassword(useDetails).pipe(map((data) => {
+                if (data['success']) {
+                    this.pwdErrorMsg = data['message'];
+                    // console.log(this.pwdErrorMsg);
+                    this.emitValidationMsg(this.pwdErrorMsg);
+                    return null;
+                }
+                else {
+                    this.pwdErrorMsg = data['errorMessage'];
+                    this.emitValidationMsg(this.pwdErrorMsg);
+                    // console.log(this.pwdErrorMsg);
+                    return { pwdInvalid: true };
+                }
+            }), catchError(() => of({ pwdInvalid: true })))));
+        };
+    }
+    emitValidationMsg(msg) {
+        this.pwdValidation.next(msg);
+    }
+    listValidationMsg() {
+        return this.pwdValidation.asObservable();
+    }
+}
+ASYNCPasswordcheckService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ASYNCPasswordcheckService, deps: [{ token: i1.HttpCommonService }, { token: i2.EncrydecryRSAdataService }], target: i0.ɵɵFactoryTarget.Injectable });
+ASYNCPasswordcheckService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ASYNCPasswordcheckService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ASYNCPasswordcheckService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpCommonService }, { type: i2.EncrydecryRSAdataService }]; } });
+export function ConfirmedValidator(controlName, matchingControlName) {
+    return (formGroup) => {
+        const control = formGroup.controls[controlName];
+        const matchingControl = formGroup.controls[matchingControlName];
+        if (matchingControl.errors &&
+            !matchingControl.errors['confirmedValidator']) {
+            return;
+        }
+        if (control.value !== matchingControl.value) {
+            matchingControl.setErrors({ confirmedValidator: true });
+        }
+        else {
+            matchingControl.setErrors(null);
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/cookie-storage-manager.service.mjs

@@ -0,0 +1,78 @@
+import { Injectable } from '@angular/core';
+import { CookieService } from 'ngx-cookie-service';
+import { HttpClient } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-cookie-service";
+import * as i2 from "@angular/common/http";
+export class CookieStorageManagerService {
+    constructor(cookie, _http) {
+        this.cookie = cookie;
+        this._http = _http;
+    }
+    //Check if cookies is set or not
+    checksetCookies(cookiesParam1) {
+        let status = this.cookie.check(cookiesParam1);
+        if (status) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    //get cookies value
+    getCookieValue(cookiesParam) {
+        let status = this.cookie.check(cookiesParam);
+        if (status) {
+            let cookieValue = this.cookie.get(cookiesParam);
+            return cookieValue;
+        }
+        //What if cookies not found
+        else {
+            return '';
+        }
+    }
+    //Set cookies value
+    setCookiesValue(key, value) {
+        this.cookie.set(key, value);
+    }
+    //Delete a specific cookie
+    deleteCookie(cookieKey) {
+        this.cookie.delete(cookieKey);
+    }
+    //Delete All cookie
+    clearAllCookies() {
+        const cookies = this.cookie.getAll();
+        for (const cookieName in cookies) {
+            if (cookies.hasOwnProperty(cookieName)) {
+                this.cookie.delete(cookieName);
+            }
+        }
+    }
+    //Delete All cookie
+    // clearCookiesByAPI(payload: any) {
+    //   const delCookieEndpoint = `${GlobalConstants.baseURL}/xaccess/api/SecureAccess/cookiesUpdation`;
+    //   return this._http.post(delCookieEndpoint, payload).pipe(map((response:any)=>{
+    //     if (response && response['success']) {
+    //       return response['result'];
+    //     } else {
+    //       return null;
+    //     }
+    //   }));
+    // }
+    //Set Long cookies
+    setLongCookie(name, value, maxChunkSize) {
+        for (let i = 0; i < Math.ceil(value.length / maxChunkSize); i++) {
+            const chunk = value.substring(i * maxChunkSize, (i + 1) * maxChunkSize);
+            this.setCookiesValue(`${name}_${i}`, chunk);
+        }
+    }
+}
+CookieStorageManagerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CookieStorageManagerService, deps: [{ token: i1.CookieService }, { token: i2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+CookieStorageManagerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CookieStorageManagerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CookieStorageManagerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CookieService }, { type: i2.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,55 @@
+import { Injectable } from '@angular/core';
+import { LoggedInUserInfo } from '../model/data_model';
+import * as i0 from "@angular/core";
+export class EncrpdataService {
+    constructor() {
+        // private publicKey: string =
+        //   '10234186980819816859565723471972110581900468266056266385607156653250136308259057583501560583440295112186917105135474383769292631464432088817050933329522683,65537';
+        this.privateKey = "";
+    }
+    getASCIIValue(text) {
+        let charCodeArr = [];
+        for (let i = 0; i < text.length; i++) {
+            let code = text.charCodeAt(i);
+            charCodeArr.push(BigInt(code));
+        }
+        return charCodeArr;
+    }
+    getModuleValue(arr, num1, num2) {
+        let numArr = [];
+        for (let i = 0; i < arr.length; i++) {
+            let code = arr[i] ** num2 % num1;
+            numArr.push(code);
+        }
+        return numArr;
+    }
+    getEncrpytedData(text) {
+        this.privateKey = LoggedInUserInfo.privateKey;
+        let key = this.privateKey.split(',');
+        const num1 = BigInt(key[0]);
+        const num2 = BigInt(key[1]);
+        //1. Convert string to phiN 
+        let asciiValue = this.getASCIIValue(text);
+        //2. Get Mod of All Value
+        let ModValue = this.getModuleValue(asciiValue, num1, num2);
+        //3. Convert Arr to String
+        // let encodedText = ModValue.join('-');
+        const encodedText = ModValue.map(b => b.toString()).join('-');
+        return encodedText;
+    }
+    encodeToBase64(text) {
+        return btoa(text);
+    }
+    decodeToBase64(text) {
+        return atob(text);
+    }
+}
+EncrpdataService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EncrpdataService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+EncrpdataService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EncrpdataService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EncrpdataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,207 @@
+import { Injectable } from '@angular/core';
+import { StorageService } from './storage.service';
+import { COOKIECONSTANT, LoggedInUserInfo } from '../model/data_model';
+import * as bigintCryptoUtils from 'bigint-crypto-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./storage.service";
+export class EncrydecrydataService {
+    constructor(_storageService) {
+        this._storageService = _storageService;
+        this.phiN = BigInt('1439652808780798693078119762209596147168096953796219172262910821317967061987350219660913015278464376519592636923598633193936864497263640780784805168728449');
+        this.m = BigInt('1439652808780798693078119762209596147168096953796219172262910821317967061987270868696269635759315523684521986922202953647194318017157636815317250179926320');
+        this.Genrator = 5;
+        this.min = 10000000;
+        this.max = 10000000 * 10000000;
+    }
+    generate() {
+        this.randomPrime = this.generateRandomPrime(this.min, this.max);
+        let code = bigintCryptoUtils.modPow(this.Genrator, BigInt(this.randomPrime), this.phiN);
+        return code;
+    }
+    process(key) {
+        let secretcode = bigintCryptoUtils.modPow(BigInt(key), BigInt(this.randomPrime), this.phiN);
+        // console.log('Private Pro Key: ', secretcode);
+        this._storageService.saveData(COOKIECONSTANT.ERRORCODE, secretcode.toString());
+    }
+    encryptViaCrypto(normalText) {
+        const code = this.getSecretCode();
+        const encryptedMessagedata = this.encryptMessage(normalText, code);
+        return encryptedMessagedata;
+    }
+    decryptViaCrypto(cipherText) {
+        const decryptedData = this.base64ToUint8Array(cipherText);
+        const code = this.getSecretCode();
+        let decryptdata = this.decrypt(decryptedData, code);
+        let decryptdatastr = this.bytesToString(decryptdata);
+        return decryptdatastr;
+    }
+    decryptResponseViaCrypto(cipherText) {
+        const code = String(this.getPublicKey());
+        const decryptdata = this.decrypt123(cipherText, code);
+        return decryptdata;
+    }
+    //todo amit
+    // private decrypt123(messageme: string, key: string): string {
+    //   let bigKey: bigint = BigInt(key);
+    //   let bytes: string = atob(messageme);
+    //   let decryptedBytes: number[] = [];
+    //   for (let i = 0; i < bytes.length; i++) {
+    //     let byteValue: bigint = BigInt(bytes.charCodeAt(i));
+    //     byteValue = (byteValue - bigKey) % 256n;
+    //     if (byteValue < 0n) {
+    //       byteValue = 256n + byteValue;
+    //     }
+    //     decryptedBytes.push(Number(byteValue));
+    //   }
+    //   let decryptedMessage: string = String.fromCharCode.apply(
+    //     null,
+    //     decryptedBytes
+    //   );
+    //   return decryptedMessage;
+    // }
+    //new amit
+    decrypt123(messageme, key) {
+        const bigKey = BigInt(key);
+        const bytes = atob(messageme);
+        const decryptedBytes = [];
+        for (let i = 0; i < bytes.length; i++) {
+            let byteValue = BigInt(bytes.charCodeAt(i));
+            byteValue = (byteValue - bigKey) % BigInt(256);
+            if (byteValue < BigInt(0)) {
+                byteValue = BigInt(256) + byteValue;
+            }
+            decryptedBytes.push(Number(byteValue));
+        }
+        return String.fromCharCode(...decryptedBytes);
+    }
+    encryptMessage(message, sharedSecret) {
+        const messageBytes = new TextEncoder().encode(message);
+        const encryptedMessage = this.encrypt(messageBytes, sharedSecret);
+        // console.log(encryptedMessage);
+        return this.encryptMessageToBase64(encryptedMessage);
+        //return encryptedMessage;
+    }
+    base64ToUint8Array(base64String) {
+        const decodedString = atob(base64String);
+        const uint8Array = new Uint8Array(decodedString.length);
+        for (let i = 0; i < decodedString.length; i++) {
+            uint8Array[i] = decodedString.charCodeAt(i);
+        }
+        return uint8Array;
+    }
+    bytesToString(bytes) {
+        let str = '';
+        for (let i = 0; i < bytes.length; i++) {
+            str += String.fromCharCode(bytes[i]);
+        }
+        return str;
+    }
+    encryptMessageToBase64(encryptedMessage) {
+        const encryptedArray = Array.from(encryptedMessage);
+        const messageString = String.fromCharCode.apply(null, encryptedArray);
+        const base64String = btoa(messageString);
+        return base64String;
+    }
+    bigintToBytes(key) {
+        const hexString = key.toString(16);
+        const byteLength = Math.ceil(hexString.length / 2);
+        const bytes = new Uint8Array(byteLength);
+        let i = hexString.length;
+        let j = 0;
+        while (i > 0) {
+            bytes[j++] = parseInt(hexString.substring(Math.max(i - 2, 0), i), 16);
+            i -= 2;
+        }
+        return bytes;
+    }
+    encrypt(data, key) {
+        const keyBytes = this.bigintToBytes(key);
+        const encryptedData = new Uint8Array(data.length);
+        for (let i = 0; i < data.length; i++) {
+            encryptedData[i] = data[i] ^ keyBytes[i % keyBytes.length];
+        }
+        return encryptedData;
+    }
+    decrypt(data, key) {
+        return this.encrypt(data, key);
+    }
+    generateRandomPrime(min, max) {
+        const isPrime = (num) => {
+            if (num <= 1)
+                return false;
+            if (num <= 3)
+                return true;
+            if (num % 2 === 0 || num % 3 === 0)
+                return false;
+            let i = 5;
+            while (i * i <= num) {
+                if (num % i === 0 || num % (i + 2) === 0)
+                    return false;
+                i += 6;
+            }
+            return true;
+        };
+        let prime;
+        do {
+            prime = Math.floor(Math.random() * (max - min + 1)) + min;
+        } while (!isPrime(prime));
+        return prime;
+    }
+    getSecretCode() {
+        //todo Amit -
+        // const key = this._storageService.getData(COOKIECONSTANT.ERRORCODE);
+        const key = this._storageService.getData(COOKIECONSTANT.ERRORCODE) ?? '0000';
+        return this.convertToBigInt(key);
+    }
+    convertToBigInt(value) {
+        try {
+            return BigInt(value);
+        }
+        catch {
+            return BigInt('0000');
+        }
+    }
+    getPublicKey() {
+        const publicKey = LoggedInUserInfo.privateKey;
+        // Check if publicKey is undefined, null, or empty
+        if (!publicKey) {
+            console.error('Public key is missing.');
+            return this.convertToBigInt('0');
+        }
+        const KeyArr = publicKey.split(',');
+        if (KeyArr.length === 0 || !KeyArr[0]) {
+            return this.convertToBigInt('0');
+        }
+        const keySegment = KeyArr[0];
+        // const keySegment = KeyArr[0].slice(0, 10);
+        // const keySegment = this.getSlicePublicKey(KeyArr[0]);
+        if (!keySegment) {
+            return this.convertToBigInt('0');
+        }
+        try {
+            return this.convertToBigInt(keySegment);
+        }
+        catch (error) {
+            return this.convertToBigInt('0');
+        }
+    }
+    getSlicePublicKey(key) {
+        const subString = key.length >= 20 ? key.substring(0, 20) : key;
+        const uniqueKey = this.getUniqueLetter(subString);
+        return uniqueKey;
+    }
+    getUniqueLetter(text) {
+        const textSet = new Set(text);
+        const uniqueString = [...textSet].join('');
+        return uniqueString;
+    }
+}
+EncrydecrydataService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EncrydecrydataService, deps: [{ token: i1.StorageService }], target: i0.ɵɵFactoryTarget.Injectable });
+EncrydecrydataService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EncrydecrydataService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EncrydecrydataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.StorageService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encrydecrydata.service.js","sourceRoot":"","sources":["../../../../../projects/common-header-lib/src/lib/services/encrydecrydata.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { StorageService } from './storage.service';\r\nimport { COOKIECONSTANT, LoggedInUserInfo } from '../model/data_model';\r\nimport * as bigintCryptoUtils from 'bigint-crypto-utils';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class EncrydecrydataService {\r\n  phiN = BigInt(\r\n    '1439652808780798693078119762209596147168096953796219172262910821317967061987350219660913015278464376519592636923598633193936864497263640780784805168728449'\r\n  );\r\n  m = BigInt(\r\n    '1439652808780798693078119762209596147168096953796219172262910821317967061987270868696269635759315523684521986922202953647194318017157636815317250179926320'\r\n  );\r\n  Genrator = 5;\r\n  min = 10000000;\r\n  max = 10000000 * 10000000;\r\n  randomPrime: any;\r\n\r\n  constructor(private _storageService: StorageService) {}\r\n\r\n  public generate() {\r\n    this.randomPrime = this.generateRandomPrime(this.min, this.max);\r\n    let code = bigintCryptoUtils.modPow(\r\n      this.Genrator,\r\n      BigInt(this.randomPrime),\r\n      this.phiN\r\n    );\r\n    return code;\r\n  }\r\n\r\n  public process(key: string) {\r\n    let secretcode = bigintCryptoUtils.modPow(\r\n      BigInt(key),\r\n      BigInt(this.randomPrime),\r\n      this.phiN\r\n    );\r\n\r\n    // console.log('Private Pro Key: ', secretcode);\r\n    this._storageService.saveData(\r\n      COOKIECONSTANT.ERRORCODE,\r\n      secretcode.toString()\r\n    );\r\n  }\r\n\r\n  public encryptViaCrypto(normalText: string) {\r\n    const code = this.getSecretCode();\r\n    const encryptedMessagedata = this.encryptMessage(normalText, code);\r\n    return encryptedMessagedata;\r\n  }\r\n\r\n  public decryptViaCrypto(cipherText: string) {\r\n    const decryptedData = this.base64ToUint8Array(cipherText);\r\n    const code = this.getSecretCode();\r\n    let decryptdata = this.decrypt(decryptedData, code);\r\n    let decryptdatastr = this.bytesToString(decryptdata);\r\n    return decryptdatastr;\r\n  }\r\n\r\n  public decryptResponseViaCrypto(cipherText: string) {\r\n    const code: string = String(this.getPublicKey());\r\n    const decryptdata = this.decrypt123(cipherText, code);\r\n    return decryptdata;\r\n  }\r\n\r\n  //todo amit\r\n  // private decrypt123(messageme: string, key: string): string {\r\n  //   let bigKey: bigint = BigInt(key);\r\n  //   let bytes: string = atob(messageme);\r\n  //   let decryptedBytes: number[] = [];\r\n  //   for (let i = 0; i < bytes.length; i++) {\r\n  //     let byteValue: bigint = BigInt(bytes.charCodeAt(i));\r\n  //     byteValue = (byteValue - bigKey) % 256n;\r\n  //     if (byteValue < 0n) {\r\n  //       byteValue = 256n + byteValue;\r\n  //     }\r\n  //     decryptedBytes.push(Number(byteValue));\r\n  //   }\r\n  //   let decryptedMessage: string = String.fromCharCode.apply(\r\n  //     null,\r\n  //     decryptedBytes\r\n  //   );\r\n  //   return decryptedMessage;\r\n  // }\r\n\r\n  //new amit\r\n  private decrypt123(messageme: string, key: string): string {\r\n    const bigKey = BigInt(key);\r\n    const bytes = atob(messageme);\r\n    const decryptedBytes: number[] = [];\r\n\r\n    for (let i = 0; i < bytes.length; i++) {\r\n      let byteValue = BigInt(bytes.charCodeAt(i));\r\n      byteValue = (byteValue - bigKey) % BigInt(256);\r\n      if (byteValue < BigInt(0)) {\r\n        byteValue = BigInt(256) + byteValue;\r\n      }\r\n      decryptedBytes.push(Number(byteValue));\r\n    }\r\n\r\n    return String.fromCharCode(...decryptedBytes);\r\n  }\r\n\r\n  private encryptMessage(message: string, sharedSecret: bigint): string {\r\n    const messageBytes = new TextEncoder().encode(message);\r\n\r\n    const encryptedMessage = this.encrypt(messageBytes, sharedSecret);\r\n    // console.log(encryptedMessage);\r\n    return this.encryptMessageToBase64(encryptedMessage);\r\n    //return encryptedMessage;\r\n  }\r\n\r\n  private base64ToUint8Array(base64String: string): Uint8Array {\r\n    const decodedString = atob(base64String);\r\n\r\n    const uint8Array = new Uint8Array(decodedString.length);\r\n    for (let i = 0; i < decodedString.length; i++) {\r\n      uint8Array[i] = decodedString.charCodeAt(i);\r\n    }\r\n\r\n    return uint8Array;\r\n  }\r\n\r\n  private bytesToString(bytes: Uint8Array): string {\r\n    let str = '';\r\n    for (let i = 0; i < bytes.length; i++) {\r\n      str += String.fromCharCode(bytes[i]);\r\n    }\r\n    return str;\r\n  }\r\n\r\n  private encryptMessageToBase64(encryptedMessage: Uint8Array): string {\r\n    const encryptedArray = Array.from(encryptedMessage);\r\n    const messageString = String.fromCharCode.apply(null, encryptedArray);\r\n    const base64String = btoa(messageString);\r\n    return base64String;\r\n  }\r\n\r\n  private bigintToBytes(key: bigint): Uint8Array {\r\n    const hexString = key.toString(16);\r\n    const byteLength = Math.ceil(hexString.length / 2);\r\n    const bytes = new Uint8Array(byteLength);\r\n    let i = hexString.length;\r\n    let j = 0;\r\n    while (i > 0) {\r\n      bytes[j++] = parseInt(hexString.substring(Math.max(i - 2, 0), i), 16);\r\n      i -= 2;\r\n    }\r\n    return bytes;\r\n  }\r\n\r\n  private encrypt(data: Uint8Array, key: bigint): Uint8Array {\r\n    const keyBytes = this.bigintToBytes(key);\r\n    const encryptedData = new Uint8Array(data.length);\r\n\r\n    for (let i = 0; i < data.length; i++) {\r\n      encryptedData[i] = data[i] ^ keyBytes[i % keyBytes.length];\r\n    }\r\n\r\n    return encryptedData;\r\n  }\r\n\r\n  private decrypt(data: Uint8Array, key: bigint): Uint8Array {\r\n    return this.encrypt(data, key);\r\n  }\r\n\r\n  private generateRandomPrime(min: number, max: number): number {\r\n    const isPrime = (num: number) => {\r\n      if (num <= 1) return false;\r\n      if (num <= 3) return true;\r\n      if (num % 2 === 0 || num % 3 === 0) return false;\r\n      let i = 5;\r\n      while (i * i <= num) {\r\n        if (num % i === 0 || num % (i + 2) === 0) return false;\r\n        i += 6;\r\n      }\r\n      return true;\r\n    };\r\n\r\n    let prime;\r\n    do {\r\n      prime = Math.floor(Math.random() * (max - min + 1)) + min;\r\n    } while (!isPrime(prime));\r\n    return prime;\r\n  }\r\n\r\n  private getSecretCode(): bigint {\r\n    //todo Amit -\r\n    // const key = this._storageService.getData(COOKIECONSTANT.ERRORCODE);\r\n    const key =\r\n      this._storageService.getData(COOKIECONSTANT.ERRORCODE) ?? '0000';\r\n    return this.convertToBigInt(key);\r\n  }\r\n\r\n  private convertToBigInt(value: string): bigint {\r\n    try {\r\n      return BigInt(value);\r\n    } catch {\r\n      return BigInt('0000');\r\n    }\r\n  }\r\n\r\n  private getPublicKey() {\r\n    const publicKey: string | undefined = LoggedInUserInfo.privateKey;\r\n\r\n    // Check if publicKey is undefined, null, or empty\r\n    if (!publicKey) {\r\n      console.error('Public key is missing.');\r\n      return this.convertToBigInt('0');\r\n    }\r\n    const KeyArr = publicKey.split(',');\r\n\r\n    if (KeyArr.length === 0 || !KeyArr[0]) {\r\n      return this.convertToBigInt('0');\r\n    }\r\n\r\n    const keySegment = KeyArr[0];\r\n    // const keySegment = KeyArr[0].slice(0, 10);\r\n    // const keySegment = this.getSlicePublicKey(KeyArr[0]);\r\n\r\n    if (!keySegment) {\r\n      return this.convertToBigInt('0');\r\n    }\r\n\r\n    try {\r\n      return this.convertToBigInt(keySegment);\r\n    } catch (error) {\r\n      return this.convertToBigInt('0');\r\n    }\r\n  }\r\n\r\n  private getSlicePublicKey(key: string): string {\r\n    const subString = key.length >= 20 ? key.substring(0, 20) : key;\r\n    const uniqueKey: string = this.getUniqueLetter(subString);\r\n    return uniqueKey;\r\n  }\r\n\r\n  private getUniqueLetter(text: string) {\r\n    const textSet = new Set(text);\r\n    const uniqueString = [...textSet].join('');\r\n    return uniqueString;\r\n  }\r\n}\r\n"]}