@traxionpay/cbsmiddleware 0.0.1

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

@@ -0,0 +1,574 @@
+import { Inject, Injectable, HttpStatus, HttpException } from '@nestjs/common';
+import { BankService } from '../interfaces/bank-service.interface';
+import axios from 'axios';
+import { AxiosErrorHelper } from '../../helpers/axios-error.helper';
+import { BankingConfig } from '../interfaces/bank-config.interface';
+import { BANKING_CONFIG } from '../tokens/bank-service.tokens';
+import * as https from 'https';
+import { Logger } from 'nestjs-pino';
+import { AccountDto, ValidateOtp } from '../dto/account.dto';
+import { TransactionHistoryDto } from '../dto/transaction-history.dto'
+import { AccountTransferDto } from '../dto/account-transfer.dto'
+import { FetchBankBalanceDto } from '../dto/fetch-bank-balance.dto';
+@Injectable()
+export class ASPACService implements BankService {
+
+  constructor(
+    @Inject(BANKING_CONFIG)
+    private readonly config: BankingConfig,
+    private readonly logger: Logger
+  ) {
+  }
+
+  async generateToken(): Promise<any> {
+
+    this.logger.log("Generating WelcomeBank Token");
+
+    try {
+      const headers = {
+        'Content-Type': 'application/json',
+        'X-API-KEY': `${this.config.ASPAC_API_KEY}`,
+        'X-API-VERSION': `${this.config.ASPAC_VERSION_KEY}`
+      };
+
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.get(
+        `${this.config.ASPAC_URL}/api/v1/token/generate`,
+        {
+          headers: headers,
+          httpsAgent,
+        }
+      );
+
+      this.logger.log({ responseData: response }, 'Welcome Bank Token generated successfully');
+
+      return {
+        success: true,
+        ...response.data,
+      };
+
+    } catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+  async refreshToken(refreshToken: string): Promise<any> {
+
+    if (!refreshToken) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'Bank token should not be empty.',
+        data: { refreshToken }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    this.logger.log("Welcome Bank refresh token");
+
+    try {
+      const headers = {
+        'Content-Type': 'application/json',
+        'X-API-KEY': `${this.config.ASPAC_API_KEY}`,
+        'X-API-VERSION': `${this.config.ASPAC_VERSION_KEY}`
+      };
+
+      const payload = {
+        "refreshtoken": refreshToken
+      }
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.post(
+        `${this.config.ASPAC_URL}/api/v1/token/refresh`,
+        payload,
+        {
+          headers: headers,
+          httpsAgent,
+        }
+      );
+
+      this.logger.log({ responseData: response }, 'Welcome Bank Refresh Token Successful');
+
+      return {
+        success: true,
+        ...response.data,
+      };
+
+    } catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+  async linkAccount(accountDto: AccountDto) {
+
+    const { token, account, accountType, mobile } = accountDto;
+
+    if (!token) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        code: 4000, //TBD
+        message: 'Bank token should not be empty.',
+        data: { accountDto }
+      }, HttpStatus.UNAUTHORIZED);
+    }
+
+    if (!account) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'Bank account number should not be empty.',
+        data: { accountDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!accountType) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'Bank account type should not be empty.',
+        data: { accountDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!mobile) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'Mobile Number should not be empty.',
+        data: { accountDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    this.logger.log("Welcome Bank Link Account");
+
+    try {
+      const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'X-API-KEY': `${this.config.ASPAC_API_KEY}`,
+        'X-API-VERSION': `${this.config.ASPAC_VERSION_KEY}`
+      };
+
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.get(
+        `${this.config.ASPAC_URL}/api/v1/linkaccount?acc=${account}&accType=${accountType}&mobile=${mobile}`,
+        {
+          headers: headers,
+          httpsAgent
+        }
+      );
+
+      this.logger.log({ responseData: response }, 'Welcome Bank Link Account Successful');
+
+      return {
+        success: true,
+        ...response.data,
+      }
+    }
+    catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+  async validateOtp(validateOtp: ValidateOtp): Promise<any> {
+
+    const { token, account, otp } = validateOtp;
+
+    if (!token) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        code: 4000, //TBD
+        message: 'Bank token should not be empty.',
+        data: { validateOtp }
+      }, HttpStatus.UNAUTHORIZED);
+    }
+
+    if (!account) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'Bank account number should not be empty.',
+        data: { validateOtp }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!otp) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'Bank account number should not be empty.',
+        data: { validateOtp }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+
+    this.logger.log("Welcome Bank Validate OTP");
+
+    try {
+      const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'X-API-KEY': `${this.config.ASPAC_API_KEY}`,
+        'X-API-VERSION': `${this.config.ASPAC_VERSION_KEY}`
+      };
+
+      const payload = {
+        "acc": account,
+        "otp": otp
+      }
+
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.post(
+        `${this.config.ASPAC_URL}/api/v1/validateotp`,
+        payload,
+        {
+          headers: headers,
+          httpsAgent
+        }
+      );
+
+      this.logger.log({ responseData: response }, 'Welcome Bank Validate OTP Successful');
+
+      return {
+        success: true,
+        ...response.data,
+      }
+
+    }
+    catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+  async processBalanceTransaction(fetchBalanceDto: FetchBankBalanceDto): Promise<any> {
+
+    const { token, account } = fetchBalanceDto;
+
+    if (!token) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        code: 4000, //TBD
+        message: 'Bank token should not be empty.',
+        data: { fetchBalanceDto }
+      }, HttpStatus.UNAUTHORIZED);
+    }
+
+    if (!account) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'Bank account number should not be empty.',
+        data: { fetchBalanceDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    this.logger.log("Welcome Bank Balance Inquiry");
+
+    try {
+      const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'X-API-KEY': `${this.config.ASPAC_API_KEY}`,
+        'X-API-VERSION': `${this.config.ASPAC_VERSION_KEY}`
+      };
+
+      const payload = {
+        "acc": account,
+      }
+
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.post(
+        `${this.config.ASPAC_URL}/api/v1/balanceinquiry`,
+        payload,
+        {
+          headers: headers,
+          httpsAgent
+        }
+      );
+
+      this.logger.log({ responseData: response }, 'Welcome Bank Balance Inquiry Successful');
+
+      return {
+        success: true,
+        ...response.data,
+      }
+    }
+    catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+  async accountCashIn(accountTransferDto: AccountTransferDto): Promise<any> {
+
+    const { token, sourceAccount, amount, particulars } = accountTransferDto;
+
+    if (!token) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        code: 4000, //TBD
+        message: 'Bank token should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.UNAUTHORIZED);
+    }
+
+    if (!sourceAccount) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'Bank source account number should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!amount) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'Amount should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!particulars) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'Particulars should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    this.logger.log("Welcome Bank cash in");
+
+    try {
+      const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'X-API-KEY': `${this.config.ASPAC_API_KEY}`,
+        'X-API-VERSION': `${this.config.ASPAC_VERSION_KEY}`
+      };
+
+      const payload = {
+        "acc": sourceAccount,
+        "amount": String(amount),
+        "particulars": particulars
+      }
+
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.post(
+        `${this.config.ASPAC_URL}/api/v1/cashin`,
+        payload,
+        {
+          headers: headers,
+          httpsAgent
+        }
+      );
+
+      this.logger.log({ responseData: response }, 'Welcome Bank Cash In Successful');
+
+      return {
+        success: true,
+        ...response.data,
+      }
+    }
+    catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+  async accountDeposit(accountTransferDto: AccountTransferDto): Promise<any> {
+
+    const { token, destinationAccount, amount, particulars } = accountTransferDto;
+
+    if (!token) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        code: 4000, //TBD
+        message: 'Bank token should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.UNAUTHORIZED);
+    }
+
+    if (!destinationAccount) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'Bank destination account number should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!amount) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'amount should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!particulars) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'Particulars should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    this.logger.log("Welcome Bank deposit");
+
+    try {
+      const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'X-API-KEY': `${this.config.ASPAC_API_KEY}`,
+        'X-API-VERSION': `${this.config.ASPAC_VERSION_KEY}`
+      };
+
+      const payload = {
+        "acc": destinationAccount,
+        "amount": String(amount),
+        "particulars": particulars
+      }
+
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.post(
+        `${this.config.ASPAC_URL}/api/v1/customerdeposit`,
+        payload,
+        {
+          headers: headers,
+          httpsAgent
+        }
+      );
+
+      this.logger.log({ responseData: response.data }, 'Welcom Bank Deposit Successful');
+
+      return {
+        success: true,
+        ...response.data,
+      }
+    }
+    catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+  async getTransactionHistory(transactionHistoryDto: TransactionHistoryDto) {
+
+    const { token, account, dateFrom, dateTo, page } = transactionHistoryDto;
+
+    if (!token) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        code: 4000, //TBD
+        message: 'Bank token should not be empty.',
+        data: { transactionHistoryDto }
+      }, HttpStatus.UNAUTHORIZED);
+    }
+
+    if (!account) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'Bank account number should not be empty.',
+        data: { transactionHistoryDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!dateFrom) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'Date From should not be empty.',
+        data: { transactionHistoryDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!dateTo) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000, //TBD
+        message: 'Date From should not be empty.',
+        data: { transactionHistoryDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+
+    this.logger.log("Welcome Bank transaction history");
+
+    try {
+      const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'X-API-KEY': `${this.config.ASPAC_API_KEY}`,
+        'X-API-VERSION': `${this.config.ASPAC_VERSION_KEY}`
+      };
+
+      const payload = {
+        "acc": account,
+        "dateFrom": dateFrom,
+        "dateTo": dateTo,
+        "pageNo": page
+      }
+
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.post(
+        `${this.config.ASPAC_URL}/api/v1/transhistory`,
+        payload,
+        {
+          headers: headers,
+          httpsAgent
+        }
+      );
+
+      this.logger.log({ responseData: response.data }, 'Welcome Bank Transaction History Successful');
+
+      return {
+        success: true,
+        ...response.data,
+      }
+    }
+    catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+  async findAccountDetailsRaw(token: string, userid: number) {
+    return "Sorry Service Currently Unavaible";
+  }
+
+  async accountTransfer(token: string, useridFrom: string, useridTo: string, amount: number) {
+    return "Sorry Service Currently Unavaible";
+  }
+
+  generateOtp(mobile: string, acc: string, bankid: string): string {
+    return "Sorry Service Currently Unavaible";
+  }
+
+  generateRandomOtp(length: number): string {
+    return "Sorry Service Currently Unavaible";
+  }
+}

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

@@ -0,0 +1,64 @@
+import { Injectable } from '@nestjs/common';
+import { BankStrategyFactory } from '../factory/bank-strategy.factory';
+import { FetchBankBalanceDto } from '../dto/fetch-bank-balance.dto';
+import { AccountDto, ValidateOtp } from '../dto/account.dto';
+import { TransactionHistoryDto } from '../dto/transaction-history.dto';
+import { AccountTransferDto } from '../dto/account-transfer.dto';
+
+@Injectable()
+export class BankingGatewayService {
+  constructor(private readonly factory: BankStrategyFactory) {}
+
+  async getAccessToken(bankId: string): Promise<any> {
+    const service = this.factory.getBankService(bankId);
+    const token = await service.generateToken();
+    return token;
+  }
+
+  async getRefreshToken(bankId: string, refreshToken: string): Promise<any> {
+    const service = this.factory.getBankService(bankId);
+    return await service.refreshToken(refreshToken);
+  }
+
+  async linkAccount(accountDto: AccountDto): Promise<any> {
+    const { bankId } = accountDto;
+    const service = this.factory.getBankService(bankId);
+    const response = await service.linkAccount(accountDto);
+    return response;
+  }
+
+  async validateOtp(validateOtp: ValidateOtp): Promise<any> {
+    const { bankId } = validateOtp;
+    const service = this.factory.getBankService(bankId);
+    const response = service.validateOtp(validateOtp);
+    return response;
+  }
+
+  async fetchBankBalance(fetchBankBalanceDto: FetchBankBalanceDto): Promise<any> {
+    const { bankId } = fetchBankBalanceDto;
+    const service = this.factory.getBankService(bankId);
+    const balance = await service.processBalanceTransaction(fetchBankBalanceDto);
+    return balance;
+  }
+
+  async accountCashIn(accountTransferDto: AccountTransferDto): Promise<any> {
+    const { bankId } = accountTransferDto;
+    const service = this.factory.getBankService(bankId);
+    const response = await service.accountCashIn(accountTransferDto);
+    return response;
+  }
+
+  async accountDeposit(accountTransferDto: AccountTransferDto): Promise<any> {
+    const { bankId } = accountTransferDto;
+    const service = this.factory.getBankService(bankId);
+    const response = await service.accountDeposit(accountTransferDto);
+    return response;
+  }
+
+  async getTransactionHistory(transactionHistoryDto: TransactionHistoryDto): Promise<any> {
+    const { bankId } = transactionHistoryDto;
+    const service = this.factory.getBankService(bankId);
+    const response = await service.getTransactionHistory(transactionHistoryDto);
+    return response;
+  }
+}