@tomei/finance 0.3.28 → 0.3.30

package/src/finance-company/finance-company.ts

@@ -1,1081 +1,1156 @@
-import axios from 'axios';
-import * as cuid from 'cuid';
-import {
-  HashTable,
-  LoginUserBase,
-  ObjectBase,
-  RecordNotFoundError,
-} from '@tomei/general';
-import Account from '../account/account';
-import JournalEntry from '../journal-entry/journal-entry';
-import FinanceCustomerBase from '../customer/customer';
-import Document from '../document/document';
-import { IAccountSystem } from '../interfaces';
-import { FinanceCompanyRepository } from './finance-company.repository';
-import { FinanceCustomerRepository } from '../customer/finance-customer.repository';
-import { LedgerTransactionRepository } from '../ledger-transaction/ledger-transaction.repository';
-import { DocType, PaymentStatus, TransactionTypeOptions } from '../enum';
-import PaymentMethodType from '../payment-method-type/payment-method-type';
-import { PaymentRepository } from '../payment/payment.repository';
-import { PaymentItemRepository } from '../payment-item/payment-item.repository';
-import Payment from '../payment/payment';
-import { DocumentRepository } from '../document/document.repository';
-import { DocumentItemRepository } from '../document/document-item.repository';
-import { getConfig } from '../config';
-
-const config = getConfig();
-
-export default class FinanceCompany extends ObjectBase {
-  private _CompanyId = 'New';
-  private _CompSystemCode = '';
-  private _CompSystemRefId = '';
-  private _AccSystemCode = '';
-  private static _htFinanceCompanyIds = new HashTable();
-  private static _htFinanceCompanies = new HashTable();
-  private static _financeCompanyRepository = new FinanceCompanyRepository();
-  private static _PaymentRepository = new PaymentRepository();
-  private static _PaymentItemRepository = new PaymentItemRepository();
-  private static _DocumentRepository = new DocumentRepository();
-  private static _DocumentItemRepository = new DocumentItemRepository();
-  private static _FinanceCustomerRepository = new FinanceCustomerRepository();
-  private static _LedgerTransactionRepository =
-    new LedgerTransactionRepository();
-  private _AccountingSystem: IAccountSystem;
-
-  get CompSystemCode(): string {
-    return this._CompSystemCode;
-  }
-
-  private set CompSystemCode(code: string) {
-    this._CompSystemCode = code;
-  }
-
-  get CompSystemRefId() {
-    return this._CompSystemRefId;
-  }
-
-  set CompSystemRefId(id: string) {
-    this._CompSystemRefId = id;
-  }
-
-  get AccSystemCode() {
-    return this._AccSystemCode;
-  }
-
-  private set AccSystemCode(code: string) {
-    this._AccSystemCode = code;
-  }
-
-  get CompanyId() {
-    return this._CompanyId;
-  }
-
-  get ObjectId() {
-    return this._CompanyId;
-  }
-
-  private set ObjectId(id: string) {
-    this._CompanyId = id;
-  }
-
-  get ObjectName() {
-    return `${this.CompSystemCode}-${this.CompSystemRefId}-${this.AccSystemCode}`;
-  }
-
-  get TableName() {
-    return 'finance_Company';
-  }
-
-  get AccountingSystem(): IAccountSystem {
-    return this._AccountingSystem;
-  }
-
-  set AccountingSystem(system: IAccountSystem) {
-    this._AccountingSystem = system;
-  }
-
-  constructor(
-    compSystemCode: string,
-    compSystemRefId: string,
-    accSystemCode: string,
-  ) {
-    super();
-    this.CompSystemCode = compSystemCode;
-    this.CompSystemRefId = compSystemRefId;
-    this.AccSystemCode = accSystemCode;
-  }
-
-  static async getFinanceCompanyId(
-    compSystemCode: string,
-    compSystemRefId: string,
-    accSystemCode: string,
-  ): Promise<string> {
-    let sCompanyId = '';
-    /*Assemble the hashtable key*/
-    const sKey = `${compSystemCode}-${compSystemRefId}-${accSystemCode}`;
-    /*Check if the FinanceCompany has previously being loaded*/
-    if (!FinanceCompany._htFinanceCompanyIds.get(sKey)) {
-      /*Instantiate a new FinanceCompany*/
-      const financeCompany = new FinanceCompany(
-        compSystemCode,
-        compSystemRefId,
-        accSystemCode,
-      );
-
-      /*Retrieve the finance company from finance_Company table using compSystemCode,
-       * CompSystemRefId and accSystemCode */
-      const company = await FinanceCompany._financeCompanyRepository.findOne({
-        where: {
-          CompSystemCode: compSystemCode,
-          CompSystemRefId: compSystemRefId,
-          AccSystemCode: accSystemCode,
-        },
-      });
-
-      /*Retrieve and store the companyId from the result*/
-      financeCompany.ObjectId = company.CompanyId;
-      sCompanyId = financeCompany.ObjectId;
-
-      /*Add the details into the hashtable*/
-      FinanceCompany._htFinanceCompanyIds.add(sKey, financeCompany.ObjectId);
-      FinanceCompany._htFinanceCompanies.add(sCompanyId, financeCompany);
-    }
-
-    if (typeof FinanceCompany._htFinanceCompanyIds.get(sKey) === 'string') {
-      sCompanyId = FinanceCompany._htFinanceCompanyIds.get(sKey);
-    }
-
-    return sCompanyId;
-  }
-
-  static async getFinanceCompany(companyId: string): Promise<FinanceCompany> {
-    /*Check if the finance company is previously be loaded*/
-    if (!FinanceCompany._htFinanceCompanies.get(companyId)) {
-      /*Retrieve the finance company from finance_Company table using compSystemCode,
-       * CompSystemRefId and accSystemCode */
-      const company = await FinanceCompany._financeCompanyRepository.findOne({
-        where: { CompanyId: companyId },
-      });
-
-      if (!company) {
-        throw Error('No finance company found. Please create first.');
-      }
-
-      /*Using the result returned, instantiate a new FinanceCompany*/
-      const compSystemCode = company.CompSystemCode;
-      const compSystemRefId = company.CompSystemRefId;
-      const accSystemCode = company.AccSystemCode;
-
-      const financeCompany = new FinanceCompany(
-        compSystemCode,
-        compSystemRefId,
-        accSystemCode,
-      );
-
-      /*Retrieve and store the CompanyId from the result*/
-      financeCompany.ObjectId = company.CompanyId;
-      financeCompany._CompanyId = company.CompanyId;
-
-      /*Add the details into the hashtable*/
-      const sKey = `${compSystemCode}-${compSystemRefId}-${accSystemCode}`;
-      FinanceCompany._htFinanceCompanyIds.add(sKey, financeCompany.ObjectId);
-      FinanceCompany._htFinanceCompanies.add(
-        financeCompany.ObjectId,
-        financeCompany,
-      );
-    }
-    // tslint:disable-next-line:no-console
-    console.log('return from hash table');
-    return FinanceCompany._htFinanceCompanies.get(companyId);
-  }
-
-  static async createFinanceCompany(
-    dbTransaction: any,
-    loginUser: LoginUserBase,
-    compSystemCode: string,
-    compSystemRefId: string,
-    accSystemCode: string,
-  ) {
-    /*Instantiate a new FinanceCompany*/
-    const financeCompany = new FinanceCompany(
-      compSystemCode,
-      compSystemRefId,
-      accSystemCode,
-    );
-
-    /*Validating if the finance company already exists in finance_Company*/
-    const company = await FinanceCompany._financeCompanyRepository.findOne({
-      where: {
-        CompSystemCode: compSystemCode,
-        CompSystemRefId: compSystemRefId,
-        AccSystemCode: accSystemCode,
-      },
-    });
-
-    if (company) {
-      throw Error(
-        'There is already another Finance Company with the compSystemCode, CompSystemRefId and accSystemCode specified.',
-      );
-    }
-
-    /*Generating the companyId*/
-    financeCompany.ObjectId = cuid();
-
-    /*Save the FinanceCompany to the finance_Company table*/
-    await FinanceCompany._financeCompanyRepository.create(
-      {
-        CompanyId: financeCompany.CompanyId,
-        CompSystemCode: financeCompany.CompSystemCode,
-        CompSystemRefId: financeCompany.CompSystemRefId,
-        AccSystemCode: financeCompany.AccSystemCode,
-      },
-      {
-        transaction: dbTransaction,
-      },
-    );
-
-    /*Add the details to hashtable*/
-    const sKey = `${compSystemCode}-${compSystemRefId}-${accSystemCode}`;
-    FinanceCompany._htFinanceCompanyIds.add(sKey, financeCompany.ObjectId);
-    FinanceCompany._htFinanceCompanies.add(
-      financeCompany.ObjectId,
-      financeCompany,
-    );
-  }
-
-  async createCustomer(
-    dbTransaction: any,
-    custSystemCode: string,
-    custSystemRefId: string,
-    customer: FinanceCustomerBase,
-  ) {
-    try {
-      if (!customer.CustSystemCode || !customer.CustSystemRefId) {
-        throw new Error(
-          'CustSystemCode and CustomerRefId are required fields.',
-        );
-      }
-
-      const financeCustomerData =
-        await FinanceCompany._FinanceCustomerRepository.findOne({
-          where: {
-            CompanyId: this._CompanyId,
-            CustSystemCode: custSystemCode,
-            CustSystemRefId: custSystemRefId,
-          },
-        });
-
-      if (financeCustomerData) {
-        throw new Error('Customer already created previously.');
-      }
-
-      // Retrieve the type of accounting system, API Key, and API secret based on SysCode from the Config.ts
-      const accSystemRefId = await this.AccountingSystem.createCustomer({
-        customer,
-      });
-
-      const newCustomer = await customer.save(
-        accSystemRefId,
-        custSystemCode,
-        custSystemRefId,
-        dbTransaction,
-      );
-
-      const payload = {
-        Action: 'Create',
-        Activity: 'Finance Customer Created',
-        Description: `Customer (ID: ${newCustomer.CustomerId}) has been created for ${this.AccSystemCode}`,
-        EntityType: 'finance_Customer',
-        EntityValueBefore: JSON.stringify({}),
-        EntityValueAfter: JSON.stringify(newCustomer),
-        PerformedById: 'test',
-        PerformedAt: new Date(),
-        EntityId: newCustomer.CustomerId,
-      };
-
-      // await axios.post(`${config.commonApiUrl}/activity-histories`, payload);
-      await axios.post(
-        `${process.env.COMMON_API_URL}/activity-histories`,
-        payload,
-      );
-
-      return customer;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  async postJournal(dbTransaction: any, journalEntry: JournalEntry) {
-    const debitTransactions = await journalEntry.DebitTransactions;
-    const creditTransactions = await journalEntry.CreditTransactions;
-    try {
-      if (creditTransactions.length < 1 || debitTransactions?.length < 1) {
-        throw new Error(
-          'There should be at least 1 debit ledger transaction and 1 credit ledger transaction in the journal entry',
-        );
-      }
-
-      const totalCreditAmount = creditTransactions.reduce(
-        (accumulator, currentValue) => accumulator + currentValue.CreditAmount,
-        0,
-      );
-      const totalDebitAmount = debitTransactions.reduce(
-        (accumulator, currentValue) => accumulator + currentValue.DebitAmount,
-        0,
-      );
-
-      if (totalCreditAmount !== totalDebitAmount) {
-        throw new Error(
-          'Credit ledger transaction and debit ledger transaction should the same amount',
-        );
-      }
-
-      const newJournalEntry = await journalEntry.save('test', dbTransaction);
-
-      const allLedgerTransactions =
-        await FinanceCompany._LedgerTransactionRepository.findAll({});
-
-      for (const ledgerTransaction of allLedgerTransactions) {
-        ledgerTransaction.JournalEntryId = newJournalEntry.JournalEntryId;
-        await ledgerTransaction.save();
-      }
-
-      await this.AccountingSystem.postJournalEntry(newJournalEntry);
-
-      const payload = {
-        Action: 'Create',
-        Activity: 'Post Journal Entry',
-        Description: `Journal Entry (ID: ${newJournalEntry.JournalEntryId}) has been created`,
-        EntityType: 'JournalEntry',
-        EntityValueBefore: JSON.stringify({}),
-        EntityValueAfter: JSON.stringify(newJournalEntry),
-        PerformedById: 'test',
-        PerformedAt: new Date(),
-        EntityId: newJournalEntry.JournalEntryId,
-      };
-
-      // await axios.post(`${config.commonApiUrl}/activity-histories`, payload);
-      await axios.post(
-        `${process.env.COMMON_API_URL}/activity-histories`,
-        payload,
-      );
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  async createAccount(dbTransaction: any, account: Account) {
-    try {
-      account.validateAccountValue();
-
-      let createAccountPayload: any = {
-        Name: account.Name,
-        AcctNum: account.AccountNo,
-        AccountType: account.AccountType,
-        AccountSubType: account.AccountSubtype,
-      };
-
-      if (account.isParentAccountExists()) {
-        createAccountPayload = {
-          ...createAccountPayload,
-          CurrencyRef: 'MYR',
-          ParentRef: account.ParentAccountNo,
-          SubAccount: true,
-        };
-      }
-
-      const accSystemAccountId = await this.AccountingSystem.createAccount(
-        createAccountPayload,
-      );
-
-      const newAccount = await account.save(
-        accSystemAccountId,
-        'test',
-        dbTransaction,
-      );
-
-      const payload = {
-        Action: 'Create',
-        Activity: 'Account Created',
-        Description: `Account (ID: ${newAccount.AccountNo}) has been created`,
-        EntityType: 'Account',
-        EntityValueBefore: JSON.stringify({}),
-        EntityValueAfter: JSON.stringify(newAccount),
-        PerformedById: 'test',
-        PerformedAt: new Date(),
-        EntityId: newAccount.AccountNo,
-      };
-
-      // await axios.post(`${config.commonApiUrl}/activity-histories`, payload);
-      await axios.post(
-        `${process.env.COMMON_API_URL}/activity-histories`,
-        payload,
-      );
-
-      return account;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  /**
-   * Issue an invoice
-   *
-   * @param dbTransaction - The database transaction to be used
-   * @param loginUser - The user issuing the invoice
-   * @param invoice - The document containing the invoice details
-   * @param customer - The customer to be issued the invoice
-   * @param dtAccountNo - The account number of the Account Receivable (AR) account to debit. If not provided, will debit the customer's default AR account
-   *
-   * @returns {Document} - Document object representing the full details of the invoice issued
-   */
-  async issueInvoice(
-    /*todo: loginUser & customer is NOT supposed to be optional */
-    dbTransaction: any,
-    invoice: Document,
-    loginUser?: LoginUserBase,
-    customer?: FinanceCustomerBase,
-    dtAccountNo?: string,
-  ): Promise<Document> {
-    try {
-      /*Check if the invoice number already exists (should be unique)*/
-      const duplicateInvoice = await FinanceCompany._DocumentRepository.findOne(
-        {
-          where: {
-            DocNo: invoice.DocNo,
-          },
-          transaction: dbTransaction,
-        },
-      );
-
-      if (duplicateInvoice) {
-        throw new Error('Invoice number already exists');
-      }
-
-      const documentItems = await invoice.DocumentItems;
-
-      /*Check if the document has at least 1 document item*/
-      if (!documentItems.length) {
-        throw new Error('Document must have at least 1 document item');
-      }
-
-      /*Check if each document item has CtAccountNo provided*/
-      for (const invoiceItem of documentItems) {
-        if (!invoiceItem.CtAccountNo) {
-          throw new Error(
-            'Each document item should have CtAccountNo provided',
-          );
-        }
-      }
-
-      /*Set up the document type*/
-      invoice.DocType = DocType.INVOICE;
-
-      /*Saving the document and document items to the database*/
-      await FinanceCompany._DocumentRepository.create(
-        {
-          DocNo: invoice.DocNo,
-          DocType: invoice.DocType,
-          DocDate: invoice.DocDate,
-          CompanyId: invoice.CompanyId,
-          Currency: invoice.Currency,
-          Amount: invoice.Amount,
-          Description: invoice.Description,
-          Status: invoice.Status,
-          IssuedById: invoice.IssuedById,
-          IssuedToId: invoice.IssuedToId,
-          IssuedToType: invoice.IssuedToType,
-          CreatedById: invoice.CreatedById,
-          CreatedAt: new Date(),
-          UpdatedById: invoice.UpdatedById,
-          UpdatedAt: new Date(),
-          DocPDFFileMediaId: invoice.DocPDFFileMediaId,
-          DocHTMLFileMediaId: invoice.DocHTMLFileMediaId,
-          AccSystemRefId: invoice.AccSystemRefId,
-          PostedToAccSystemYN: invoice.PostedToAccSystemYN,
-          PostedById: invoice.PostedById,
-          PostedDateTime: new Date(),
-          UseAccSystemDocYN: invoice.UseAccSystemDocYN,
-        },
-        {
-          transaction: dbTransaction,
-        },
-      );
-
-      // Q: IS THIS ONE BELOW NECESSARY? WHY WOULD WE CREATE THE SAME DOCUMENT ITEM
-
-      // documentItems.forEach(async (documentItem) => {
-      //   await FinanceCompany._DocumentItemRepository.create(
-      //     {
-      //       DocumentItemId: cuid(),
-      //       DocNo: documentItem.DocNo,
-      //       Name: documentItem.Name,
-      //       NameBM: documentItem.NameBM,
-      //       Description: documentItem.Description,
-      //       ItemId: documentItem.ItemId,
-      //       ItemType: documentItem.ItemType,
-      //       ItemSKU: documentItem.ItemSKU,
-      //       ItemSerialNo: documentItem.ItemSerialNo,
-      //       Currency: documentItem.Currency,
-      //       UnitPrice: documentItem.UnitPrice,
-      //       Quantity: documentItem.Quantity,
-      //       QuantityUOM: documentItem.QuantityUOM,
-      //       Amount: documentItem.Amount,
-      //       TaxCode: documentItem.TaxCode,
-      //       TaxAmount: documentItem.TaxAmount,
-      //       TaxRate: documentItem.TaxRate,
-      //       TaxInclusiveYN: documentItem.TaxInclusiveYN,
-      //       DtAccountNo: documentItem.DtAccountNo,
-      //       CtAccountNo: documentItem.CtAccountNo,
-      //     },
-      //     {
-      //       transaction: dbTransaction,
-      //     },
-      //   );
-      // });
-
-      /*Generating the invoice*/
-      if (invoice.UseAccSystemDocYN === 'Y') {
-        /*todo: Posting to accounting system to generate invoice*/
-        await this.AccountingSystem.createInvoice(invoice);
-      } else {
-        /*todo: check config file to see which invoice template is to be used for specific project*/
-
-        /*Generating invoice based on template*/
-        invoice.generateInvoice(invoice.IssuedById);
-      }
-
-      const journalEntry = new JournalEntry(dbTransaction);
-      const transactionDate = new Date();
-
-      const ledgerTransaction = await journalEntry.newLedgerTransaction(
-        TransactionTypeOptions.DEBIT,
-      );
-
-      if (dtAccountNo) {
-        /*Transacting using AR account provided*/
-        ledgerTransaction.AccountNo = dtAccountNo;
-      } else {
-        /*Transacting based on default customer AR account*/
-        ledgerTransaction.AccountNo = customer.CustSystemCode + '-AR';
-      }
-
-      ledgerTransaction.Currency = invoice.Currency;
-      ledgerTransaction.DebitAmount = invoice.Amount;
-      ledgerTransaction.Date = transactionDate;
-      ledgerTransaction.Name = invoice.DocNo;
-
-      for (const invoiceItem of documentItems) {
-        const itemLedger = await journalEntry.newLedgerTransaction(
-          TransactionTypeOptions.CREDIT,
-        );
-        itemLedger.AccountNo = invoiceItem.CtAccountNo;
-        itemLedger.Currency = invoiceItem.Currency;
-        itemLedger.CreditAmount = invoiceItem.Amount;
-        itemLedger.Date = transactionDate;
-        itemLedger.Name = invoiceItem.Name;
-      }
-
-      this.postJournal(dbTransaction, journalEntry);
-
-      /*todo: uncomment below later*/
-
-      const payload = {
-        Action: 'Create',
-        Activity: 'Issuing an Invoice',
-        Description: `Ledger Transaction (ID: ${ledgerTransaction.TransactionId}) has been created`,
-        EntityType: 'LedgerTransaction',
-        EntityValueBefore: JSON.stringify({}),
-        EntityValueAfter: JSON.stringify(ledgerTransaction),
-        PerformedById: 'test',
-        PerformedAt: new Date(),
-        EntityId: ledgerTransaction.TransactionId,
-      };
-
-      await axios.post(
-        `${process.env.COMMON_API_URL}/activity-histories`,
-        payload,
-      );
-
-      return invoice;
-    } catch (err) {
-      // tslint:disable-next-line:no-console
-      console.log('Issue invoice err: ', err);
-      throw err;
-    }
-  }
-
-  /**
-   * Issue a debit note
-   *
-   * @param dbTransaction - The database transaction to be used
-   * @param loginUser - The user issuing the invoice
-   * @param invoice - The document containing the invoice details
-   * @param customer - The customer to be issued the invoice
-   * @param dtAccountNo - The account number of the Account Receivable (AR) account to debit. If not provided, will debit the customer's default AR account
-   *
-   * @returns {Document} - Document object representing the full details of the invoice issued
-   */
-  async issueDebitNote(
-    dbTransaction: any,
-    loginUser: LoginUserBase,
-    invoice: Document,
-    customer: FinanceCustomerBase,
-    dtAccountNo?: string,
-  ): Promise<Document> {
-    try {
-      /*Check if the invoice number already exists (should be unique)*/
-      const duplicateInvoice = await FinanceCompany._DocumentRepository.findOne(
-        {
-          where: {
-            DocNo: invoice.DocNo,
-          },
-          transaction: dbTransaction,
-        },
-      );
-
-      if (duplicateInvoice) {
-        throw new Error('Invoice number already exists');
-      }
-
-      const documentItems = await invoice.DocumentItems;
-
-      /*Check if the document has at least 1 document item*/
-      if (!documentItems.length) {
-        throw new Error('Document must have at least 1 document item');
-      }
-
-      /*Check if each document item has CtAccountNo provided*/
-      for (const invoiceItem of documentItems) {
-        if (!invoiceItem.CtAccountNo) {
-          throw new Error(
-            'Each document item should have CtAccountNo provided',
-          );
-        }
-      }
-
-      /*Set up the document type*/
-      invoice.DocType = DocType.DEBIT_NOTE;
-
-      /*Saving the document and document items to the database*/
-      await FinanceCompany._DocumentRepository.create(
-        {
-          DocNo: invoice.DocNo,
-          DocType: invoice.DocType,
-          DocDate: invoice.DocDate,
-          CompanyId: invoice.CompanyId,
-          Currency: invoice.Currency,
-          Amount: invoice.Amount,
-          Description: invoice.Description,
-          Status: invoice.Status,
-          IssuedById: loginUser.ObjectId,
-          IssuedToId: customer.ObjectId,
-          IssuedToType: invoice.IssuedToType,
-          CreatedById: loginUser.ObjectId,
-          CreatedAt: new Date(),
-          UpdatedById: loginUser.ObjectId,
-          UpdatedAt: new Date(),
-          DocPDFFileMediaId: invoice.DocPDFFileMediaId,
-          DocHTMLFileMediaId: invoice.DocHTMLFileMediaId,
-          AccSystemRefId: invoice.AccSystemRefId,
-          PostedToAccSystemYN: invoice.PostedToAccSystemYN,
-          PostedById: invoice.PostedById,
-          PostedDateTime: new Date(),
-          UseAccSystemDocYN: invoice.UseAccSystemDocYN,
-        },
-        {
-          transaction: dbTransaction,
-        },
-      );
-
-      documentItems.forEach(async (documentItem) => {
-        await FinanceCompany._DocumentItemRepository.create(
-          {
-            DocumentItemId: cuid(),
-            DocNo: documentItem.DocNo,
-            Name: documentItem.Name,
-            NameBM: documentItem.NameBM,
-            Description: documentItem.Description,
-            ItemId: documentItem.ItemId,
-            ItemType: documentItem.ItemType,
-            ItemSKU: documentItem.ItemSKU,
-            ItemSerialNo: documentItem.ItemSerialNo,
-            Currency: documentItem.Currency,
-            UnitPrice: documentItem.UnitPrice,
-            Quantity: documentItem.Quantity,
-            QuantityUOM: documentItem.QuantityUOM,
-            Amount: documentItem.Amount,
-            TaxCode: documentItem.TaxCode,
-            TaxAmount: documentItem.TaxAmount,
-            TaxRate: documentItem.TaxRate,
-            TaxInclusiveYN: documentItem.TaxInclusiveYN,
-            DtAccountNo: documentItem.DtAccountNo,
-            CtAccountNo: documentItem.CtAccountNo,
-          },
-          {
-            transaction: dbTransaction,
-          },
-        );
-      });
-
-      /*Generating the invoice*/
-      if (invoice.UseAccSystemDocYN === 'Y') {
-        /*todo: Posting to accounting system to generate invoice*/
-        await this.AccountingSystem.createInvoice(invoice);
-      } else {
-        /*todo: check config file to see which invoice template is to be used for specific project*/
-
-        /*Generating invoice based on template*/
-        invoice.generateInvoice(loginUser.IDNo, customer);
-      }
-
-      const journalEntry = new JournalEntry(dbTransaction);
-      const transactionDate = new Date();
-
-      const debitTransaction = await journalEntry.newLedgerTransaction(
-        TransactionTypeOptions.DEBIT,
-      );
-
-      if (dtAccountNo) {
-        /*Transacting using AR account provided*/
-        debitTransaction.AccountNo = dtAccountNo;
-      } else {
-        /*Transacting based on default customer AR account*/
-        debitTransaction.AccountNo = customer.CustSystemCode + '-AR';
-      }
-
-      debitTransaction.Currency = invoice.Currency;
-      debitTransaction.DebitAmount = invoice.Amount;
-      debitTransaction.Date = transactionDate;
-      debitTransaction.Name = invoice.DocNo;
-
-      for (const invoiceItem of documentItems) {
-        const itemLedger = await journalEntry.newLedgerTransaction(
-          TransactionTypeOptions.CREDIT,
-        );
-        itemLedger.AccountNo = invoiceItem.CtAccountNo;
-        itemLedger.Currency = invoiceItem.Currency;
-        itemLedger.CreditAmount = invoiceItem.Amount;
-        itemLedger.Date = transactionDate;
-        itemLedger.Name = invoiceItem.Name;
-      }
-
-      this.postJournal(dbTransaction, journalEntry);
-
-      const payload = {
-        Action: 'Create',
-        Activity: 'Issuing a Debit Note',
-        Description: `Debit Transaction (ID: ${debitTransaction.TransactionId}) has been created`,
-        EntityType: 'DebitTransaction',
-        EntityValueBefore: JSON.stringify({}),
-        EntityValueAfter: JSON.stringify(debitTransaction),
-        PerformedById: 'test',
-        PerformedAt: new Date(),
-        EntityId: debitTransaction.TransactionId,
-      };
-
-      await axios.post(`${config.commonApiUrl}/activity-histories`, payload);
-
-      return invoice;
-    } catch (err) {
-      // tslint:disable-next-line:no-console
-      console.log('Issue debit note err: ', err);
-      throw err;
-    }
-  }
-
-  /**
-   * Issue a credit note
-   *
-   * @param dbTransaction - The database transaction to be used
-   * @param loginUser - The user issuing the credit note
-   * @param creditNote - The document containing the credit note details
-   * @param customer - The customer to be issued the credit note
-   * @param ctAccountNo - The account number of the Account Payable (AP) account to debit. If not provided, will debit the customer's default AR account
-   *
-   * @returns {Document} - Document object representing the full details of the invoice issued
-   */
-  async issueCreditNote(
-    dbTransaction: any,
-    loginUser: LoginUserBase,
-    creditNote: Document,
-    customer: FinanceCustomerBase,
-    ctAccountNo?: string,
-  ): Promise<Document> {
-    try {
-      /*Check if the invoice number already exists (should be unique)*/
-      const duplicateCreditNote =
-        await FinanceCompany._DocumentRepository.findOne({
-          where: {
-            DocNo: creditNote.DocNo,
-          },
-          transaction: dbTransaction,
-        });
-
-      if (duplicateCreditNote) {
-        throw new Error('Invoice number already exists');
-      }
-
-      const documentItems = await creditNote.DocumentItems;
-
-      /*Check if the document has at least 1 document item*/
-      if (!documentItems.length) {
-        throw new Error('Document must have at least 1 document item');
-      }
-
-      /*Check if each document item has CtAccountNo provided*/
-      for (const invoiceItem of documentItems) {
-        if (!invoiceItem.CtAccountNo) {
-          throw new Error(
-            'Each document item should have CtAccountNo provided',
-          );
-        }
-      }
-
-      /*Set up the document type*/
-      creditNote.DocType = DocType.DEBIT_NOTE;
-
-      /*Saving the document and document items to the database*/
-      await FinanceCompany._DocumentRepository.create(
-        {
-          DocNo: creditNote.DocNo,
-          DocType: creditNote.DocType,
-          DocDate: creditNote.DocDate,
-          CompanyId: creditNote.CompanyId,
-          Currency: creditNote.Currency,
-          Amount: creditNote.Amount,
-          Description: creditNote.Description,
-          Status: creditNote.Status,
-          IssuedById: loginUser.ObjectId,
-          IssuedToId: customer.ObjectId,
-          IssuedToType: creditNote.IssuedToType,
-          CreatedById: loginUser.ObjectId,
-          CreatedAt: new Date(),
-          UpdatedById: loginUser.ObjectId,
-          UpdatedAt: new Date(),
-          DocPDFFileMediaId: creditNote.DocPDFFileMediaId,
-          DocHTMLFileMediaId: creditNote.DocHTMLFileMediaId,
-          AccSystemRefId: creditNote.AccSystemRefId,
-          PostedToAccSystemYN: creditNote.PostedToAccSystemYN,
-          PostedById: creditNote.PostedById,
-          PostedDateTime: new Date(),
-          UseAccSystemDocYN: creditNote.UseAccSystemDocYN,
-        },
-        {
-          transaction: dbTransaction,
-        },
-      );
-
-      documentItems.forEach(async (documentItem) => {
-        await FinanceCompany._DocumentItemRepository.create(
-          {
-            DocumentItemId: documentItem.DocumentItemId,
-            DocNo: documentItem.DocNo,
-            Name: documentItem.Name,
-            NameBM: documentItem.NameBM,
-            Description: documentItem.Description,
-            ItemId: documentItem.ItemId,
-            ItemType: documentItem.ItemType,
-            ItemSKU: documentItem.ItemSKU,
-            ItemSerialNo: documentItem.ItemSerialNo,
-            Currency: documentItem.Currency,
-            UnitPrice: documentItem.UnitPrice,
-            Quantity: documentItem.Quantity,
-            QuantityUOM: documentItem.QuantityUOM,
-            Amount: documentItem.Amount,
-            TaxCode: documentItem.TaxCode,
-            TaxAmount: documentItem.TaxAmount,
-            TaxRate: documentItem.TaxRate,
-            TaxInclusiveYN: documentItem.TaxInclusiveYN,
-            DtAccountNo: documentItem.DtAccountNo,
-            CtAccountNo: documentItem.CtAccountNo,
-          },
-          {
-            transaction: dbTransaction,
-          },
-        );
-      });
-
-      /*Generating the credit note*/
-      if (creditNote.UseAccSystemDocYN === 'Y') {
-        /*todo: Posting to accounting system to generate creditNote*/
-        await this.AccountingSystem.createCreditNote(creditNote);
-      } else {
-        /*todo: check config file to see which invoice template is to be used for specific project*/
-
-        /*Generating credit note based on template*/
-        creditNote.generateCreditNote(loginUser.IDNo, customer);
-      }
-
-      const journalEntry = new JournalEntry(dbTransaction);
-      const transactionDate = new Date();
-
-      const creditTransaction = await journalEntry.newLedgerTransaction(
-        TransactionTypeOptions.CREDIT,
-      );
-
-      if (ctAccountNo) {
-        /*Transacting using AR account provided*/
-        creditTransaction.AccountNo = ctAccountNo;
-      } else {
-        /*Transacting based on default customer AR account*/
-        creditTransaction.AccountNo = customer.CustSystemCode + '-AP';
-      }
-
-      creditTransaction.Currency = creditNote.Currency;
-      creditTransaction.CreditAmount = creditNote.Amount;
-      creditTransaction.Date = transactionDate;
-      creditTransaction.Name = creditNote.DocNo;
-
-      for (const invoiceItem of documentItems) {
-        const itemLedger = await journalEntry.newLedgerTransaction(
-          TransactionTypeOptions.DEBIT,
-        );
-        itemLedger.AccountNo = invoiceItem.CtAccountNo;
-        itemLedger.Currency = invoiceItem.Currency;
-        itemLedger.DebitAmount = invoiceItem.Amount;
-        itemLedger.Date = transactionDate;
-        itemLedger.Name = invoiceItem.Name;
-      }
-
-      this.postJournal(dbTransaction, journalEntry);
-
-      const payload = {
-        Action: 'Create',
-        Activity: 'Issuing a Credit Note Transaction',
-        Description: `Credit Transaction (ID: ${creditTransaction.TransactionId}) has been created`,
-        EntityType: 'CreditTransaction',
-        EntityValueBefore: JSON.stringify({}),
-        EntityValueAfter: JSON.stringify(creditTransaction),
-        PerformedById: 'test',
-        PerformedAt: transactionDate,
-        EntityId: creditTransaction.TransactionId,
-      };
-
-      await axios.post(`${config.commonApiUrl}/activity-histories`, payload);
-
-      return creditNote;
-    } catch (err) {
-      // tslint:disable-next-line:no-console
-      console.log('Issue credit note err: ', err);
-      throw err;
-    }
-  }
-
-  /**
-   * Register a payment collected
-   *
-   * @param dbTransaction - The database transaction to be used
-   * @param loginUser - The user collecting the payment
-   * @param payment - The payment object containing payment details
-   * @param customer - The customer making the payment
-   * @param ctAccountNo - The customer's Account Receivable (AR) account to credit
-   *
-   * @returns {Payment} - Payment object representing the full detals of the payment collection recorded
-   */
-  async collectPayment(
-    dbTransaction: any,
-    loginUser: LoginUserBase,
-    payment: Payment,
-    customer: FinanceCustomerBase,
-    ctAccountNo?: string,
-  ): Promise<Payment> {
-    let paymentMethodType: PaymentMethodType;
-    try {
-      paymentMethodType = new PaymentMethodType(
-        dbTransaction,
-        payment.MethodTypeId,
-      );
-
-      const paymentItems = await payment.PaymentItems;
-      if (paymentItems.length < 1) {
-        throw new Error(
-          'Atleast one payment item is required to identify what payment is being paid for',
-        );
-      }
-
-      payment.PaymentId = cuid();
-
-      await FinanceCompany._PaymentRepository.create(
-        {
-          PaymentId: payment.PaymentId,
-          PaymentType: payment.PaymentType,
-          PaymentDate: payment.PaymentDate,
-          CompanyId: this.CompanyId,
-          MethodTypeId: payment.MethodTypeId,
-          Currency: payment.Currency,
-          Amount: payment.Amount,
-          Status: PaymentStatus.SUCCESSFUL,
-          TransactionId: payment.TransactionId,
-          TransactionApprovalCode: payment.TransactionApprovalCode,
-          TransactionAccountName: payment.TransactionAccountName,
-          TransactionAccountNo: payment.TransactionAccountNo,
-          ReceivedBy: payment.ReceivedBy,
-          PostedToAccSystemYN: 'N',
-          UpdatedAt: new Date(),
-          UpdatedBy: loginUser.ObjectId,
-          CreatedAt: new Date(),
-          CreatedBy: loginUser.ObjectId,
-        },
-        { transaction: dbTransaction },
-      );
-
-      paymentItems.forEach(async (paymentItem) => {
-        await FinanceCompany._PaymentItemRepository.create(
-          {
-            PaymentId: payment.PaymentId,
-            PayForObjectId: paymentItem.PayForObjectId,
-            PayForObjectType: paymentItem.PayForObjectType,
-            Currency: paymentItem.Currency,
-            Amount: paymentItem.Amount,
-          },
-          { transaction: dbTransaction },
-        );
-      });
-
-      const journalEntry = new JournalEntry(dbTransaction);
-      //Temporary fix to successfully save journal entry in PostJournal
-      journalEntry.init({
-        CompanyId: this.CompanyId,
-        Name: 'Collect-payments for ' + payment.PaymentId,
-      });
-      const transactionDate = new Date();
-
-      const debitLT = await journalEntry.newLedgerTransaction(
-        TransactionTypeOptions.DEBIT,
-      );
-      debitLT.AccountNo = paymentMethodType.AccountNo;
-      debitLT.Currency = payment.Currency;
-      debitLT.DebitAmount = payment.Amount;
-      debitLT.Date = transactionDate;
-      debitLT.Name = customer.FullName;
-
-      const creditLT = await journalEntry.newLedgerTransaction(
-        TransactionTypeOptions.CREDIT,
-      );
-
-      if (ctAccountNo) {
-        creditLT.AccountNo = ctAccountNo;
-      } else {
-        // const config = getConfig();
-        creditLT.AccountNo = customer.CustSystemCode + '-AR';
-      }
-      creditLT.Currency = payment.Currency;
-      creditLT.CreditAmount = payment.Amount;
-      creditLT.Date = transactionDate;
-      creditLT.Name = paymentMethodType.Name;
-
-      await this.postJournal(dbTransaction, journalEntry);
-
-      /*todo: saving a record into the activity history table*/
-
-      return payment;
-    } catch (error) {
-      if (error instanceof RecordNotFoundError) {
-        throw new Error('Invalid PaymentMethodType id');
-      } else {
-        throw error;
-      }
-    }
-  }
-}
+import axios from 'axios';
+import * as cuid from 'cuid';
+import {
+  HashTable,
+  LoginUserBase,
+  ObjectBase,
+  RecordNotFoundError,
+} from '@tomei/general';
+import Account from '../account/account';
+import JournalEntry from '../journal-entry/journal-entry';
+import FinanceCustomerBase from '../customer/customer';
+import Document from '../document/document';
+import { IAccountSystem } from '../interfaces';
+import { FinanceCompanyRepository } from './finance-company.repository';
+import { FinanceCustomerRepository } from '../customer/finance-customer.repository';
+import { LedgerTransactionRepository } from '../ledger-transaction/ledger-transaction.repository';
+import { DocType, PaymentStatus, TransactionTypeOptions } from '../enum';
+import PaymentMethodType from '../payment-method-type/payment-method-type';
+import { PaymentRepository } from '../payment/payment.repository';
+import { PaymentItemRepository } from '../payment-item/payment-item.repository';
+import Payment from '../payment/payment';
+import { DocumentRepository } from '../document/document.repository';
+import { DocumentItemRepository } from '../document/document-item.repository';
+import { PaymentMethodRepository } from '../payment-method/payment-method.repository';
+import { PaymentMethodTypeRepository } from '../payment-method-type/payment-method-type.repository';
+import PaymentMethod from '../payment-method/payment-method';
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { getConfig } = require('../config');
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const config = getConfig();
+
+export default class FinanceCompany extends ObjectBase {
+  private _CompanyId = 'New';
+  private _CompSystemCode = '';
+  private _CompSystemRefId = '';
+  private _AccSystemCode = '';
+  private static _htFinanceCompanyIds = new HashTable();
+  private static _htFinanceCompanies = new HashTable();
+  private static _financeCompanyRepository = new FinanceCompanyRepository();
+  private static _PaymentRepository = new PaymentRepository();
+  private static _PaymentItemRepository = new PaymentItemRepository();
+  private static _PaymentMethodRepository = new PaymentMethodRepository();
+  private static _PaymentMethodTypeRepository =
+    new PaymentMethodTypeRepository();
+  private static _DocumentRepository = new DocumentRepository();
+  private static _DocumentItemRepository = new DocumentItemRepository();
+  private static _FinanceCustomerRepository = new FinanceCustomerRepository();
+  private static _LedgerTransactionRepository =
+    new LedgerTransactionRepository();
+  private _AccountingSystem: IAccountSystem;
+
+  private _PaymentMethods = null;
+
+  get CompSystemCode(): string {
+    return this._CompSystemCode;
+  }
+
+  private set CompSystemCode(code: string) {
+    this._CompSystemCode = code;
+  }
+
+  get CompSystemRefId() {
+    return this._CompSystemRefId;
+  }
+
+  set CompSystemRefId(id: string) {
+    this._CompSystemRefId = id;
+  }
+
+  get AccSystemCode() {
+    return this._AccSystemCode;
+  }
+
+  private set AccSystemCode(code: string) {
+    this._AccSystemCode = code;
+  }
+
+  get CompanyId() {
+    return this._CompanyId;
+  }
+
+  get ObjectId() {
+    return this._CompanyId;
+  }
+
+  private set ObjectId(id: string) {
+    this._CompanyId = id;
+  }
+
+  get ObjectName() {
+    return `${this.CompSystemCode}-${this.CompSystemRefId}-${this.AccSystemCode}`;
+  }
+
+  get TableName() {
+    return 'finance_Company';
+  }
+
+  get AccountingSystem(): IAccountSystem {
+    return this._AccountingSystem;
+  }
+
+  set AccountingSystem(system: IAccountSystem) {
+    this._AccountingSystem = system;
+  }
+
+  constructor(
+    compSystemCode: string,
+    compSystemRefId: string,
+    accSystemCode: string,
+  ) {
+    super();
+    this.CompSystemCode = compSystemCode;
+    this.CompSystemRefId = compSystemRefId;
+    this.AccSystemCode = accSystemCode;
+  }
+
+  static async getFinanceCompanyId(
+    compSystemCode: string,
+    compSystemRefId: string,
+    accSystemCode: string,
+  ): Promise<string> {
+    let sCompanyId = '';
+    /*Assemble the hashtable key*/
+    const sKey = `${compSystemCode}-${compSystemRefId}-${accSystemCode}`;
+    /*Check if the FinanceCompany has previously being loaded*/
+    if (!FinanceCompany._htFinanceCompanyIds.get(sKey)) {
+      /*Instantiate a new FinanceCompany*/
+      const financeCompany = new FinanceCompany(
+        compSystemCode,
+        compSystemRefId,
+        accSystemCode,
+      );
+
+      /*Retrieve the finance company from finance_Company table using compSystemCode,
+       * CompSystemRefId and accSystemCode */
+      const company = await FinanceCompany._financeCompanyRepository.findOne({
+        where: {
+          CompSystemCode: compSystemCode,
+          CompSystemRefId: compSystemRefId,
+          AccSystemCode: accSystemCode,
+        },
+      });
+
+      /*Retrieve and store the companyId from the result*/
+      financeCompany.ObjectId = company.CompanyId;
+      sCompanyId = financeCompany.ObjectId;
+
+      /*Add the details into the hashtable*/
+      FinanceCompany._htFinanceCompanyIds.add(sKey, financeCompany.ObjectId);
+      FinanceCompany._htFinanceCompanies.add(sCompanyId, financeCompany);
+    }
+
+    if (typeof FinanceCompany._htFinanceCompanyIds.get(sKey) === 'string') {
+      sCompanyId = FinanceCompany._htFinanceCompanyIds.get(sKey);
+    }
+
+    return sCompanyId;
+  }
+
+  static async getFinanceCompany(companyId: string): Promise<FinanceCompany> {
+    /*Check if the finance company is previously be loaded*/
+    if (!FinanceCompany._htFinanceCompanies.get(companyId)) {
+      /*Retrieve the finance company from finance_Company table using compSystemCode,
+       * CompSystemRefId and accSystemCode */
+      const company = await FinanceCompany._financeCompanyRepository.findOne({
+        where: { CompanyId: companyId },
+      });
+
+      if (!company) {
+        throw Error('No finance company found. Please create first.');
+      }
+
+      /*Using the result returned, instantiate a new FinanceCompany*/
+      const compSystemCode = company.CompSystemCode;
+      const compSystemRefId = company.CompSystemRefId;
+      const accSystemCode = company.AccSystemCode;
+
+      const financeCompany = new FinanceCompany(
+        compSystemCode,
+        compSystemRefId,
+        accSystemCode,
+      );
+
+      /*Retrieve and store the CompanyId from the result*/
+      financeCompany.ObjectId = company.CompanyId;
+      financeCompany._CompanyId = company.CompanyId;
+
+      /*Add the details into the hashtable*/
+      const sKey = `${compSystemCode}-${compSystemRefId}-${accSystemCode}`;
+      FinanceCompany._htFinanceCompanyIds.add(sKey, financeCompany.ObjectId);
+      FinanceCompany._htFinanceCompanies.add(
+        financeCompany.ObjectId,
+        financeCompany,
+      );
+    }
+    // tslint:disable-next-line:no-console
+    console.log('return from hash table');
+    return FinanceCompany._htFinanceCompanies.get(companyId);
+  }
+
+  static async createFinanceCompany(
+    dbTransaction: any,
+    loginUser: LoginUserBase,
+    compSystemCode: string,
+    compSystemRefId: string,
+    accSystemCode: string,
+  ) {
+    /*Instantiate a new FinanceCompany*/
+    const financeCompany = new FinanceCompany(
+      compSystemCode,
+      compSystemRefId,
+      accSystemCode,
+    );
+
+    /*Validating if the finance company already exists in finance_Company*/
+    const company = await FinanceCompany._financeCompanyRepository.findOne({
+      where: {
+        CompSystemCode: compSystemCode,
+        CompSystemRefId: compSystemRefId,
+        AccSystemCode: accSystemCode,
+      },
+    });
+
+    if (company) {
+      throw Error(
+        'There is already another Finance Company with the compSystemCode, CompSystemRefId and accSystemCode specified.',
+      );
+    }
+
+    /*Generating the companyId*/
+    financeCompany.ObjectId = cuid();
+
+    /*Save the FinanceCompany to the finance_Company table*/
+    await FinanceCompany._financeCompanyRepository.create(
+      {
+        CompanyId: financeCompany.CompanyId,
+        CompSystemCode: financeCompany.CompSystemCode,
+        CompSystemRefId: financeCompany.CompSystemRefId,
+        AccSystemCode: financeCompany.AccSystemCode,
+      },
+      {
+        transaction: dbTransaction,
+      },
+    );
+
+    /*Add the details to hashtable*/
+    const sKey = `${compSystemCode}-${compSystemRefId}-${accSystemCode}`;
+    FinanceCompany._htFinanceCompanyIds.add(sKey, financeCompany.ObjectId);
+    FinanceCompany._htFinanceCompanies.add(
+      financeCompany.ObjectId,
+      financeCompany,
+    );
+  }
+
+  async createCustomer(
+    dbTransaction: any,
+    custSystemCode: string,
+    custSystemRefId: string,
+    customer: FinanceCustomerBase,
+  ) {
+    try {
+      if (!customer.CustSystemCode || !customer.CustSystemRefId) {
+        throw new Error(
+          'CustSystemCode and CustomerRefId are required fields.',
+        );
+      }
+
+      const financeCustomerData =
+        await FinanceCompany._FinanceCustomerRepository.findOne({
+          where: {
+            CompanyId: this._CompanyId,
+            CustSystemCode: custSystemCode,
+            CustSystemRefId: custSystemRefId,
+          },
+        });
+
+      if (financeCustomerData) {
+        throw new Error('Customer already created previously.');
+      }
+
+      // Retrieve the type of accounting system, API Key, and API secret based on SysCode from the Config.ts
+      const customerId = await this.AccountingSystem.createCustomer({
+        customer,
+      });
+
+      const newCustomer = await customer.save(
+        customerId,
+        custSystemCode,
+        custSystemRefId,
+        dbTransaction,
+      );
+
+      const payload = {
+        Action: 'Create',
+        Activity: 'Finance Customer Created',
+        Description: `Customer (ID: ${newCustomer.CustomerId}) has been created for ${this.AccSystemCode}`,
+        EntityType: 'finance_Customer',
+        EntityValueBefore: JSON.stringify({}),
+        EntityValueAfter: JSON.stringify(newCustomer),
+        PerformedById: 'test',
+        PerformedAt: new Date(),
+        EntityId: newCustomer.CustomerId,
+      };
+
+      await axios.post(
+        `${process.env.COMMON_API_URL}/activity-histories`,
+        payload,
+      );
+
+      return customer;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async postJournal(dbTransaction: any, journalEntry: JournalEntry) {
+    const debitTransactions = await journalEntry.DebitTransactions;
+    const creditTransactions = await journalEntry.CreditTransactions;
+    try {
+      if (creditTransactions.length < 1 || debitTransactions?.length < 1) {
+        throw new Error(
+          'There should be at least 1 debit ledger transaction and 1 credit ledger transaction in the journal entry',
+        );
+      }
+
+      const totalCreditAmount = creditTransactions.reduce(
+        (accumulator, currentValue) => accumulator + currentValue.CreditAmount,
+        0,
+      );
+      const totalDebitAmount = debitTransactions.reduce(
+        (accumulator, currentValue) => accumulator + currentValue.DebitAmount,
+        0,
+      );
+
+      if (totalCreditAmount !== totalDebitAmount) {
+        throw new Error(
+          'Credit ledger transaction and debit ledger transaction should the same amount',
+        );
+      }
+
+      const newJournalEntry = await journalEntry.save('test', dbTransaction);
+
+      const allLedgerTransactions =
+        await FinanceCompany._LedgerTransactionRepository.findAll({});
+
+      for (const ledgerTransaction of allLedgerTransactions) {
+        ledgerTransaction.JournalEntryId = newJournalEntry.JournalEntryId;
+        await ledgerTransaction.save();
+      }
+
+      await this.AccountingSystem.postJournalEntry(newJournalEntry);
+
+      const payload = {
+        Action: 'Create',
+        Activity: 'Post Journal Entry',
+        Description: `Journal Entry (ID: ${newJournalEntry.JournalEntryId}) has been created`,
+        EntityType: 'JournalEntry',
+        EntityValueBefore: JSON.stringify({}),
+        EntityValueAfter: JSON.stringify(newJournalEntry),
+        PerformedById: 'test',
+        PerformedAt: new Date(),
+        EntityId: newJournalEntry.JournalEntryId,
+      };
+
+      await axios.post(
+        `${process.env.COMMON_API_URL}/activity-histories`,
+        payload,
+      );
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async createAccount(dbTransaction: any, account: Account) {
+    try {
+      account.validateAccountValue();
+
+      let createAccountPayload: any = {
+        Name: account.Name,
+        AcctNum: account.AccountNo,
+        AccountType: account.AccountType,
+        AccountSubType: account.AccountSubtype,
+      };
+
+      if (account.isParentAccountExists()) {
+        createAccountPayload = {
+          ...createAccountPayload,
+          CurrencyRef: 'MYR',
+          ParentRef: account.ParentAccountNo,
+          SubAccount: true,
+        };
+      }
+
+      const accSystemAccountId = await this.AccountingSystem.createAccount(
+        createAccountPayload,
+      );
+
+      const newAccount = await account.save(
+        accSystemAccountId,
+        'test',
+        dbTransaction,
+      );
+
+      const payload = {
+        Action: 'Create',
+        Activity: 'Account Created',
+        Description: `Account (ID: ${newAccount.AccountNo}) has been created`,
+        EntityType: 'Account',
+        EntityValueBefore: JSON.stringify({}),
+        EntityValueAfter: JSON.stringify(newAccount),
+        PerformedById: 'test',
+        PerformedAt: new Date(),
+        EntityId: newAccount.AccountNo,
+      };
+
+      await axios.post(
+        `${process.env.COMMON_API_URL}/activity-histories`,
+        payload,
+      );
+
+      return account;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Issue an invoice
+   *
+   * @param dbTransaction - The database transaction to be used
+   * @param loginUser - The user issuing the invoice
+   * @param invoice - The document containing the invoice details
+   * @param customer - The customer to be issued the invoice
+   * @param dtAccountNo - The account number of the Account Receivable (AR) account to debit. If not provided, will debit the customer's default AR account
+   *
+   * @returns {Document} - Document object representing the full details of the invoice issued
+   */
+  async issueInvoice(
+    /*todo: loginUser & customer is NOT supposed to be optional */
+    dbTransaction: any,
+    invoice: Document,
+    loginUser?: LoginUserBase,
+    customer?: FinanceCustomerBase,
+    dtAccountNo?: string,
+  ): Promise<Document> {
+    try {
+      /*Check if the invoice number already exists (should be unique)*/
+      const duplicateInvoice = await FinanceCompany._DocumentRepository.findOne(
+        {
+          where: {
+            DocNo: invoice.DocNo,
+          },
+          transaction: dbTransaction,
+        },
+      );
+
+      if (duplicateInvoice) {
+        throw new Error('Invoice number already exists');
+      }
+
+      const documentItems = await invoice.DocumentItems;
+
+      /*Check if the document has at least 1 document item*/
+      if (!documentItems.length) {
+        throw new Error('Document must have at least 1 document item');
+      }
+
+      /*Check if each document item has CtAccountNo provided*/
+      for (const invoiceItem of documentItems) {
+        if (!invoiceItem.CtAccountNo) {
+          throw new Error(
+            'Each document item should have CtAccountNo provided',
+          );
+        }
+      }
+
+      /*Set up the document type*/
+      invoice.DocType = DocType.INVOICE;
+
+      /*Saving the document and document items to the database*/
+      await FinanceCompany._DocumentRepository.create(
+        {
+          DocNo: invoice.DocNo,
+          DocType: invoice.DocType,
+          DocDate: invoice.DocDate,
+          CompanyId: invoice.CompanyId,
+          Currency: invoice.Currency,
+          Amount: invoice.Amount,
+          Description: invoice.Description,
+          Status: invoice.Status,
+          IssuedById: invoice.IssuedById,
+          IssuedToId: invoice.IssuedToId,
+          IssuedToType: invoice.IssuedToType,
+          CreatedById: invoice.CreatedById,
+          CreatedAt: new Date(),
+          UpdatedById: invoice.UpdatedById,
+          UpdatedAt: new Date(),
+          DocPDFFileMediaId: invoice.DocPDFFileMediaId,
+          DocHTMLFileMediaId: invoice.DocHTMLFileMediaId,
+          AccSystemRefId: invoice.AccSystemRefId,
+          PostedToAccSystemYN: invoice.PostedToAccSystemYN,
+          PostedById: invoice.PostedById,
+          PostedDateTime: new Date(),
+          UseAccSystemDocYN: invoice.UseAccSystemDocYN,
+        },
+        {
+          transaction: dbTransaction,
+        },
+      );
+
+      // Q: IS THIS ONE BELOW NECESSARY? WHY WOULD WE CREATE THE SAME DOCUMENT ITEM
+
+      // documentItems.forEach(async (documentItem) => {
+      //   await FinanceCompany._DocumentItemRepository.create(
+      //     {
+      //       DocumentItemId: cuid(),
+      //       DocNo: documentItem.DocNo,
+      //       Name: documentItem.Name,
+      //       NameBM: documentItem.NameBM,
+      //       Description: documentItem.Description,
+      //       ItemId: documentItem.ItemId,
+      //       ItemType: documentItem.ItemType,
+      //       ItemSKU: documentItem.ItemSKU,
+      //       ItemSerialNo: documentItem.ItemSerialNo,
+      //       Currency: documentItem.Currency,
+      //       UnitPrice: documentItem.UnitPrice,
+      //       Quantity: documentItem.Quantity,
+      //       QuantityUOM: documentItem.QuantityUOM,
+      //       Amount: documentItem.Amount,
+      //       TaxCode: documentItem.TaxCode,
+      //       TaxAmount: documentItem.TaxAmount,
+      //       TaxRate: documentItem.TaxRate,
+      //       TaxInclusiveYN: documentItem.TaxInclusiveYN,
+      //       DtAccountNo: documentItem.DtAccountNo,
+      //       CtAccountNo: documentItem.CtAccountNo,
+      //     },
+      //     {
+      //       transaction: dbTransaction,
+      //     },
+      //   );
+      // });
+
+      /*Generating the invoice*/
+      if (invoice.UseAccSystemDocYN === 'Y') {
+        /*todo: Posting to accounting system to generate invoice*/
+        await this.AccountingSystem.createInvoice(invoice);
+      } else {
+        /*todo: check config file to see which invoice template is to be used for specific project*/
+
+        /*Generating invoice based on template*/
+        invoice.generateInvoice(invoice.IssuedById);
+      }
+
+      const journalEntry = new JournalEntry(dbTransaction);
+      const transactionDate = new Date();
+
+      const ledgerTransaction = await journalEntry.newLedgerTransaction(
+        TransactionTypeOptions.DEBIT,
+      );
+
+      if (dtAccountNo) {
+        /*Transacting using AR account provided*/
+        ledgerTransaction.AccountNo = dtAccountNo;
+      } else {
+        /*Transacting based on default customer AR account*/
+        ledgerTransaction.AccountNo = customer.CustSystemCode + '-AR';
+      }
+
+      ledgerTransaction.Currency = invoice.Currency;
+      ledgerTransaction.DebitAmount = invoice.Amount;
+      ledgerTransaction.Date = transactionDate;
+      ledgerTransaction.Name = invoice.DocNo;
+
+      for (const invoiceItem of documentItems) {
+        const itemLedger = await journalEntry.newLedgerTransaction(
+          TransactionTypeOptions.CREDIT,
+        );
+        itemLedger.AccountNo = invoiceItem.CtAccountNo;
+        itemLedger.Currency = invoiceItem.Currency;
+        itemLedger.CreditAmount = invoiceItem.Amount;
+        itemLedger.Date = transactionDate;
+        itemLedger.Name = invoiceItem.Name;
+      }
+
+      this.postJournal(dbTransaction, journalEntry);
+
+      /*todo: uncomment below later*/
+
+      // const payload = {
+      //   Action: 'Create',
+      //   Activity: 'Issuing an Invoice',
+      //   Description: `Ledger Transaction (ID: ${ledgerTransaction.TransactionId}) has been created`,
+      //   EntityType: 'LedgerTransaction',
+      //   EntityValueBefore: JSON.stringify({}),
+      //   EntityValueAfter: JSON.stringify(ledgerTransaction),
+      //   PerformedById: 'test',
+      //   PerformedAt: new Date(),
+      //   EntityId: ledgerTransaction.TransactionId,
+      // };
+
+      // await axios.post(
+      //   `${process.env.COMMON_API_URL}/activity-histories`,
+      //   payload,
+      // );
+
+      return invoice;
+    } catch (err) {
+      // tslint:disable-next-line:no-console
+      console.log('Issue invoice err: ', err);
+      throw err;
+    }
+  }
+
+  /**
+   * Issue a debit note
+   *
+   * @param dbTransaction - The database transaction to be used
+   * @param loginUser - The user issuing the invoice
+   * @param invoice - The document containing the invoice details
+   * @param customer - The customer to be issued the invoice
+   * @param dtAccountNo - The account number of the Account Receivable (AR) account to debit. If not provided, will debit the customer's default AR account
+   *
+   * @returns {Document} - Document object representing the full details of the invoice issued
+   */
+  async issueDebitNote(
+    dbTransaction: any,
+    loginUser: LoginUserBase,
+    invoice: Document,
+    customer: FinanceCustomerBase,
+    dtAccountNo?: string,
+  ): Promise<Document> {
+    try {
+      /*Check if the invoice number already exists (should be unique)*/
+      const duplicateInvoice = await FinanceCompany._DocumentRepository.findOne(
+        {
+          where: {
+            DocNo: invoice.DocNo,
+          },
+          transaction: dbTransaction,
+        },
+      );
+
+      if (duplicateInvoice) {
+        throw new Error('Invoice number already exists');
+      }
+
+      const documentItems = await invoice.DocumentItems;
+
+      /*Check if the document has at least 1 document item*/
+      if (!documentItems.length) {
+        throw new Error('Document must have at least 1 document item');
+      }
+
+      /*Check if each document item has CtAccountNo provided*/
+      for (const invoiceItem of documentItems) {
+        if (!invoiceItem.CtAccountNo) {
+          throw new Error(
+            'Each document item should have CtAccountNo provided',
+          );
+        }
+      }
+
+      /*Set up the document type*/
+      invoice.DocType = DocType.DEBIT_NOTE;
+
+      /*Saving the document and document items to the database*/
+      await FinanceCompany._DocumentRepository.create(
+        {
+          DocNo: invoice.DocNo,
+          DocType: invoice.DocType,
+          DocDate: invoice.DocDate,
+          CompanyId: invoice.CompanyId,
+          Currency: invoice.Currency,
+          Amount: invoice.Amount,
+          Description: invoice.Description,
+          Status: invoice.Status,
+          IssuedById: loginUser.ObjectId,
+          IssuedToId: customer.ObjectId,
+          IssuedToType: invoice.IssuedToType,
+          CreatedById: loginUser.ObjectId,
+          CreatedAt: new Date(),
+          UpdatedById: loginUser.ObjectId,
+          UpdatedAt: new Date(),
+          DocPDFFileMediaId: invoice.DocPDFFileMediaId,
+          DocHTMLFileMediaId: invoice.DocHTMLFileMediaId,
+          AccSystemRefId: invoice.AccSystemRefId,
+          PostedToAccSystemYN: invoice.PostedToAccSystemYN,
+          PostedById: invoice.PostedById,
+          PostedDateTime: new Date(),
+          UseAccSystemDocYN: invoice.UseAccSystemDocYN,
+        },
+        {
+          transaction: dbTransaction,
+        },
+      );
+
+      documentItems.forEach(async (documentItem) => {
+        await FinanceCompany._DocumentItemRepository.create(
+          {
+            DocumentItemId: cuid(),
+            DocNo: documentItem.DocNo,
+            Name: documentItem.Name,
+            NameBM: documentItem.NameBM,
+            Description: documentItem.Description,
+            ItemId: documentItem.ItemId,
+            ItemType: documentItem.ItemType,
+            ItemSKU: documentItem.ItemSKU,
+            ItemSerialNo: documentItem.ItemSerialNo,
+            Currency: documentItem.Currency,
+            UnitPrice: documentItem.UnitPrice,
+            Quantity: documentItem.Quantity,
+            QuantityUOM: documentItem.QuantityUOM,
+            Amount: documentItem.Amount,
+            TaxCode: documentItem.TaxCode,
+            TaxAmount: documentItem.TaxAmount,
+            TaxRate: documentItem.TaxRate,
+            TaxInclusiveYN: documentItem.TaxInclusiveYN,
+            DtAccountNo: documentItem.DtAccountNo,
+            CtAccountNo: documentItem.CtAccountNo,
+          },
+          {
+            transaction: dbTransaction,
+          },
+        );
+      });
+
+      /*Generating the invoice*/
+      if (invoice.UseAccSystemDocYN === 'Y') {
+        /*todo: Posting to accounting system to generate invoice*/
+        await this.AccountingSystem.createInvoice(invoice);
+      } else {
+        /*todo: check config file to see which invoice template is to be used for specific project*/
+
+        /*Generating invoice based on template*/
+        invoice.generateInvoice(loginUser.IDNo, customer);
+      }
+
+      const journalEntry = new JournalEntry(dbTransaction);
+      const transactionDate = new Date();
+
+      const debitTransaction = await journalEntry.newLedgerTransaction(
+        TransactionTypeOptions.DEBIT,
+      );
+
+      if (dtAccountNo) {
+        /*Transacting using AR account provided*/
+        debitTransaction.AccountNo = dtAccountNo;
+      } else {
+        /*Transacting based on default customer AR account*/
+        debitTransaction.AccountNo = customer.CustSystemCode + '-AR';
+      }
+
+      debitTransaction.Currency = invoice.Currency;
+      debitTransaction.DebitAmount = invoice.Amount;
+      debitTransaction.Date = transactionDate;
+      debitTransaction.Name = invoice.DocNo;
+
+      for (const invoiceItem of documentItems) {
+        const itemLedger = await journalEntry.newLedgerTransaction(
+          TransactionTypeOptions.CREDIT,
+        );
+        itemLedger.AccountNo = invoiceItem.CtAccountNo;
+        itemLedger.Currency = invoiceItem.Currency;
+        itemLedger.CreditAmount = invoiceItem.Amount;
+        itemLedger.Date = transactionDate;
+        itemLedger.Name = invoiceItem.Name;
+      }
+
+      this.postJournal(dbTransaction, journalEntry);
+
+      const payload = {
+        Action: 'Create',
+        Activity: 'Issuing a Debit Note',
+        Description: `Debit Transaction (ID: ${debitTransaction.TransactionId}) has been created`,
+        EntityType: 'DebitTransaction',
+        EntityValueBefore: JSON.stringify({}),
+        EntityValueAfter: JSON.stringify(debitTransaction),
+        PerformedById: 'test',
+        PerformedAt: new Date(),
+        EntityId: debitTransaction.TransactionId,
+      };
+
+      await axios.post(
+        `${process.env.COMMON_API_URL}/activity-histories`,
+        payload,
+      );
+
+      return invoice;
+    } catch (err) {
+      // tslint:disable-next-line:no-console
+      console.log('Issue debit note err: ', err);
+      throw err;
+    }
+  }
+
+  /**
+   * Issue a credit note
+   *
+   * @param dbTransaction - The database transaction to be used
+   * @param loginUser - The user issuing the credit note
+   * @param creditNote - The document containing the credit note details
+   * @param customer - The customer to be issued the credit note
+   * @param ctAccountNo - The account number of the Account Payable (AP) account to debit. If not provided, will debit the customer's default AR account
+   *
+   * @returns {Document} - Document object representing the full details of the invoice issued
+   */
+  async issueCreditNote(
+    dbTransaction: any,
+    loginUser: LoginUserBase,
+    creditNote: Document,
+    customer: FinanceCustomerBase,
+    ctAccountNo?: string,
+  ): Promise<Document> {
+    try {
+      /*Check if the invoice number already exists (should be unique)*/
+      const duplicateCreditNote =
+        await FinanceCompany._DocumentRepository.findOne({
+          where: {
+            DocNo: creditNote.DocNo,
+          },
+          transaction: dbTransaction,
+        });
+
+      if (duplicateCreditNote) {
+        throw new Error('Invoice number already exists');
+      }
+
+      const documentItems = await creditNote.DocumentItems;
+
+      /*Check if the document has at least 1 document item*/
+      if (!documentItems.length) {
+        throw new Error('Document must have at least 1 document item');
+      }
+
+      /*Check if each document item has CtAccountNo provided*/
+      for (const invoiceItem of documentItems) {
+        if (!invoiceItem.CtAccountNo) {
+          throw new Error(
+            'Each document item should have CtAccountNo provided',
+          );
+        }
+      }
+
+      /*Set up the document type*/
+      creditNote.DocType = DocType.DEBIT_NOTE;
+
+      /*Saving the document and document items to the database*/
+      await FinanceCompany._DocumentRepository.create(
+        {
+          DocNo: creditNote.DocNo,
+          DocType: creditNote.DocType,
+          DocDate: creditNote.DocDate,
+          CompanyId: creditNote.CompanyId,
+          Currency: creditNote.Currency,
+          Amount: creditNote.Amount,
+          Description: creditNote.Description,
+          Status: creditNote.Status,
+          IssuedById: loginUser.ObjectId,
+          IssuedToId: customer.ObjectId,
+          IssuedToType: creditNote.IssuedToType,
+          CreatedById: loginUser.ObjectId,
+          CreatedAt: new Date(),
+          UpdatedById: loginUser.ObjectId,
+          UpdatedAt: new Date(),
+          DocPDFFileMediaId: creditNote.DocPDFFileMediaId,
+          DocHTMLFileMediaId: creditNote.DocHTMLFileMediaId,
+          AccSystemRefId: creditNote.AccSystemRefId,
+          PostedToAccSystemYN: creditNote.PostedToAccSystemYN,
+          PostedById: creditNote.PostedById,
+          PostedDateTime: new Date(),
+          UseAccSystemDocYN: creditNote.UseAccSystemDocYN,
+        },
+        {
+          transaction: dbTransaction,
+        },
+      );
+
+      documentItems.forEach(async (documentItem) => {
+        await FinanceCompany._DocumentItemRepository.create(
+          {
+            DocumentItemId: documentItem.DocumentItemId,
+            DocNo: documentItem.DocNo,
+            Name: documentItem.Name,
+            NameBM: documentItem.NameBM,
+            Description: documentItem.Description,
+            ItemId: documentItem.ItemId,
+            ItemType: documentItem.ItemType,
+            ItemSKU: documentItem.ItemSKU,
+            ItemSerialNo: documentItem.ItemSerialNo,
+            Currency: documentItem.Currency,
+            UnitPrice: documentItem.UnitPrice,
+            Quantity: documentItem.Quantity,
+            QuantityUOM: documentItem.QuantityUOM,
+            Amount: documentItem.Amount,
+            TaxCode: documentItem.TaxCode,
+            TaxAmount: documentItem.TaxAmount,
+            TaxRate: documentItem.TaxRate,
+            TaxInclusiveYN: documentItem.TaxInclusiveYN,
+            DtAccountNo: documentItem.DtAccountNo,
+            CtAccountNo: documentItem.CtAccountNo,
+          },
+          {
+            transaction: dbTransaction,
+          },
+        );
+      });
+
+      /*Generating the credit note*/
+      if (creditNote.UseAccSystemDocYN === 'Y') {
+        /*todo: Posting to accounting system to generate creditNote*/
+        await this.AccountingSystem.createCreditNote(creditNote);
+      } else {
+        /*todo: check config file to see which invoice template is to be used for specific project*/
+
+        /*Generating credit note based on template*/
+        creditNote.generateCreditNote(loginUser.IDNo, customer);
+      }
+
+      const journalEntry = new JournalEntry(dbTransaction);
+      const transactionDate = new Date();
+
+      const creditTransaction = await journalEntry.newLedgerTransaction(
+        TransactionTypeOptions.CREDIT,
+      );
+
+      if (ctAccountNo) {
+        /*Transacting using AR account provided*/
+        creditTransaction.AccountNo = ctAccountNo;
+      } else {
+        /*Transacting based on default customer AR account*/
+        creditTransaction.AccountNo = customer.CustSystemCode + '-AP';
+      }
+
+      creditTransaction.Currency = creditNote.Currency;
+      creditTransaction.CreditAmount = creditNote.Amount;
+      creditTransaction.Date = transactionDate;
+      creditTransaction.Name = creditNote.DocNo;
+
+      for (const invoiceItem of documentItems) {
+        const itemLedger = await journalEntry.newLedgerTransaction(
+          TransactionTypeOptions.DEBIT,
+        );
+        itemLedger.AccountNo = invoiceItem.CtAccountNo;
+        itemLedger.Currency = invoiceItem.Currency;
+        itemLedger.DebitAmount = invoiceItem.Amount;
+        itemLedger.Date = transactionDate;
+        itemLedger.Name = invoiceItem.Name;
+      }
+
+      this.postJournal(dbTransaction, journalEntry);
+
+      const payload = {
+        Action: 'Create',
+        Activity: 'Issuing a Credit Note Transaction',
+        Description: `Credit Transaction (ID: ${creditTransaction.TransactionId}) has been created`,
+        EntityType: 'CreditTransaction',
+        EntityValueBefore: JSON.stringify({}),
+        EntityValueAfter: JSON.stringify(creditTransaction),
+        PerformedById: 'test',
+        PerformedAt: transactionDate,
+        EntityId: creditTransaction.TransactionId,
+      };
+
+      await axios.post(
+        `${process.env.COMMON_API_URL}/activity-histories`,
+        payload,
+      );
+
+      return creditNote;
+    } catch (err) {
+      // tslint:disable-next-line:no-console
+      console.log('Issue credit note err: ', err);
+      throw err;
+    }
+  }
+
+  /**
+   * Register a payment collected
+   *
+   * @param dbTransaction - The database transaction to be used
+   * @param loginUser - The user collecting the payment
+   * @param payment - The payment object containing payment details
+   * @param customer - The customer making the payment
+   * @param ctAccountNo - The customer's Account Receivable (AR) account to credit
+   *
+   * @returns {Payment} - Payment object representing the full detals of the payment collection recorded
+   */
+  async collectPayment(
+    dbTransaction: any,
+    loginUser: LoginUserBase,
+    payment: Payment,
+    customer: FinanceCustomerBase,
+    ctAccountNo?: string,
+  ): Promise<Payment> {
+    let paymentMethodType: PaymentMethodType;
+    try {
+      paymentMethodType = new PaymentMethodType(
+        dbTransaction,
+        payment.MethodTypeId,
+      );
+
+      const paymentItems = await payment.PaymentItems;
+      if (paymentItems.length < 1) {
+        throw new Error(
+          'Atleast one payment item is required to identify what payment is being paid for',
+        );
+      }
+
+      payment.PaymentId = cuid();
+
+      await FinanceCompany._PaymentRepository.create(
+        {
+          PaymentId: payment.PaymentId,
+          PaymentType: payment.PaymentType,
+          PaymentDate: payment.PaymentDate,
+          CompanyId: this.CompanyId,
+          MethodTypeId: payment.MethodTypeId,
+          Currency: payment.Currency,
+          Amount: payment.Amount,
+          Status: PaymentStatus.SUCCESSFUL,
+          TransactionId: payment.TransactionId,
+          TransactionApprovalCode: payment.TransactionApprovalCode,
+          TransactionAccountName: payment.TransactionAccountName,
+          TransactionAccountNo: payment.TransactionAccountNo,
+          ReceivedBy: payment.ReceivedBy,
+          PostedToAccSystemYN: 'N',
+          UpdatedAt: new Date(),
+          UpdatedBy: loginUser.ObjectId,
+          CreatedAt: new Date(),
+          CreatedBy: loginUser.ObjectId,
+        },
+        { transaction: dbTransaction },
+      );
+
+      paymentItems.forEach(async (paymentItem) => {
+        await FinanceCompany._PaymentItemRepository.create(
+          {
+            PaymentId: payment.PaymentId,
+            PayForObjectId: paymentItem.PayForObjectId,
+            PayForObjectType: paymentItem.PayForObjectType,
+            Currency: paymentItem.Currency,
+            Amount: paymentItem.Amount,
+          },
+          { transaction: dbTransaction },
+        );
+      });
+
+      const journalEntry = new JournalEntry(dbTransaction);
+      //Temporary fix to successfully save journal entry in PostJournal
+      journalEntry.init({
+        CompanyId: this.CompanyId,
+        Name: 'Collect-payments for ' + payment.PaymentId,
+      });
+      const transactionDate = new Date();
+
+      const debitLT = await journalEntry.newLedgerTransaction(
+        TransactionTypeOptions.DEBIT,
+      );
+      debitLT.AccountNo = paymentMethodType.AccountNo;
+      debitLT.Currency = payment.Currency;
+      debitLT.DebitAmount = payment.Amount;
+      debitLT.Date = transactionDate;
+      debitLT.Name = customer.FullName;
+
+      const creditLT = await journalEntry.newLedgerTransaction(
+        TransactionTypeOptions.CREDIT,
+      );
+
+      if (ctAccountNo) {
+        creditLT.AccountNo = ctAccountNo;
+      } else {
+        // const config = getConfig();
+        creditLT.AccountNo = customer.CustSystemCode + '-AR';
+      }
+      creditLT.Currency = payment.Currency;
+      creditLT.CreditAmount = payment.Amount;
+      creditLT.Date = transactionDate;
+      creditLT.Name = paymentMethodType.Name;
+
+      await this.postJournal(dbTransaction, journalEntry);
+
+      /*todo: saving a record into the activity history table*/
+
+      return payment;
+    } catch (error) {
+      if (error instanceof RecordNotFoundError) {
+        throw new Error('Invalid PaymentMethodType id');
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  get PaymentMethods() {
+    if (this._PaymentMethods === null || this._PaymentMethods.length === 0) {
+      this.LoadPaymentMethods();
+    }
+    return this._PaymentMethods;
+  }
+
+  /**
+   * Method to load / reload the payment methods based on the configuration file
+   */
+  async LoadPaymentMethods(): Promise<void> {
+    /*Retrieve the payment method from the config file */
+    const { companyId, paymentMethods } = config.systemConfig['EZC'];
+    const paymentMethod = new PaymentMethod();
+
+    for (const method in paymentMethods) {
+      const paymentMethodData =
+        await FinanceCompany._PaymentMethodRepository.findOne({
+          where: {
+            MethodId: paymentMethods[method].id,
+            Name: paymentMethods[method].name,
+          },
+        });
+
+      if (!paymentMethodData) {
+        const newPaymentMethod =
+          await FinanceCompany._PaymentMethodRepository.create({
+            MethodId: paymentMethods[method].id,
+            Name: paymentMethods[method].name,
+            CompanyId: companyId,
+          });
+
+        await this._PaymentMethods.push(newPaymentMethod);
+      }
+
+      await this._PaymentMethods.push(paymentMethodData);
+
+      this._PaymentMethods.forEach(async (paymentMethodData) => {
+        const paymentMethodTypeData =
+          await FinanceCompany._PaymentMethodTypeRepository.findOne({
+            where: {
+              MethodId: paymentMethodData.MethodId,
+            },
+          });
+
+        if (!paymentMethodTypeData) {
+          const configPaymentMethodTypes = paymentMethods[method]?.types;
+
+          for (const methodType in configPaymentMethodTypes) {
+            const paymentMethodTypePayload = {
+              MethodId: paymentMethodTypeData.MethodId,
+              MethodTypeId: configPaymentMethodTypes[methodType].id,
+              Name: configPaymentMethodTypes[methodType].name,
+            };
+
+            await paymentMethod.newPaymentMethodType(paymentMethodTypePayload);
+          }
+        }
+      });
+    }
+  }
+}