@traxionpay/cbsmiddleware 0.0.1

package/dist/banking/services/WelcomeBank.service.js

@@ -0,0 +1,840 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WelcomeBankService = void 0;
+const common_1 = require("@nestjs/common");
+const axios_1 = __importDefault(require("axios"));
+const axios_error_helper_1 = require("../../helpers/axios-error.helper");
+const bank_service_tokens_1 = require("../tokens/bank-service.tokens");
+const https = __importStar(require("https"));
+const speakeasy = __importStar(require("speakeasy"));
+const CryptoJS = __importStar(require("crypto-js"));
+const nestjs_pino_1 = require("nestjs-pino");
+let WelcomeBankService = class WelcomeBankService {
+    config;
+    logger;
+    secretKey = '5HZ3HAX4MVCGFH3EWYP3U62QRDR6R3TD';
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    generateTOTP(serverTimestamp) {
+        const timeInSeconds = typeof serverTimestamp === 'string'
+            ? Math.floor(Date.parse(serverTimestamp) / 1000)
+            : serverTimestamp;
+        return speakeasy.totp({
+            secret: this.secretKey,
+            encoding: 'base32',
+            step: 30,
+            algorithm: 'sha1',
+            digits: 6,
+            time: timeInSeconds,
+        });
+    }
+    encryptPayloadWithOTP(payload, otp) {
+        const stringified = JSON.stringify(payload);
+        const encrypted = CryptoJS.AES.encrypt(stringified, otp).toString();
+        return encrypted;
+    }
+    decryptPayloadWithOTP(encryptedPayload, otp) {
+        const decrypted = CryptoJS.AES.decrypt(encryptedPayload, otp);
+        const plaintext = decrypted.toString(CryptoJS.enc.Utf8);
+        try {
+            return JSON.parse(plaintext);
+        }
+        catch (err) {
+            this.logger.error("Failed to JSON.parse decrypted payload", err);
+            throw new Error("Decryption or JSON parsing failed");
+        }
+    }
+    async generateToken() {
+        this.logger.log("Generating WelcomeBank Token");
+        try {
+            const headers = {
+                'Content-Type': 'application/json',
+                'X-API-KEY': `${this.config.WELCOMEBANK_API_KEY}`,
+                'X-API-VERSION': `${this.config.WELCOMEBANK_VERSION_KEY}`
+            };
+            const httpsAgent = new https.Agent({
+                rejectUnauthorized: false,
+            });
+            const response = await axios_1.default.get(`${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/token/generate`, {
+                headers: headers,
+                httpsAgent,
+            });
+            this.logger.log({ responseData: response }, 'Welcome Bank Token generated successfully');
+            return {
+                success: true,
+                ...response.data,
+            };
+        }
+        catch (error) {
+            axios_error_helper_1.AxiosErrorHelper.handleAxiosError(error);
+        }
+    }
+    async refreshToken(refreshToken) {
+        if (!refreshToken) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020206,
+                message: 'Bank token should not be empty.',
+                data: { refreshToken }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        this.logger.log("Welcome Bank refresh token");
+        try {
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+            const payload = {
+                "refreshToken": refreshToken
+            };
+            const httpsAgent = new https.Agent({
+                rejectUnauthorized: false,
+            });
+            const response = await axios_1.default.post(`${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/token/refresh`, payload, {
+                headers: headers,
+                httpsAgent,
+            });
+            this.logger.log({ responseData: response }, 'Welcome Bank Refresh Token Successful');
+            return {
+                success: true,
+                ...response.data,
+            };
+        }
+        catch (error) {
+            axios_error_helper_1.AxiosErrorHelper.handleAxiosError(error);
+        }
+    }
+    async linkAccount(accountDto) {
+        const { token, account, branch, accountType, mobile } = accountDto;
+        if (!token) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.UNAUTHORIZED,
+                code: 401020302,
+                message: 'Bank token should not be empty.',
+                data: { accountDto }
+            }, common_1.HttpStatus.UNAUTHORIZED);
+        }
+        if (!account) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020304,
+                message: 'Bank account number should not be empty.',
+                data: { accountDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!accountType) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 4400020306,
+                message: 'Bank account type should not be empty.',
+                data: { accountDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!mobile) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 4000203009,
+                message: 'Mobile Number should not be empty.',
+                data: { accountDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        this.logger.log("Welcome Bank Link Account");
+        const isoTimestamp = new Date().toISOString();
+        const timeInSeconds = Math.floor(Date.parse(isoTimestamp) / 1000);
+        const totp = this.generateTOTP(timeInSeconds);
+        const totpPrevious = this.generateTOTP(timeInSeconds - 30);
+        this.logger.log(`TOTP GENERATED FOR WELCOMEBANK LINK ACCOUNT: ${totp}, For Time stamp: ${isoTimestamp}`);
+        this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
+        try {
+            const headers = {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                'X-SERVER-TIMESTAMP': `${isoTimestamp}`
+            };
+            const httpsAgent = new https.Agent({
+                rejectUnauthorized: false,
+            });
+            let response;
+            if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+                let payload;
+                payload = {
+                    "acc": account,
+                    "br": branch,
+                    "accType": accountType,
+                    "mobile": mobile
+                };
+                payload = this.encryptPayloadWithOTP(payload, totp);
+                const encodedPayload = encodeURIComponent(payload);
+                response = await axios_1.default.get(`${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/linkaccount?data=${encodedPayload}`, {
+                    headers: headers,
+                    httpsAgent
+                });
+            }
+            else {
+                response = await axios_1.default.get(`${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/linkaccount?acc=${account}&br=${branch}&accType=${accountType}&mobile=${mobile}`, {
+                    headers: headers,
+                    httpsAgent
+                });
+            }
+            let responseData = response.data;
+            this.logger.log({ responseData: response }, 'Welcome Bank Link Account Successful');
+            if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+                const encryptedResponsePayload = responseData.data;
+                if (!encryptedResponsePayload) {
+                    throw new Error("Encrypted response expected but not found");
+                }
+                let decryptedResponse;
+                try {
+                    decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+                }
+                catch (error) {
+                    this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+                }
+                if (!decryptedResponse) {
+                    decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
+                }
+                return {
+                    success: true,
+                    data: decryptedResponse,
+                };
+            }
+            else {
+                return {
+                    success: true,
+                    ...responseData,
+                };
+            }
+        }
+        catch (error) {
+            axios_error_helper_1.AxiosErrorHelper.handleAxiosError(error);
+        }
+    }
+    async validateOtp(validateOtp) {
+        const { token, account, branch, accountType, otp } = validateOtp;
+        if (!token) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.UNAUTHORIZED,
+                code: 401020402,
+                message: 'Bank token should not be empty.',
+                data: { validateOtp }
+            }, common_1.HttpStatus.UNAUTHORIZED);
+        }
+        if (!account) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020404,
+                message: 'Bank account number should not be empty.',
+                data: { validateOtp }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!accountType) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020406,
+                message: 'Bank account type should not be empty.',
+                data: { validateOtp }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!otp) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020408,
+                message: 'Mobile Number should not be empty.',
+                data: { validateOtp }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        this.logger.log("Welcome Bank Validate OTP");
+        const isoTimestamp = new Date().toISOString();
+        const timeInSeconds = Math.floor(Date.parse(isoTimestamp) / 1000);
+        const totp = this.generateTOTP(timeInSeconds);
+        const totpPrevious = this.generateTOTP(timeInSeconds - 30);
+        this.logger.log(`TOTP GENERATED FOR WELCOME BANK VALIDATE OTP: ${totp}, For Time stamp: ${isoTimestamp}`);
+        this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
+        try {
+            const headers = {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                'X-SERVER-TIMESTAMP': `${isoTimestamp}`
+            };
+            let payload;
+            payload = {
+                "acc": account,
+                "br": branch,
+                "accType": accountType,
+                "otp": otp
+            };
+            if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+                payload = { data: this.encryptPayloadWithOTP(payload, totp) };
+            }
+            const httpsAgent = new https.Agent({
+                rejectUnauthorized: false,
+            });
+            const response = await axios_1.default.post(`${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/validateotp`, payload, {
+                headers: headers,
+                httpsAgent
+            });
+            let responseData = response.data;
+            this.logger.log({ responseData: response }, 'Welcome Bank Validate OTP Successful');
+            if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+                const encryptedResponsePayload = responseData.data;
+                if (!encryptedResponsePayload) {
+                    throw new Error("Encrypted response expected but not found");
+                }
+                let decryptedResponse;
+                try {
+                    decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+                }
+                catch (error) {
+                    this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+                }
+                if (!decryptedResponse) {
+                    decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
+                }
+                return {
+                    success: true,
+                    data: decryptedResponse,
+                };
+            }
+            else {
+                return {
+                    success: true,
+                    ...responseData,
+                };
+            }
+        }
+        catch (error) {
+            axios_error_helper_1.AxiosErrorHelper.handleAxiosError(error);
+        }
+    }
+    async processBalanceTransaction(fetchBalanceDto) {
+        const { token, permissionKey, account, branch, accountType } = fetchBalanceDto;
+        if (!token) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.UNAUTHORIZED,
+                code: 401020502,
+                message: 'Bank token should not be empty.',
+                data: { fetchBalanceDto }
+            }, common_1.HttpStatus.UNAUTHORIZED);
+        }
+        if (!permissionKey) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.UNAUTHORIZED,
+                code: 403020504,
+                message: 'Bank permission key should not be empty.',
+                data: { fetchBalanceDto }
+            }, common_1.HttpStatus.UNAUTHORIZED);
+        }
+        if (!account) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020506,
+                message: 'Bank account number should not be empty.',
+                data: { fetchBalanceDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!accountType) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020508,
+                message: 'Bank account type should not be empty.',
+                data: { fetchBalanceDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        this.logger.log("Welcome Bank Balance Inquiry");
+        const isoTimestamp = new Date().toISOString();
+        const timeInSeconds = Math.floor(Date.parse(isoTimestamp) / 1000);
+        const totp = this.generateTOTP(timeInSeconds);
+        const totpPrevious = this.generateTOTP(timeInSeconds - 30);
+        this.logger.log(`TOTP GENERATED FOR WELCOME BANK BALANCE INQUIRY: ${totp}, For Time stamp: ${isoTimestamp}`);
+        this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
+        try {
+            const headers = {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                'X-SERVER-TIMESTAMP': `${new Date().toISOString()}`
+            };
+            let payload;
+            payload = {
+                "acc": account,
+                "br": branch,
+                "accType": accountType,
+                "permissionKey": permissionKey,
+            };
+            if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+                payload = { data: this.encryptPayloadWithOTP(payload, totp) };
+            }
+            const httpsAgent = new https.Agent({
+                rejectUnauthorized: false,
+            });
+            const response = await axios_1.default.post(`${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/balanceinquiry`, payload, {
+                headers: headers,
+                httpsAgent
+            });
+            let responseData = response.data;
+            this.logger.log({ responseData: response }, 'Welcome Bank Balance Inquiry Successful');
+            if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+                const encryptedResponsePayload = responseData.data;
+                if (!encryptedResponsePayload) {
+                    throw new Error("Encrypted response expected but not found");
+                }
+                let decryptedResponse;
+                try {
+                    decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+                }
+                catch (error) {
+                    this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+                }
+                if (!decryptedResponse) {
+                    decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
+                }
+                return {
+                    success: true,
+                    data: decryptedResponse,
+                };
+            }
+            else {
+                return {
+                    success: true,
+                    ...responseData,
+                };
+            }
+        }
+        catch (error) {
+            axios_error_helper_1.AxiosErrorHelper.handleAxiosError(error);
+        }
+    }
+    async accountCashIn(accountTransferDto) {
+        const { token, permissionKey, sourceAccount, sourceBranch, sourceAccountType, destinationAccount, destinationBranch, destinationAccountType, amount } = accountTransferDto;
+        if (!token) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.UNAUTHORIZED,
+                code: 401020602,
+                message: 'Bank token should not be empty.',
+                data: { accountTransferDto }
+            }, common_1.HttpStatus.UNAUTHORIZED);
+        }
+        if (!permissionKey) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.FORBIDDEN,
+                code: 403020604,
+                message: 'Bank permission key should not be empty.',
+                data: { accountTransferDto }
+            }, common_1.HttpStatus.FORBIDDEN);
+        }
+        if (!sourceAccount) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020606,
+                message: 'Bank source account number should not be empty.',
+                data: { accountTransferDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!sourceAccountType) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020608,
+                message: 'Bank source account type should not be empty.',
+                data: { accountTransferDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!destinationAccount) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020610,
+                message: 'Bank destination account number should not be empty.',
+                data: { accountTransferDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!destinationAccountType) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020612,
+                message: 'Bank destination account type should not be empty.',
+                data: { accountTransferDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!amount) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020613,
+                message: 'Amount should not be empty.',
+                data: { accountTransferDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        this.logger.log("Welcome Bank cash in");
+        const isoTimestamp = new Date().toISOString();
+        const timeInSeconds = Math.floor(Date.parse(isoTimestamp) / 1000);
+        const totp = this.generateTOTP(timeInSeconds);
+        const totpPrevious = this.generateTOTP(timeInSeconds - 30);
+        this.logger.log(`TOTP GENERATED FOR WELCOME BANK CASH IN: ${totp}, For Time stamp: ${isoTimestamp}`);
+        this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
+        try {
+            const headers = {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                'X-SERVER-TIMESTAMP': `${new Date().toISOString()}`
+            };
+            let payload;
+            payload = {
+                "permissionKey": permissionKey,
+                "sourceAcc": sourceAccount,
+                "sourceBr": sourceBranch,
+                "sourceAccType": sourceAccountType,
+                "destAcc": destinationAccount,
+                "destBr": destinationBranch,
+                "destAccType": destinationAccountType,
+                "trnAmt": amount
+            };
+            if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+                payload = { data: this.encryptPayloadWithOTP(payload, totp) };
+            }
+            const httpsAgent = new https.Agent({
+                rejectUnauthorized: false,
+            });
+            const response = await axios_1.default.post(`${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/cashin`, payload, {
+                headers: headers,
+                httpsAgent
+            });
+            let responseData = response.data;
+            this.logger.log({ responseData: response }, 'Welcome Bank Cash In Successful');
+            if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+                const encryptedResponsePayload = responseData.data;
+                if (!encryptedResponsePayload) {
+                    throw new Error("Encrypted response expected but not found");
+                }
+                let decryptedResponse;
+                try {
+                    decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+                }
+                catch (error) {
+                    this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+                }
+                if (!decryptedResponse) {
+                    decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
+                }
+                return {
+                    success: true,
+                    data: decryptedResponse,
+                };
+            }
+            else {
+                return {
+                    success: true,
+                    ...responseData,
+                };
+            }
+        }
+        catch (error) {
+            axios_error_helper_1.AxiosErrorHelper.handleAxiosError(error);
+        }
+    }
+    async accountDeposit(accountTransferDto) {
+        const { token, permissionKey, sourceAccount, sourceBranch, sourceAccountType, destinationAccount, destinationBranch, destinationAccountType, amount } = accountTransferDto;
+        if (!token) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.UNAUTHORIZED,
+                code: 401020702,
+                message: 'Bank token should not be empty.',
+                data: { accountTransferDto }
+            }, common_1.HttpStatus.UNAUTHORIZED);
+        }
+        if (!permissionKey) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.FORBIDDEN,
+                code: 403020704,
+                message: 'Bank permission key should not be empty.',
+                data: { accountTransferDto }
+            }, common_1.HttpStatus.FORBIDDEN);
+        }
+        if (!sourceAccount) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020706,
+                message: 'Bank source account number should not be empty.',
+                data: { accountTransferDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!sourceAccountType) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020708,
+                message: 'Bank source account type should not be empty.',
+                data: { accountTransferDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!destinationAccount) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020710,
+                message: 'Bank destination account number should not be empty.',
+                data: { accountTransferDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!destinationAccountType) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020712,
+                message: 'Bank destination account type should not be empty.',
+                data: { accountTransferDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!amount) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020713,
+                message: 'Amount should not be empty.',
+                data: { accountTransferDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        this.logger.log("Welcome Bank deposit");
+        const isoTimestamp = new Date().toISOString();
+        const timeInSeconds = Math.floor(Date.parse(isoTimestamp) / 1000);
+        const totp = this.generateTOTP(timeInSeconds);
+        const totpPrevious = this.generateTOTP(timeInSeconds - 30);
+        this.logger.log(`TOTP GENERATED FOR WELCOME BANK DEPOSIT: ${totp}, For Time stamp: ${isoTimestamp}`);
+        this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
+        try {
+            const headers = {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                'X-SERVER-TIMESTAMP': `${new Date().toISOString()}`
+            };
+            let payload;
+            payload = {
+                "permissionKey": permissionKey,
+                "sourceAcc": sourceAccount,
+                "sourceBr": sourceBranch,
+                "sourceAccType": sourceAccountType,
+                "destAcc": destinationAccount,
+                "destBr": destinationBranch,
+                "destAccType": destinationAccountType,
+                "trnAmt": amount
+            };
+            if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+                payload = { data: this.encryptPayloadWithOTP(payload, totp) };
+            }
+            const httpsAgent = new https.Agent({
+                rejectUnauthorized: false,
+            });
+            const response = await axios_1.default.post(`${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/customerdeposit`, payload, {
+                headers: headers,
+                httpsAgent
+            });
+            let responseData = response.data;
+            this.logger.log({ responseData: response.data }, 'Welcom Bank Deposit Successful');
+            if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+                const encryptedResponsePayload = responseData.data;
+                if (!encryptedResponsePayload) {
+                    throw new Error("Encrypted response expected but not found");
+                }
+                let decryptedResponse;
+                try {
+                    decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+                }
+                catch (error) {
+                    this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+                }
+                if (!decryptedResponse) {
+                    decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
+                }
+                return {
+                    success: true,
+                    data: decryptedResponse,
+                };
+            }
+            else {
+                return {
+                    success: true,
+                    ...responseData,
+                };
+            }
+        }
+        catch (error) {
+            axios_error_helper_1.AxiosErrorHelper.handleAxiosError(error);
+        }
+    }
+    async getTransactionHistory(transactionHistoryDto) {
+        const { token, permissionKey, account, branch, accountType, dateFrom, dateTo, page } = transactionHistoryDto;
+        if (!token) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.UNAUTHORIZED,
+                code: 401020802,
+                message: 'Bank token should not be empty.',
+                data: { transactionHistoryDto }
+            }, common_1.HttpStatus.UNAUTHORIZED);
+        }
+        if (!permissionKey) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.FORBIDDEN,
+                code: 403020804,
+                message: 'Bank permission key should not be empty.',
+                data: { transactionHistoryDto }
+            }, common_1.HttpStatus.FORBIDDEN);
+        }
+        if (!account) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020806,
+                message: 'Bank account number should not be empty.',
+                data: { transactionHistoryDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!accountType) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020808,
+                message: 'Bank account type should not be empty.',
+                data: { transactionHistoryDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!dateFrom) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020810,
+                message: 'Date From should not be empty.',
+                data: { transactionHistoryDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (!dateTo) {
+            throw new common_1.HttpException({
+                statusCode: common_1.HttpStatus.BAD_REQUEST,
+                code: 400020812,
+                message: 'Date From should not be empty.',
+                data: { transactionHistoryDto }
+            }, common_1.HttpStatus.BAD_REQUEST);
+        }
+        this.logger.log("Welcome Bank transaction history");
+        const isoTimestamp = new Date().toISOString();
+        const timeInSeconds = Math.floor(Date.parse(isoTimestamp) / 1000);
+        const totp = this.generateTOTP(timeInSeconds);
+        const totpPrevious = this.generateTOTP(timeInSeconds - 30);
+        this.logger.log(`TOTP GENERATED FOR WELCOME BANK VALIDATE OTP: ${totp}, For Time stamp: ${isoTimestamp}`);
+        this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
+        try {
+            const headers = {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                'X-SERVER-TIMESTAMP': `${new Date().toISOString()}`
+            };
+            let payload;
+            payload = {
+                "acc": account,
+                "br": branch,
+                "accType": accountType,
+                "permissionKey": permissionKey,
+                "dateFrom": dateFrom,
+                "dateTo": dateTo,
+                "pageNo": page
+            };
+            if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+                payload = { data: this.encryptPayloadWithOTP(payload, totp) };
+            }
+            const httpsAgent = new https.Agent({
+                rejectUnauthorized: false,
+            });
+            const response = await axios_1.default.post(`${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/transhistory`, payload, {
+                headers: headers,
+                httpsAgent
+            });
+            let responseData = response.data;
+            this.logger.log({ responseData: response.data }, 'Welcome Bank Transaction History Successful');
+            if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+                const encryptedResponsePayload = responseData.data;
+                if (!encryptedResponsePayload) {
+                    throw new Error("Encrypted response expected but not found");
+                }
+                let decryptedResponse;
+                try {
+                    decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+                }
+                catch (error) {
+                    this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+                }
+                if (!decryptedResponse) {
+                    decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
+                }
+                return {
+                    success: true,
+                    data: decryptedResponse,
+                };
+            }
+            else {
+                return {
+                    success: true,
+                    ...responseData,
+                };
+            }
+        }
+        catch (error) {
+            axios_error_helper_1.AxiosErrorHelper.handleAxiosError(error);
+        }
+    }
+    async findAccountDetailsRaw(token, userid) {
+        return "Sorry Service Currently Unavaible";
+    }
+    async accountTransfer(token, useridFrom, useridTo, amount) {
+        return "Sorry Service Currently Unavaible";
+    }
+    generateOtp(mobile, acc, bankid) {
+        return "Sorry Service Currently Unavaible";
+    }
+    generateRandomOtp(length) {
+        return "Sorry Service Currently Unavaible";
+    }
+};
+exports.WelcomeBankService = WelcomeBankService;
+exports.WelcomeBankService = WelcomeBankService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(bank_service_tokens_1.BANKING_CONFIG)),
+    __metadata("design:paramtypes", [Object, nestjs_pino_1.Logger])
+], WelcomeBankService);
+//# sourceMappingURL=WelcomeBank.service.js.map