@traxionpay/cbsmiddleware 0.0.1 → 0.0.3

package/src/banking/services/WelcomeBank.service.ts

@@ -100,8 +100,8 @@ export class WelcomeBankService implements BankService {
     if (!refreshToken) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 400020206,
-        message: 'Bank token should not be empty.',
+        code: 400020205,
+        message: 'Refresh token is required.',
         data: { refreshToken }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -132,6 +132,15 @@ export class WelcomeBankService implements BankService {
 
       this.logger.log({ responseData: response }, 'Welcome Bank Refresh Token Successful');
 
+      if (response.data.message === "Unable to Process this request. Please check your payload.") {
+        throw new HttpException({
+          statusCode: HttpStatus.BAD_REQUEST,
+          code: 400020206,
+          message: 'Invalid refresh token.',
+          data: { refreshToken }
+        }, HttpStatus.BAD_REQUEST);
+      }
+
       return {
         success: true,
         ...response.data,
@@ -159,7 +168,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020304,
-        message: 'Bank account number should not be empty.',
+        message: 'Account number is required.',
         data: { accountDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -167,8 +176,8 @@ export class WelcomeBankService implements BankService {
     if (!accountType) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4400020306,
-        message: 'Bank account type should not be empty.',
+        code: 400020306,
+        message: 'Account type is required.',
         data: { accountDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -177,7 +186,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 4000203009,
-        message: 'Mobile Number should not be empty.',
+        message: 'Mobile number is required.',
         data: { accountDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -192,6 +201,8 @@ export class WelcomeBankService implements BankService {
     this.logger.log(`TOTP GENERATED FOR WELCOMEBANK LINK ACCOUNT: ${totp}, For Time stamp: ${isoTimestamp}`);
     this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
 
+    let responseData;
+
     try {
       const headers = {
         'Authorization': `Bearer ${token}`,
@@ -205,13 +216,18 @@ export class WelcomeBankService implements BankService {
 
       let response;
 
+      let formattedMobile = mobile;
+      if (mobile.startsWith("63") && mobile.length > 2) {
+        formattedMobile = "0" + mobile.slice(2);
+      }
+
       if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
         let payload;
         payload = {
           "acc": account,
           "br": branch,
           "accType": accountType,
-          "mobile": mobile
+          "mobile": formattedMobile
         }
         payload = this.encryptPayloadWithOTP(payload, totp);
         const encodedPayload = encodeURIComponent(payload);
@@ -227,52 +243,80 @@ export class WelcomeBankService implements BankService {
 
       else {
         response = await axios.get(
-          `${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/linkaccount?acc=${account}&br=${branch}&accType=${accountType}&mobile=${mobile}`,
+          `${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/linkaccount?acc=${account}&br=${branch}&accType=${accountType}&mobile=${formattedMobile}`,
           {
             headers: headers,
             httpsAgent
           }
         );
       }
-      let responseData = response.data;
 
-      this.logger.log({ responseData: response }, 'Welcome Bank Link Account Successful');
+      this.logger.log({ responseData: response.data }, 'Welcome Bank Link Account Successful');
 
       if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
 
-        const encryptedResponsePayload = responseData.data;
+        const encryptedResponsePayload = response.data.data;
 
         if (!encryptedResponsePayload) {
           throw new Error("Encrypted response expected but not found");
         }
 
-        let decryptedResponse;
         try {
-          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+          responseData = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
         } catch (error) {
           this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+          responseData = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
         }
+      }
+      else {
+        responseData = response.data;
+      }
+    }
+    catch (error) {
 
-        if (!decryptedResponse) {
-          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
-        }
+      if (error.response.data.message === "Mobile number is not registered in the account.") {
+        throw new HttpException({
+          statusCode: HttpStatus.BAD_REQUEST,
+          code: 400020307,
+          message: 'Mobile number is not registered in the account.',
+          data: { accountDto }
+        }, HttpStatus.BAD_REQUEST);
+      }
 
-        return {
-          success: true,
-          data: decryptedResponse,
-        };
+      AxiosErrorHelper.handleAxiosError(error);
+    }
 
-      } else {
+    if (responseData.data.status === "99997") {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020303,
+        message: 'Account not found',
+        data: { ...accountDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
 
-        return {
-          success: true,
-          ...responseData,
-        };
-      }
+    if (responseData.data.status === "00001") {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020305,
+        message: 'Account type is not supported.',
+        data: { ...accountDto }
+      }, HttpStatus.BAD_REQUEST);
     }
-    catch (error) {
-      AxiosErrorHelper.handleAxiosError(error);
+
+    if (responseData.data.status === "00007") {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020307,
+        message: 'Mobile number is not registered in the account.',
+        data: { ...accountDto }
+      }, HttpStatus.BAD_REQUEST);
     }
+
+    return {
+      success: true,
+      ...responseData,
+    };
   }
 
 
@@ -293,7 +337,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020404,
-        message: 'Bank account number should not be empty.',
+        message: 'Account number is required.',
         data: { validateOtp }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -302,7 +346,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020406,
-        message: 'Bank account type should not be empty.',
+        message: 'Account type is required.',
         data: { validateOtp }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -311,7 +355,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020408,
-        message: 'Mobile Number should not be empty.',
+        message: 'OTP is required.',
         data: { validateOtp }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -326,6 +370,8 @@ export class WelcomeBankService implements BankService {
     this.logger.log(`TOTP GENERATED FOR WELCOME BANK VALIDATE OTP: ${totp}, For Time stamp: ${isoTimestamp}`);
     this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
 
+    let responseData;
+
     try {
       const headers = {
         'Authorization': `Bearer ${token}`,
@@ -343,7 +389,7 @@ export class WelcomeBankService implements BankService {
       }
 
       if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
-        payload = {data: this.encryptPayloadWithOTP(payload, totp)};
+        payload = { data: this.encryptPayloadWithOTP(payload, totp) };
       }
 
       const httpsAgent = new https.Agent({
@@ -359,44 +405,61 @@ export class WelcomeBankService implements BankService {
         }
       );
 
-      let responseData = response.data;
-      this.logger.log({ responseData: response }, 'Welcome Bank Validate OTP Successful');
+      this.logger.log({ responseData: response.data }, 'Welcome Bank Validate OTP Successful');
 
       if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
 
-        const encryptedResponsePayload = responseData.data;
+        const encryptedResponsePayload = response.data.data;
 
         if (!encryptedResponsePayload) {
           throw new Error("Encrypted response expected but not found");
         }
 
-        let decryptedResponse;
         try {
-          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+          responseData = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
         } catch (error) {
           this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+          responseData = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
         }
-
-        if (!decryptedResponse) {
-          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
-        }
-
-        return {
-          success: true,
-          data: decryptedResponse,
-        };
-
-      } else {
-
-        return {
-          success: true,
-          ...responseData,
-        };
+      }
+      else {
+        responseData = response.data;
       }
     }
     catch (error) {
       AxiosErrorHelper.handleAxiosError(error);
     }
+    if (responseData.data.status === "99997") {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020403,
+        message: 'Account number is required.',
+        data: { ...validateOtp }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (responseData.data.status === "00001") {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020405,
+        message: 'Account type is not supported.',
+        data: { ...validateOtp }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (responseData.data.status === "00005") {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020407,
+        message: 'Invalid or expired OTP.',
+        data: { ...validateOtp }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    return {
+      success: true,
+      ...responseData,
+    };
   }
 
   async processBalanceTransaction(fetchBalanceDto: FetchBankBalanceDto): Promise<any> {
@@ -414,18 +477,18 @@ export class WelcomeBankService implements BankService {
 
     if (!permissionKey) {
       throw new HttpException({
-        statusCode: HttpStatus.UNAUTHORIZED,
+        statusCode: HttpStatus.FORBIDDEN,
         code: 403020504,
-        message: 'Bank permission key should not be empty.',
+        message: 'Permission key is required.',
         data: { fetchBalanceDto }
-      }, HttpStatus.UNAUTHORIZED);
+      }, HttpStatus.FORBIDDEN);
     }
 
     if (!account) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020506,
-        message: 'Bank account number should not be empty.',
+        message: 'Account number is required.',
         data: { fetchBalanceDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -434,7 +497,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020508,
-        message: 'Bank account type should not be empty.',
+        message: 'Account type is required.',
         data: { fetchBalanceDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -445,9 +508,12 @@ export class WelcomeBankService implements BankService {
     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}`);
 
+    let responseData;
+
     try {
       const headers = {
         'Authorization': `Bearer ${token}`,
@@ -465,7 +531,7 @@ export class WelcomeBankService implements BankService {
       }
 
       if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
-        payload = {data: this.encryptPayloadWithOTP(payload, totp)};
+        payload = { data: this.encryptPayloadWithOTP(payload, totp) };
       }
 
       const httpsAgent = new https.Agent({
@@ -481,44 +547,62 @@ export class WelcomeBankService implements BankService {
         }
       );
 
-      let responseData = response.data;
-
-      this.logger.log({ responseData: response }, 'Welcome Bank Balance Inquiry Successful');
+      this.logger.log({ responseData: response.data }, 'Welcome Bank Balance Inquiry Successful');
 
       if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
 
-        const encryptedResponsePayload = responseData.data;
+        const encryptedResponsePayload = response.data.data;
 
         if (!encryptedResponsePayload) {
           throw new Error("Encrypted response expected but not found");
         }
 
-        let decryptedResponse;
         try {
-          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+          responseData = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
         } catch (error) {
           this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+          responseData = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
         }
-
-        if (!decryptedResponse) {
-          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
-        }
-        return {
-          success: true,
-          data: decryptedResponse,
-        };
-
-      } else {
-
-        return {
-          success: true,
-          ...responseData,
-        };
+      }
+      else {
+        responseData = response.data;
       }
     }
     catch (error) {
       AxiosErrorHelper.handleAxiosError(error);
     }
+    if (responseData.data.status === "99999") {
+      throw new HttpException({
+        statusCode: HttpStatus.FORBIDDEN,
+        code: 403020503,
+        message: 'Invalid permission key.',
+        data: { ...fetchBalanceDto }
+      }, HttpStatus.FORBIDDEN);
+    }
+
+    if (responseData.data.status === "99997") {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020505,
+        message: 'Account not found.',
+        data: { ...fetchBalanceDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (responseData.data.status === "00001") {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020507,
+        message: 'Account type is not supported.',
+        data: { ...fetchBalanceDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    return {
+      success: true,
+      ...responseData,
+    };
+
   }
 
   async accountCashIn(accountTransferDto: AccountTransferDto): Promise<any> {
@@ -538,7 +622,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.FORBIDDEN,
         code: 403020604,
-        message: 'Bank permission key should not be empty.',
+        message: 'Permission key is required.',
         data: { accountTransferDto }
       }, HttpStatus.FORBIDDEN);
     }
@@ -547,7 +631,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020606,
-        message: 'Bank source account number should not be empty.',
+        message: 'Source account number is required.',
         data: { accountTransferDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -556,7 +640,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020608,
-        message: 'Bank source account type should not be empty.',
+        message: 'Source account type is required.',
         data: { accountTransferDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -565,7 +649,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020610,
-        message: 'Bank destination account number should not be empty.',
+        message: 'Destination account number is required.',
         data: { accountTransferDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -574,7 +658,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020612,
-        message: 'Bank destination account type should not be empty.',
+        message: 'Destination account type is required.',
         data: { accountTransferDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -583,7 +667,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020613,
-        message: 'Amount should not be empty.',
+        message: 'Transaction amount is required.',
         data: { accountTransferDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -598,6 +682,8 @@ export class WelcomeBankService implements BankService {
     this.logger.log(`TOTP GENERATED FOR WELCOME BANK CASH IN: ${totp}, For Time stamp: ${isoTimestamp}`);
     this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
 
+    let responseData;
+
     try {
       const headers = {
         'Authorization': `Bearer ${token}`,
@@ -619,7 +705,7 @@ export class WelcomeBankService implements BankService {
       }
 
       if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
-        payload = {data: this.encryptPayloadWithOTP(payload, totp)};
+        payload = { data: this.encryptPayloadWithOTP(payload, totp) };
       }
 
       const httpsAgent = new https.Agent({
@@ -635,44 +721,70 @@ export class WelcomeBankService implements BankService {
         }
       );
 
-      let responseData = response.data;
-      this.logger.log({ responseData: response }, 'Welcome Bank Cash In Successful');
+      this.logger.log({ responseData: response.data }, 'Welcome Bank Cash In Successful');
 
       if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
 
-        const encryptedResponsePayload = responseData.data;
+        const encryptedResponsePayload = response.data.data;
 
         if (!encryptedResponsePayload) {
           throw new Error("Encrypted response expected but not found");
         }
 
-        let decryptedResponse;
         try {
-          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+          responseData = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
         } catch (error) {
           this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+          responseData = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
         }
-
-        if (!decryptedResponse) {
-          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
-        }
-
-        return {
-          success: true,
-          data: decryptedResponse,
-        };
-
-      } else {
-
-        return {
-          success: true,
-          ...responseData,
-        };
+      }
+      else {
+        responseData = response.data;
       }
     }
     catch (error) {
       AxiosErrorHelper.handleAxiosError(error);
     }
+    if (responseData.data.status === "99999") {
+      throw new HttpException({
+        statusCode: HttpStatus.FORBIDDEN,
+        code: 403020603,
+        message: 'Invalid permission key.',
+        data: { ...accountTransferDto }
+      }, HttpStatus.FORBIDDEN);
+    }
+
+    if (responseData.data.status === "99997") {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020605,
+        message: 'Account not found.',
+        data: { ...accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (responseData.data.status === "00001") {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020607,
+        message: 'Account type is not supported.',
+        data: { ...accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (responseData.data.status === "00004") {
+      throw new HttpException({
+        statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+        code: 422020614,
+        message: 'Invalid transaction amount value.',
+        data: { ...accountTransferDto }
+      }, HttpStatus.UNPROCESSABLE_ENTITY);
+    }
+
+    return {
+      success: true,
+      ...responseData,
+    };
   }
 
   async accountDeposit(accountTransferDto: AccountTransferDto): Promise<any> {
@@ -692,7 +804,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.FORBIDDEN,
         code: 403020704,
-        message: 'Bank permission key should not be empty.',
+        message: 'Permission key is required.',
         data: { accountTransferDto }
       }, HttpStatus.FORBIDDEN);
     }
@@ -701,7 +813,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020706,
-        message: 'Bank source account number should not be empty.',
+        message: 'Source account number is required',
         data: { accountTransferDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -710,7 +822,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020708,
-        message: 'Bank source account type should not be empty.',
+        message: 'Source account type is required.',
         data: { accountTransferDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -719,7 +831,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020710,
-        message: 'Bank destination account number should not be empty.',
+        message: 'Destination account number is required',
         data: { accountTransferDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -737,7 +849,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020713,
-        message: 'Amount should not be empty.',
+        message: 'Transaction amount is required.',
         data: { accountTransferDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -752,6 +864,8 @@ export class WelcomeBankService implements BankService {
     this.logger.log(`TOTP GENERATED FOR WELCOME BANK DEPOSIT: ${totp}, For Time stamp: ${isoTimestamp}`);
     this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
 
+    let responseData;
+
     try {
       const headers = {
         'Authorization': `Bearer ${token}`,
@@ -759,8 +873,8 @@ export class WelcomeBankService implements BankService {
         'X-SERVER-TIMESTAMP': `${new Date().toISOString()}`
       };
 
-
       let payload;
+
       payload = {
         "permissionKey": permissionKey,
         "sourceAcc": sourceAccount,
@@ -774,7 +888,7 @@ export class WelcomeBankService implements BankService {
 
 
       if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
-        payload = {data: this.encryptPayloadWithOTP(payload, totp)};
+        payload = { data: this.encryptPayloadWithOTP(payload, totp) };
       }
 
       const httpsAgent = new https.Agent({
@@ -790,49 +904,95 @@ export class WelcomeBankService implements BankService {
         }
       );
 
-      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;
+        const encryptedResponsePayload = response.data.data;
 
         if (!encryptedResponsePayload) {
           throw new Error("Encrypted response expected but not found");
         }
 
-        let decryptedResponse;
         try {
-          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+          responseData = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
         } catch (error) {
           this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+          responseData = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
         }
 
-        if (!decryptedResponse) {
-          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
-        }
-
-        return {
-          success: true,
-          data: decryptedResponse,
-        };
-
-      } else {
-
-        return {
-          success: true,
-          ...responseData,
-        };
+      }
+      else {
+        responseData = response.data;
       }
     }
     catch (error) {
       AxiosErrorHelper.handleAxiosError(error);
     }
+    if (responseData.data.status === "99999") {
+      throw new HttpException({
+        statusCode: HttpStatus.FORBIDDEN,
+        code: 403020703,
+        message: 'Invalid permission key.',
+        data: { ...accountTransferDto }
+      }, HttpStatus.FORBIDDEN);
+    }
+
+    if (responseData.data.status === "99997") {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020709,
+        message: 'Account not found.',
+        data: { ...accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (responseData.data.status === "00001") {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020711,
+        message: 'Account type is not supported.',
+        data: { ...accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (responseData.data.status === "00004") {
+      throw new HttpException({
+        statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+        code: 422020714,
+        message: 'Invalid transaction amount value.',
+        data: { ...accountTransferDto }
+      }, HttpStatus.UNPROCESSABLE_ENTITY);
+    }
+
+    return {
+      success: true,
+      ...responseData,
+    };
+
   }
 
-  async getTransactionHistory(transactionHistoryDto: TransactionHistoryDto) {
+  async getTransactionHistory(transactionHistoryDto: TransactionHistoryDto):
+    Promise<{
+      success: boolean;
+      message: any;
+      timestamp: any;
+      transactions: any;
+    }> {
 
     const { token, permissionKey, account, branch, accountType, dateFrom, dateTo, page } = transactionHistoryDto;
+    const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+
+    interface ReformattedTransaction {
+      dateTime: string;
+      amount: number;
+      type: string;
+      description: string;
+      transactionReference: string;
+    }
+
+    const reformattedTransactions: Record<string, ReformattedTransaction> = {};
+
 
     if (!token) {
       throw new HttpException({
@@ -847,7 +1007,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.FORBIDDEN,
         code: 403020804,
-        message: 'Bank permission key should not be empty.',
+        message: 'Permission key is required.',
         data: { transactionHistoryDto }
       }, HttpStatus.FORBIDDEN);
     }
@@ -856,7 +1016,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020806,
-        message: 'Bank account number should not be empty.',
+        message: 'Account number is required',
         data: { transactionHistoryDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -865,7 +1025,7 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020808,
-        message: 'Bank account type should not be empty.',
+        message: 'Account type is required.',
         data: { transactionHistoryDto }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -874,20 +1034,38 @@ export class WelcomeBankService implements BankService {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020810,
-        message: 'Date From should not be empty.',
+        message: 'Starting date is required.',
         data: { transactionHistoryDto }
       }, HttpStatus.BAD_REQUEST);
     }
 
+    if (!dateRegex.test(dateFrom)) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+        code: 422020809,
+        message: 'Invalid starting date format. Format should be in YYYY-MM-DD.',
+        data: { ...transactionHistoryDto }
+      }, HttpStatus.UNPROCESSABLE_ENTITY);
+    }
+
     if (!dateTo) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
         code: 400020812,
-        message: 'Date From should not be empty.',
+        message: 'Ending date is required.',
         data: { transactionHistoryDto }
       }, HttpStatus.BAD_REQUEST);
     }
 
+    if (!dateRegex.test(dateTo)) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+        code: 422020811,
+        message: 'Invalid starting date format. Format should be in YYYY-MM-DD.',
+        data: { ...transactionHistoryDto }
+      }, HttpStatus.UNPROCESSABLE_ENTITY);
+    }
+
     this.logger.log("Welcome Bank transaction history");
 
     const isoTimestamp = new Date().toISOString();
@@ -895,9 +1073,11 @@ export class WelcomeBankService implements BankService {
     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 WELCOME BANK TRANSACTION HISTORY: ${totp}, For Time stamp: ${isoTimestamp}`);
     this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
 
+    let responseData;
+
     try {
       const headers = {
         'Authorization': `Bearer ${token}`,
@@ -917,7 +1097,7 @@ export class WelcomeBankService implements BankService {
       }
 
       if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
-        payload = {data: this.encryptPayloadWithOTP(payload, totp)};
+        payload = { data: this.encryptPayloadWithOTP(payload, totp) };
       }
 
       const httpsAgent = new https.Agent({
@@ -932,44 +1112,93 @@ export class WelcomeBankService implements BankService {
           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;
+        const encryptedResponsePayload = response.data.data;
 
         if (!encryptedResponsePayload) {
           throw new Error("Encrypted response expected but not found");
         }
 
-        let decryptedResponse;
         try {
-          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+          responseData = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
         } catch (error) {
           this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+          responseData = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
         }
 
-        if (!decryptedResponse) {
-          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
-        }
-
-        return {
-          success: true,
-          data: decryptedResponse,
-        };
-
-      } else {
+        this.logger.log(`Decrypted Response Log: ${JSON.stringify(responseData)}`);
+        this.logger.log(`Decrypted.data.transactions Response Log: ${JSON.stringify(responseData.data.transaction)}`);
+        
+        responseData.data.transaction.forEach((txn, index) => {
+          const key = `${index + 1}`;
+
+          reformattedTransactions[key] = {
+            dateTime: txn.dateTime,
+            amount: txn.amount,
+            type: txn.type,
+            description: txn.description,
+            transactionReference: txn.tranReference
+          };
+        });
 
-        return {
-          success: true,
-          ...responseData,
-        };
       }
+      else {
+        responseData = response.data;
+      }
+
     }
     catch (error) {
       AxiosErrorHelper.handleAxiosError(error);
     }
+
+    if (responseData.data.status === "99999") {
+      throw new HttpException({
+        statusCode: HttpStatus.FORBIDDEN,
+        code: 403020803,
+        message: 'Invalid permission key.',
+        data: { ...transactionHistoryDto }
+      }, HttpStatus.FORBIDDEN);
+    }
+
+    if (responseData.data.status === "99997") {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020805,
+        message: 'Account not found.',
+        data: { ...transactionHistoryDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (responseData.data.status === "00001") {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020807,
+        message: 'Account type is not supported.',
+        data: { ...transactionHistoryDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (responseData.data.status === "XXXXX") {
+      throw new HttpException({
+        statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+        code: 422020813,
+        message: 'Invalid page number format.',
+        data: { ...transactionHistoryDto }
+      }, HttpStatus.UNPROCESSABLE_ENTITY);
+    }
+
+    return {
+      success: true,
+      message: responseData.data.responseMessage,
+      timestamp: responseData.timestamp,
+      transactions: reformattedTransactions,
+    }
+
   }
 
   async findAccountDetailsRaw(token: string, userid: number) {