@tomei/finance 0.6.112 → 0.8.0

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

@@ -1,2434 +0,0 @@
-import axios from 'axios';
-import {
-  ClassError,
-  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,
-  DocumentStatus,
-  PaymentStatus,
-  PaymentType,
-  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';
-import { AccountRepository } from '../account/account.repository';
-import { PaymentPaidWithRepository } from '../payment-paid-with/payment-paid-with.repository';
-import { MediasModel } from '@tomei/media';
-import DocumentItem from '../document/document-item';
-import { type } from '../helpers/typeof';
-import { LoginUser } from '@tomei/sso';
-import { ActionEnum, Activity } from '@tomei/activity-history';
-import { ApplicationConfig, ComponentConfig } from '@tomei/config';
-import { TaxRepository } from '../tax/tax.repository';
-import { Tax } from '../tax/tax';
-import { CollectPaymentType } from '../enum/collect-payment-type';
-import FinanceCustomerModel from 'src/models/customer.entity';
-
-export default class FinanceCompany extends ObjectBase {
-  private _CompanyId = 'New';
-  private _CompSystemCode = '';
-  private _CompSystemRefId = '';
-  private _AccSystemCode = 'REF';
-  private _AccSystemRefId = 'REF';
-  private _PostedToAccSystemYN = 'N';
-  private _PostedById = null;
-  private _PostedDateTime = null;
-  private _ObjectType = 'FinanceCompany';
-
-  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 _PaymentPaidWithRepository = new PaymentPaidWithRepository();
-  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 static _AccountRepository = new AccountRepository();
-  private static _TaxRepository = new TaxRepository();
-
-  private _AccountingSystem: IAccountSystem;
-
-  private _DbTransaction: any;
-  private _PaymentMethods = [];
-  private _Taxes: Tax[] = [];
-
-  get ObjectType() {
-    return this._ObjectType;
-  }
-
-  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;
-  }
-
-  get AccSystemRefId() {
-    return this._AccSystemRefId;
-  }
-
-  set AccSystemRefId(id: string) {
-    this._AccSystemRefId = id;
-  }
-
-  get PostedToAccSystemYN() {
-    return this._PostedToAccSystemYN;
-  }
-
-  set PostedToAccSystemYN(value: string) {
-    this._PostedToAccSystemYN = value;
-  }
-
-  get PostedById() {
-    return this._PostedById;
-  }
-
-  set PostedById(id: string) {
-    this._PostedById = id;
-  }
-
-  get PostedDateTime() {
-    return this._PostedDateTime;
-  }
-
-  set PostedDateTime(date: any) {
-    this._PostedDateTime = date;
-  }
-
-  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 || 'REF';
-
-    this.AccSystemRefId = 'REF';
-    this.PostedToAccSystemYN = 'N';
-  }
-
-  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,
-    companyId: string,
-    compSystemCode: string,
-    compSystemRefId: string,
-    accSystemCode: string,
-    accSystemRefId?: string,
-    postedToAccSystemYN?: 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 = companyId;
-    financeCompany.PostedById = loginUser?.ObjectId || null;
-    financeCompany.PostedDateTime = new Date();
-
-    if (postedToAccSystemYN === 'Y' && !financeCompany.PostedById) {
-      throw Error(
-        'Cannot post to the accounting system because no user is specified.',
-      );
-    }
-
-    /*Save the FinanceCompany to the finance_Company table*/
-    await FinanceCompany._financeCompanyRepository.create(
-      {
-        CompanyId: financeCompany.CompanyId,
-        CompSystemCode: financeCompany.CompSystemCode,
-        CompSystemRefId: financeCompany.CompSystemRefId,
-        AccSystemCode: financeCompany.AccSystemCode,
-        AccSystemRefId:
-          postedToAccSystemYN === 'Y'
-            ? accSystemRefId
-            : financeCompany.AccSystemRefId,
-        PostedToAccSystemYN:
-          postedToAccSystemYN || financeCompany.PostedToAccSystemYN,
-        PostedById:
-          postedToAccSystemYN === 'Y' ? financeCompany.PostedById : null,
-        PostedDateTime:
-          postedToAccSystemYN === 'Y' ? financeCompany.PostedDateTime : null,
-      },
-      {
-        transaction: dbTransaction,
-      },
-    );
-
-    /*Add the details to 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 findAccount(
-    loginUser: LoginUserBase,
-    dbTransaction: any,
-    accountNo: string,
-  ): Promise<Account> {
-    try {
-      //Part 1: Privilege Check
-      //Check if the user has the privilege to view the account
-      const systemCode =
-        ApplicationConfig.getComponentConfigValue('system-code');
-      const isPrivileged = await loginUser.checkPrivileges(
-        systemCode,
-        'FINANCECOMPANY_VIEW_ACCOUNT',
-      );
-
-      //If the user is not privileged, throw an error
-      if (!isPrivileged) {
-        throw new ClassError(
-          'FinanceCompany',
-          'findAccountErrMsg0X',
-          'User not privileged to view finance company account',
-        );
-      }
-
-      //Part 2: Find Account
-      //Find the account using the accountNo
-      const record = await FinanceCompany._AccountRepository.findOne({
-        where: {
-          AccountNo: accountNo,
-        },
-        transaction: dbTransaction,
-      });
-
-      if (record) {
-        const account = new Account(dbTransaction);
-        account.init(record.get({ plain: true }));
-        return account;
-      }
-      return undefined;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  async createCustomer<T extends FinanceCustomerBase>(
-    dbTransaction: any,
-    custSystemCode: string,
-    custSystemRefId: string,
-    customer: T,
-    loginUser: LoginUser,
-  ) {
-    try {
-      if (!custSystemCode || !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.');
-      }
-
-      let AccCustomerRefId = 'REF';
-      if (this.AccountingSystem) {
-        AccCustomerRefId = await this.AccountingSystem.createCustomer(
-          customer,
-          dbTransaction,
-        );
-      }
-
-      customer.CompanyId = this._CompanyId;
-
-      const newCustomer = await customer.save(
-        AccCustomerRefId,
-        custSystemCode,
-        custSystemRefId,
-        dbTransaction,
-      );
-
-      const activity = new Activity();
-      activity.ActivityId = this._createId().toUpperCase();
-      activity.Action = ActionEnum.CREATE;
-      activity.Description = 'Add Finance Customer';
-      activity.EntityType = 'FinanceCustomer';
-      activity.EntityId = newCustomer.CustomerId;
-      activity.EntityValueBefore = JSON.stringify({});
-      activity.EntityValueAfter = JSON.stringify(newCustomer);
-
-      await activity.create(loginUser.ObjectId, dbTransaction);
-
-      return customer;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  async postJournal(
-    dbTransaction: any,
-    journalEntry: JournalEntry,
-    loginUser: LoginUserBase,
-  ) {
-    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',
-        );
-      }
-
-      let totalCreditAmount = creditTransactions.reduce(
-        (accumulator, currentValue) => accumulator + currentValue.CreditAmount,
-        0,
-      );
-      let totalDebitAmount = debitTransactions.reduce(
-        (accumulator, currentValue) => accumulator + currentValue.DebitAmount,
-        0,
-      );
-      console.log('totalCreditAmount: ', totalCreditAmount);
-      console.log('totalDebitAmount: ', totalDebitAmount);
-
-      if (typeof totalCreditAmount === 'string') {
-        totalCreditAmount = parseFloat(totalCreditAmount);
-      }
-
-      if (typeof totalDebitAmount === 'string') {
-        totalDebitAmount = parseFloat(totalDebitAmount);
-      }
-      if (totalCreditAmount.toFixed(2) !== totalDebitAmount.toFixed(2)) {
-        throw new Error(
-          'Credit ledger transaction and debit ledger transaction should the same amount',
-        );
-      }
-
-      const newJournalEntry = await journalEntry.save(
-        loginUser.ObjectId,
-        dbTransaction,
-      );
-
-      for (const ledgerTransaction of debitTransactions) {
-        ledgerTransaction.JournalEntryId = newJournalEntry.JournalEntryId;
-
-        await ledgerTransaction.save(dbTransaction);
-        // const dt = await ledgerTransaction.newLedgerTransaction(
-        //   TransactionTypeOptions.DEBIT,
-        //   newJournalEntry.JournalEntryId,
-        // );
-        // await dt.save();
-      }
-
-      for (const ledgerTransaction of creditTransactions) {
-        ledgerTransaction.JournalEntryId = newJournalEntry.JournalEntryId;
-
-        await ledgerTransaction.save(dbTransaction);
-        // const ct = await ledgerTransaction.newLedgerTransaction(
-        //   TransactionTypeOptions.CREDIT,
-        //   newJournalEntry.JournalEntryId,
-        // );
-        // await ct.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: loginUser.ObjectId,
-        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,
-    loginUser: LoginUserBase,
-  ) {
-    try {
-      let accSystemRefId: string;
-
-      if (!account.AccountType) {
-        throw new Error('AccountType is required.');
-      }
-
-      // Retrieve & validate accountNoLength from finance config file
-      const accountNoLength = ComponentConfig.getComponentConfigValue(
-        '@tomei/finance',
-        'accountNoLength',
-      );
-
-      if (accountNoLength && account.AccountNo.length > accountNoLength) {
-        throw new Error(
-          `Account No length should not exceed ${accountNoLength} characters.`,
-        );
-      }
-
-      let createAccountPayload: any = {
-        Name: account.Name,
-        AcctNum: account.AccountNo,
-        AccountType: account.AccountType,
-        AccountSubType: account.AccountSubtype,
-      };
-
-      if (this.AccountingSystem) {
-        accSystemRefId = await this.AccountingSystem.createAccount(
-          account,
-          dbTransaction,
-        );
-      }
-
-      if (account.isParentAccountExists()) {
-        createAccountPayload = {
-          ...createAccountPayload,
-          CurrencyRef: 'MYR',
-          ParentRef: account.ParentAccountNo,
-          SubAccount: true,
-        };
-      }
-
-      console.log(
-        'Finance Company Create Account: Before accSystemAccountId Create',
-      );
-
-      console.log(
-        'Finance Company Create Account: After accSystemAccountId Create',
-      );
-
-      console.log('Finance Company Create Account: Before new Account Create');
-
-      if (account.AccSystemRefId) {
-        account.PostedToAccSystemYN = 'Y';
-        account.PostedById = loginUser.ObjectId;
-        account.PostedDateTime = new Date();
-      }
-
-      const newAccount = await account.save(
-        this.CompanyId,
-        account.AccSystemRefId || 'REF',
-        loginUser.ObjectId,
-        dbTransaction,
-      );
-
-      console.log('Finance Company Create Account: After new Account Create');
-
-      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: loginUser.ObjectId,
-        PerformedAt: new Date(),
-        EntityId: newAccount.AccountNo,
-      };
-
-      await axios.post(
-        `${process.env.COMMON_API_URL}/activity-histories`,
-        payload,
-      );
-
-      return newAccount;
-    } 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<C extends FinanceCustomerBase>(
-    /*todo: loginUser & customer is NOT supposed to be optional */
-    dbTransaction: any,
-    invoice: Document,
-    loginUser?: LoginUserBase,
-    customer?: C,
-    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.getDocumentItems(dbTransaction);
-
-      /*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;
-
-      /*Generating the invoice*/
-      let invoiceMedia: {
-        HTMLMedia: MediasModel;
-        PDFMedia: MediasModel;
-      };
-
-      if (invoice.UseAccSystemDocYN === 'Y') {
-        /*todo: Posting to accounting system to generate invoice*/
-        const accInvoiceRefIdDetail = await this.AccountingSystem.createInvoice(
-          {
-            customer,
-            invoice,
-            paymentMode: 'credit',
-          },
-          dbTransaction,
-        );
-        invoice.DocNo = accInvoiceRefIdDetail.invoiceNo;
-        invoice.AccSystemRefId = accInvoiceRefIdDetail.invoiceRefId;
-        invoice.PostedToAccSystemYN = 'Y';
-        invoice.PostedById = loginUser.ObjectId;
-        invoice.PostedDateTime = new Date();
-
-        //for each document item, insert the  document item accounting reference id that have matching name
-        for (const documentItem of documentItems) {
-          const accItem = accInvoiceRefIdDetail.invoiceItems.find(
-            (item) => item.name === documentItem.Name,
-          );
-          if (accItem) {
-            documentItem.DocNo = accInvoiceRefIdDetail.invoiceNo;
-            documentItem.AccSystemRefId = accItem.itemRefId;
-            documentItem.PostedToAccSystemYN = 'Y';
-            documentItem.PostedById = loginUser.ObjectId;
-            documentItem.PostedDateTime = new Date();
-          }
-        }
-      } else {
-        /*todo: check config file to see which invoice template is to be used for specific project*/
-
-        /*Generating invoice based on template*/
-        invoiceMedia = await invoice.generateInvoice(
-          invoice.IssuedById,
-          customer,
-          dbTransaction,
-        );
-      }
-
-      /*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,
-          RelatedObjectId: invoice.RelatedObjectId,
-          RelatedObjectType: invoice.RelatedObjectType,
-          CreatedById: invoice.CreatedById,
-          CreatedAt: new Date(),
-          UpdatedById: invoice.UpdatedById,
-          UpdatedAt: new Date(),
-          DocPDFFileMediaId:
-            invoice.UseAccSystemDocYN == 'N'
-              ? invoiceMedia.PDFMedia.MediaId
-              : null,
-          DocHTMLFileMediaId:
-            invoice.UseAccSystemDocYN == 'N'
-              ? invoiceMedia.HTMLMedia.MediaId
-              : null,
-          AccSystemRefId: invoice.AccSystemRefId,
-          PostedToAccSystemYN: invoice.PostedToAccSystemYN,
-          PostedById:
-            invoice.UseAccSystemDocYN == 'Y' ? invoice.PostedById : null,
-          PostedDateTime: new Date(),
-          UseAccSystemDocYN: invoice.UseAccSystemDocYN,
-        },
-        {
-          transaction: dbTransaction,
-        },
-      );
-
-      for (const documentItem of documentItems) {
-        await FinanceCompany._DocumentItemRepository.create(
-          {
-            DocumentItemId: this._createId().toUpperCase(),
-            DocNo: invoice.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
-              ? documentItem.DtAccountNo
-              : null,
-            CtAccountNo: documentItem.CtAccountNo
-              ? documentItem.CtAccountNo
-              : null,
-            AccSystemRefId: documentItem.AccSystemRefId,
-            PostedToAccSystemYN: documentItem.PostedToAccSystemYN,
-            PostedById: documentItem.PostedById,
-            PostedDateTime: documentItem.PostedDateTime,
-          },
-          {
-            transaction: dbTransaction,
-          },
-        );
-      }
-
-      const transactionDate = new Date();
-      const htCreditAccountAmount = new HashTable();
-      const htCreditAccountCurrency = new HashTable();
-      const htCreditAccountPurpose = new HashTable();
-
-      documentItems.forEach((invoiceItem) => {
-        if (!htCreditAccountAmount.exists(invoiceItem.CtAccountNo)) {
-          //add the credit account to the hash table
-          htCreditAccountAmount.add(
-            invoiceItem.CtAccountNo,
-            invoiceItem.Amount,
-          );
-
-          htCreditAccountCurrency.add(
-            invoiceItem.CtAccountNo,
-            invoiceItem.Currency,
-          );
-
-          htCreditAccountPurpose.add(invoiceItem.CtAccountNo, invoiceItem.Name);
-        } else {
-          //update the credit account amount
-          const d = htCreditAccountAmount.get(invoiceItem.CtAccountNo);
-          htCreditAccountAmount.add(
-            invoiceItem.CtAccountNo,
-            d + invoiceItem.Amount,
-          );
-        }
-      });
-
-      const savedItems = htCreditAccountAmount.list();
-
-      for (const item of savedItems) {
-        const journalEntry = new JournalEntry(dbTransaction);
-        //Temporary fix to successfully save journal entry in PostJournal
-        journalEntry.init({
-          CompanyId: this.CompanyId,
-          Name: 'Issue Invoice ' + invoice.DocNo,
-        });
-        // const account = await Account.initAccount(dbTransaction, item.value[0]);
-        const creditAmount = item.value[1];
-        const currency = htCreditAccountCurrency.get(item.value[0]);
-        const purpose = htCreditAccountPurpose.get(item.value[0]);
-
-        const dt = await journalEntry.newLedgerTransaction(
-          TransactionTypeOptions.DEBIT,
-        );
-
-        if (dtAccountNo) {
-          /*Transacting using AR account provided*/
-          dt.AccountNo = dtAccountNo;
-        } else {
-          /*Transacting based on default customer AR account*/
-          const arAccount = await customer.getAccountReceivable();
-          dt.AccountNo = arAccount.AccountNo;
-        }
-
-        dt.Currency = currency ? currency : 'MYR';
-        dt.DebitAmount = creditAmount ? creditAmount : 0.0;
-        dt.Date = transactionDate;
-        dt.Description = `${purpose}`;
-        dt.Name = `${purpose}`;
-        dt.RelatedDocNo = invoice.DocNo;
-        dt.RelatedObjectId = invoice.RelatedObjectId;
-        dt.RelatedObjectType = invoice.RelatedObjectType;
-
-        const ct = await journalEntry.newLedgerTransaction(
-          TransactionTypeOptions.CREDIT,
-        );
-        ct.AccountNo = item.value[0];
-        ct.Currency = currency ? currency : 'MYR';
-        ct.CreditAmount = creditAmount ? creditAmount : 0.0;
-        ct.Date = transactionDate;
-        ct.Description = customer.FullName;
-        ct.Name = customer.FullName;
-        ct.RelatedDocNo = invoice.DocNo;
-        ct.RelatedObjectId = invoice.RelatedObjectId;
-        ct.RelatedObjectType = invoice.RelatedObjectType;
-
-        await this.postJournal(dbTransaction, journalEntry, loginUser);
-      }
-
-      return invoice;
-    } catch (err) {
-      // tslint:disable-next-line:no-console
-      console.log('Issue invoice err: ', err);
-      throw err;
-    }
-  }
-
-  static async findCustomer(
-    custSystemRefId: string,
-    dbTransaction?: any,
-  ): Promise<FinanceCustomerModel> {
-    const data = await FinanceCompany._FinanceCustomerRepository.findOne({
-      where: {
-        CustSystemRefId: custSystemRefId,
-      },
-      transaction: dbTransaction,
-    });
-
-    return data;
-  }
-
-  /**
-   * 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.getDocumentItems(dbTransaction);
-
-      /*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;
-      // invoice.DocNo = this._createId().toUpperCase();
-
-      /*Generating the invoice*/
-      if (invoice.UseAccSystemDocYN === 'Y') {
-        /*todo: Posting to accounting system to generate invoice*/
-        const accInvoiceRefIDetail = await this.AccountingSystem.createInvoice(
-          {
-            customer,
-            invoice,
-            paymentMode: 'credit',
-          },
-          dbTransaction,
-        );
-        invoice.AccSystemRefId = accInvoiceRefIDetail.invoiceRefId;
-        invoice.PostedToAccSystemYN = 'Y';
-        invoice.PostedById = loginUser.ObjectId;
-        invoice.PostedDateTime = new Date();
-
-        //for each document item, insert the  document item accounting reference id that have matching name
-        for (const documentItem of documentItems) {
-          const accItem = accInvoiceRefIDetail.invoiceItems.find(
-            (item) => item.name === documentItem.Name,
-          );
-          if (accItem) {
-            documentItem.AccSystemRefId = accItem.itemRefId;
-            documentItem.PostedToAccSystemYN = 'Y';
-            documentItem.PostedById = loginUser.ObjectId;
-            documentItem.PostedDateTime = new Date();
-          }
-        }
-      } 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, dbTransaction);
-      }
-
-      /*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,
-          RelatedObjectId: invoice.RelatedObjectId,
-          RelatedObjectType: invoice.RelatedObjectType,
-          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.PostedToAccSystemYN == 'Y' ? invoice.PostedById : null,
-          PostedDateTime: new Date(),
-          UseAccSystemDocYN: invoice.UseAccSystemDocYN,
-        },
-        {
-          transaction: dbTransaction,
-        },
-      );
-
-      documentItems.forEach(async (documentItem) => {
-        await FinanceCompany._DocumentItemRepository.create(
-          {
-            DocumentItemId: this._createId().toUpperCase(),
-            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,
-            AccSystemRefId: documentItem.AccSystemRefId,
-            PostedToAccSystemYN: documentItem.PostedToAccSystemYN,
-            PostedById: documentItem.PostedById,
-            PostedDateTime: documentItem.PostedDateTime,
-          },
-          {
-            transaction: dbTransaction,
-          },
-        );
-      });
-
-      const transactionDate = new Date();
-      const htCreditAccountAmount = new HashTable();
-      const htCreditAccountCurrency = new HashTable();
-      const htCreditAccountPurpose = new HashTable();
-
-      documentItems.forEach((invoiceItem) => {
-        if (!htCreditAccountAmount.exists(invoiceItem.CtAccountNo)) {
-          //add the credit account to the hash table
-          htCreditAccountAmount.add(
-            invoiceItem.CtAccountNo,
-            invoiceItem.Amount,
-          );
-
-          htCreditAccountCurrency.add(
-            invoiceItem.CtAccountNo,
-            invoiceItem.Currency,
-          );
-
-          htCreditAccountPurpose.add(invoiceItem.CtAccountNo, invoiceItem.Name);
-        } else {
-          //update the credit account amount
-          const d = htCreditAccountAmount.get(invoiceItem.CtAccountNo);
-          htCreditAccountAmount.add(
-            invoiceItem.CtAccountNo,
-            d + invoiceItem.Amount,
-          );
-        }
-      });
-
-      const savedItems = htCreditAccountAmount.list();
-
-      for (const item of savedItems) {
-        const journalEntry = new JournalEntry(dbTransaction);
-        //Temporary fix to successfully save journal entry in PostJournal
-        journalEntry.init({
-          CompanyId: this.CompanyId,
-          Name: 'issue Invoice ' + invoice.DocNo,
-        });
-        // const account = await Account.initAccount(dbTransaction, item.value[0]);
-        const creditAmount = item.value[1];
-        const currency = htCreditAccountCurrency.get(item.value[0]);
-        const purpose = htCreditAccountPurpose.get(item.value[0]);
-
-        const dt = await journalEntry.newLedgerTransaction(
-          TransactionTypeOptions.DEBIT,
-        );
-
-        if (dtAccountNo) {
-          /*Transacting using AR account provided*/
-          dt.AccountNo = dtAccountNo;
-        } else {
-          /*Transacting based on default customer AR account*/
-          const arAccount = await customer.getAccountReceivable();
-          dt.AccountNo = arAccount.AccountNo;
-        }
-
-        dt.Currency = currency ? currency : 'MYR';
-        dt.DebitAmount = creditAmount ? creditAmount : 0.0;
-        dt.Date = transactionDate;
-        dt.Description = `${purpose}`;
-        dt.Name = `${purpose}`;
-        dt.RelatedDocNo = invoice.DocNo;
-        dt.RelatedObjectId = invoice.RelatedObjectId;
-        dt.RelatedObjectType = invoice.RelatedObjectType;
-
-        const ct = await journalEntry.newLedgerTransaction(
-          TransactionTypeOptions.CREDIT,
-        );
-        ct.AccountNo = item.value[0];
-        ct.Currency = currency ? currency : 'MYR';
-        ct.CreditAmount = creditAmount ? creditAmount : 0.0;
-        ct.Date = transactionDate;
-        ct.Description = customer.FullName;
-        ct.Name = customer.FullName;
-        ct.RelatedDocNo = invoice.DocNo;
-        ct.RelatedObjectId = invoice.RelatedObjectId;
-        ct.RelatedObjectType = invoice.RelatedObjectType;
-
-        await this.postJournal(dbTransaction, journalEntry, loginUser);
-      }
-
-      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.getDocumentItems(dbTransaction);
-
-      /*Check if the document has at least 1 document item*/
-      if (!documentItems.length) {
-        throw new Error('Document must have at least 1 document item');
-      }
-
-      //Map each creditNote.DocumentItems and do checking below:
-      //1. Set actualDocument to the instantiation of existing Document. (to check valid Document)
-      //2. Check for each actualDocument to make sure IssuedToId all the same. If not, throw ClassError.
-      //3. Check if each document item has DtAccountNo provided
-      for (const invoiceItem of documentItems) {
-        if (!invoiceItem.DtAccountNo) {
-          throw new Error(
-            'Each document item should have DtAccountNo provided',
-          );
-        }
-
-        const actualDocument = await Document.initDocument(
-          dbTransaction,
-          invoiceItem.ItemId,
-        );
-
-        if (actualDocument.IssuedToId !== creditNote.IssuedToId) {
-          throw new ClassError(
-            'FinanceCompany',
-            'FinanceCompanyErrMsgOX',
-            'To issue credit note, all invoices must belong to same customer.',
-          );
-        }
-      }
-
-      /*Set up the document type*/
-      creditNote.DocType = DocType.CREDIT_NOTE;
-      creditNote.Status = DocumentStatus.SETTLED;
-
-      /*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,
-          RelatedObjectId: creditNote.RelatedObjectId,
-          RelatedObjectType: creditNote.RelatedObjectType,
-          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.PostedToAccSystemYN == 'Y'
-              ? creditNote.PostedById
-              : null,
-          PostedDateTime: new Date(),
-          UseAccSystemDocYN: creditNote.UseAccSystemDocYN,
-        },
-        {
-          transaction: dbTransaction,
-        },
-      );
-
-      for (const docItem of documentItems) {
-        await FinanceCompany._DocumentItemRepository.create(
-          {
-            DocumentItemId: this._createId().toUpperCase(),
-            DocNo: docItem.DocNo,
-            Name: docItem.Name,
-            NameBM: docItem.NameBM,
-            Description: docItem.Description,
-            ItemId: docItem.ItemId,
-            ItemType: docItem.ItemType,
-            ItemSKU: docItem.ItemSKU,
-            ItemSerialNo: docItem.ItemSerialNo,
-            Currency: docItem.Currency,
-            UnitPrice: docItem.UnitPrice,
-            Quantity: docItem.Quantity,
-            QuantityUOM: docItem.QuantityUOM,
-            Amount: docItem.Amount,
-            TaxCode: docItem.TaxCode,
-            TaxAmount: docItem.TaxAmount,
-            TaxRate: docItem.TaxRate,
-            TaxInclusiveYN: docItem.TaxInclusiveYN,
-            DtAccountNo: docItem.DtAccountNo ? docItem.DtAccountNo : null,
-            CtAccountNo: docItem.CtAccountNo ? docItem.CtAccountNo : null,
-          },
-          {
-            transaction: dbTransaction,
-          },
-        );
-
-        //Call Document.settleByCreditNote to settle the invoice
-        await Document.settleByCreditNote(
-          loginUser,
-          dbTransaction,
-          docItem.ItemId,
-          docItem.Amount,
-        );
-      }
-
-      /*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);
-      //Temporary fix to successfully save journal entry in PostJournal
-      journalEntry.init({
-        CompanyId: this.CompanyId,
-        Name: 'Issue Credit Note ' + creditNote.DocNo,
-      });
-
-      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';
-        // getAccountPayable
-        const arAccount = await customer.getAccountPayable();
-        creditTransaction.AccountNo = arAccount.AccountNo;
-      }
-
-      creditTransaction.Currency = creditNote.Currency;
-      creditTransaction.CreditAmount = creditNote.Amount;
-      creditTransaction.Date = transactionDate;
-      creditTransaction.Description = creditNote.DocNo;
-      creditTransaction.Name = creditNote.DocNo;
-      creditTransaction.RelatedDocNo = creditNote.DocNo;
-      creditTransaction.RelatedObjectId = creditNote.RelatedObjectId;
-      creditTransaction.RelatedObjectType = creditNote.RelatedObjectType;
-
-      for (const invoiceItem of documentItems) {
-        const itemLedger = await journalEntry.newLedgerTransaction(
-          TransactionTypeOptions.DEBIT,
-        );
-        itemLedger.AccountNo = invoiceItem.DtAccountNo;
-        itemLedger.Currency = invoiceItem.Currency;
-        itemLedger.DebitAmount = invoiceItem.Amount;
-        itemLedger.Date = transactionDate;
-        itemLedger.Description = invoiceItem.Name;
-        // itemLedger.Name = invoiceItem.Name;
-        itemLedger.RelatedDocNo = creditNote.DocNo;
-        itemLedger.RelatedObjectId = creditNote.RelatedObjectId;
-        itemLedger.RelatedObjectType = creditNote.RelatedObjectType;
-      }
-
-      await this.postJournal(dbTransaction, journalEntry, loginUser);
-
-      const entityValueAfter = {
-        LedgerNo: creditTransaction.LedgerNo,
-        TransactionType: creditTransaction.TransactionType,
-        JournalEntryId: creditTransaction.JournalEntryId,
-        AccountNo: creditTransaction.AccountNo,
-        Date: creditTransaction.Date,
-        Name: creditTransaction.Name,
-        Description: creditTransaction.Description,
-        Currency: creditTransaction.Currency,
-        DebitAmount: creditTransaction.DebitAmount,
-        CreditAmount: creditTransaction.CreditAmount,
-        RelatedObjectId: creditTransaction.RelatedObjectId,
-        RelatedObjectType: creditTransaction.RelatedObjectType,
-        RelatedDocNo: creditTransaction.RelatedDocNo,
-        RelatedPaymentId: creditTransaction.RelatedPaymentId,
-      };
-      const payload = {
-        Action: 'Create',
-        Activity: 'Issuing a Credit Note Transaction',
-        Description: `Credit Transaction (ID: ${creditTransaction.LedgerNo}) has been created`,
-        EntityType: 'CreditTransaction',
-        EntityValueBefore: JSON.stringify({}),
-        EntityValueAfter: JSON.stringify(entityValueAfter),
-        PerformedById: loginUser.ObjectId,
-        PerformedAt: transactionDate,
-        EntityId: creditTransaction.LedgerNo,
-      };
-
-      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 account number of the customer's Account Receivable account to transact, else the default customer account payable receivable will be used
-   * @param receiptNo - The document receipt number
-   *
-   * @returns {Payment} - Payment object representing the full detals of the payment collection recorded
-   */
-  async collectPayment(
-    dbTransaction: any,
-    loginUser: LoginUserBase,
-    payment: Payment,
-    collectPaymentType: CollectPaymentType = CollectPaymentType.AUTOMATIC,
-  ): Promise<Payment> {
-    try {
-      /*validation 1: Make sure that the payment has at least 1 payment item*/
-      const paymentItems = await payment.getPaymentItems();
-      if (paymentItems.length < 1) {
-        throw new Error(
-          'Atleast one payment item is required to identify what payment is being paid for.',
-        );
-      }
-
-      /*validation 2: Make sure that the payment has at least 1 payment method*/
-      const paymentPaidWithItems = await payment.getPaymentPaidWith();
-      if (paymentPaidWithItems.length < 1) {
-        throw new Error(
-          'Atleast one payment paid with item is required to identify how the payment was made.',
-        );
-      }
-
-      /*Saving payment, payment items, and payment paid with details to the database*/
-      payment.PaymentId = this._createId().toUpperCase();
-      payment.PaymentType = PaymentType.PAYMENT_RECEIVED;
-      payment.ReceivedBy = loginUser.ObjectId;
-      payment.IssuedBy = loginUser.ObjectId;
-
-      await FinanceCompany._PaymentRepository.create(
-        {
-          PaymentId: payment.PaymentId,
-          PaymentType: payment.PaymentType,
-          PaymentDate: payment.PaymentDate,
-          Description: payment.Description,
-          Currency: payment.Currency,
-          Amount: payment.Amount,
-          Status:
-            collectPaymentType === CollectPaymentType.AUTOMATIC
-              ? PaymentStatus.CONFIRMED
-              : PaymentStatus.PENDING,
-          PostedToAccSystemYN: 'N',
-          ReceivedBy: payment.ReceivedBy,
-          IssuedBy: payment.IssuedBy,
-          Remarks: payment.Remarks,
-          RelatedObjectId: payment.RelatedObjectId,
-          RelatedObjectType: payment.RelatedObjectType,
-          ReceiptDocNo: payment.ReceiptDocNo,
-          UpdatedAt: new Date(),
-          UpdatedBy: loginUser.ObjectId,
-          CreatedAt: new Date(),
-          CreatedBy: loginUser.ObjectId,
-        },
-        { transaction: dbTransaction },
-      );
-
-      for (const paymentItem of paymentItems) {
-        await FinanceCompany._PaymentItemRepository.create(
-          {
-            PaymentId: payment.PaymentId,
-            PayForObjectId: paymentItem.PayForObjectId,
-            PayForObjectType: paymentItem.PayForObjectType,
-            Currency: paymentItem.Currency,
-            Amount: paymentItem.Amount,
-            Name: paymentItem.Name,
-            Description: paymentItem.Description,
-          },
-          { transaction: dbTransaction },
-        );
-
-        // await paymentItem.paid(dbTransaction);
-      }
-
-      for (const paymentPaidWithItem of paymentPaidWithItems) {
-        // Validate payment method type used
-        await PaymentMethodType.initMethodType(
-          dbTransaction,
-          paymentPaidWithItem.MethodTypeId,
-        );
-
-        await FinanceCompany._PaymentPaidWithRepository.create(
-          {
-            PaymentId: payment.PaymentId,
-            MethodTypeId: paymentPaidWithItem.MethodTypeId,
-            Currency: paymentPaidWithItem.Currency,
-            Amount: paymentPaidWithItem.Amount,
-            Status: paymentPaidWithItem.Status,
-            TransactionId: paymentPaidWithItem.TransactionId,
-            RefBank: paymentPaidWithItem.RefBank,
-            RefName: paymentPaidWithItem.RefName,
-            RefNo: paymentPaidWithItem.RefNo,
-            RefOther1: paymentPaidWithItem.RefOther1,
-            RefOther2: paymentPaidWithItem.RefOther2,
-            RefOther3: paymentPaidWithItem.RefOther3,
-            RefOther4: paymentPaidWithItem.RefOther4,
-            RefOther5: paymentPaidWithItem.RefOther5,
-            Remarks: paymentPaidWithItem.Remarks,
-            PaymentMediaId: paymentPaidWithItem.PaymentMediaId,
-          },
-          { transaction: dbTransaction },
-        );
-      }
-
-      /*todo: saving a record into the activity history table*/
-
-      return payment;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  /**
-   * Method to make payment to a customer.
-   *
-   * @param dbTransaction - The database transaction to be used
-   * @param loginUser - The user logging in and the user who collected the payment.
-   * @param payment - The payment object containing payment details
-   * @param customer - The customer who is receiving the payment.
-   * @param ctAccountNo - The account number of the customer's Account Payable account to transact, else the default customer account payable will be used.
-   *
-   * @returns {Payment} - Payment object representing the full details of the payment collection recorded
-   */
-  async makePayment(
-    dbTransaction: any,
-    loginUser: LoginUserBase,
-    payment: Payment,
-    customer: FinanceCustomerBase,
-    dtAccountNo?: string,
-  ): Promise<Payment> {
-    let paymentMethodType: PaymentMethodType;
-    try {
-      const paymentPaidWith = await payment.getPaymentPaidWith();
-      if (paymentPaidWith.length < 1) {
-        throw new Error(
-          'Atleast one payment paid with item is required to identify how the payment was made.',
-        );
-      }
-      paymentMethodType = await PaymentMethodType.initMethodType(
-        dbTransaction,
-        paymentPaidWith[0].MethodTypeId,
-      );
-
-      const paymentItems = await payment.getPaymentItems();
-      if (paymentItems.length < 1) {
-        throw new Error(
-          'Atleast one payment item is required to identify what payment is being paid for',
-        );
-      }
-
-      payment.PaymentId = this._createId().toUpperCase();
-      payment.PaymentType = PaymentType.PAYOUT;
-      payment.ReceivedBy = loginUser.ObjectId;
-      payment.IssuedBy = loginUser.ObjectId;
-
-      await FinanceCompany._PaymentRepository.create(
-        {
-          PaymentId: payment.PaymentId,
-          PaymentType: payment.PaymentType,
-          PaymentDate: payment.PaymentDate,
-          Description: payment.Description,
-          Currency: payment.Currency,
-          ReceivedBy: payment.ReceivedBy,
-          IssuedBy: payment.IssuedBy,
-          Remarks: payment.Remarks,
-          RelatedObjectId: payment.RelatedObjectId,
-          RelatedObjectType: payment.RelatedObjectType,
-          Amount: payment.Amount,
-          Status: PaymentStatus.CONFIRMED,
-          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,
-            Name: paymentItem.Name,
-            Description: paymentItem.Description,
-          },
-          { transaction: dbTransaction },
-        );
-
-        await paymentItem.paid(dbTransaction);
-      });
-
-      for (const paymentPaidWithItem of paymentPaidWith) {
-        await FinanceCompany._PaymentPaidWithRepository.create(
-          {
-            PaymentId: payment.PaymentId,
-            MethodTypeId: paymentPaidWithItem.MethodTypeId,
-            Currency: paymentPaidWithItem.Currency,
-            Amount: paymentPaidWithItem.Amount,
-            Status: paymentPaidWithItem.Status,
-            TransactionId: paymentPaidWithItem.TransactionId,
-            RefBank: paymentPaidWithItem.RefBank,
-            RefName: paymentPaidWithItem.RefName,
-            RefNo: paymentPaidWithItem.RefNo,
-            RefOther1: paymentPaidWithItem.RefOther1,
-            RefOther2: paymentPaidWithItem.RefOther2,
-            RefOther3: paymentPaidWithItem.RefOther3,
-            RefOther4: paymentPaidWithItem.RefOther4,
-            RefOther5: paymentPaidWithItem.RefOther5,
-            Remarks: paymentPaidWithItem.Remarks,
-            PaymentMediaId: paymentPaidWithItem.PaymentMediaId,
-          },
-          { transaction: dbTransaction },
-        );
-      }
-      const transactionDate = new Date();
-      for (const paymentPaidWithItem of paymentPaidWith) {
-        try {
-          paymentMethodType = await PaymentMethodType.initMethodType(
-            dbTransaction,
-            paymentPaidWithItem.MethodTypeId,
-          );
-
-          const journalEntry = new JournalEntry(dbTransaction);
-          //Temporary fix to successfully save journal entry in PostJournal
-          journalEntry.init({
-            CompanyId: this.CompanyId,
-            Name: 'Make Payment for ' + payment.PaymentId,
-          });
-
-          const creditLT = await journalEntry.newLedgerTransaction(
-            TransactionTypeOptions.CREDIT,
-          );
-          creditLT.AccountNo = paymentMethodType.AccountNo;
-          creditLT.Currency = paymentPaidWithItem.Currency;
-          creditLT.CreditAmount = paymentPaidWithItem.Amount;
-          creditLT.Date = transactionDate;
-          creditLT.Description = customer.FullName;
-          creditLT.Name = customer.FullName;
-          creditLT.RelatedObjectId = payment.RelatedObjectId;
-          creditLT.RelatedObjectType = payment.RelatedObjectType;
-
-          const debitLT = await journalEntry.newLedgerTransaction(
-            TransactionTypeOptions.DEBIT,
-          );
-          if (dtAccountNo) {
-            debitLT.AccountNo = dtAccountNo;
-          } else {
-            const apAccount = await customer.getAccountPayable();
-            debitLT.AccountNo = apAccount.AccountNo;
-          }
-          debitLT.Currency = paymentPaidWithItem.Currency;
-          debitLT.DebitAmount = paymentPaidWithItem.Amount;
-          debitLT.Date = transactionDate;
-          debitLT.Description = paymentMethodType.Name;
-          debitLT.Name = paymentMethodType.Name;
-          debitLT.RelatedObjectId = payment.RelatedObjectId;
-          debitLT.RelatedObjectType = payment.RelatedObjectType;
-
-          await this.postJournal(dbTransaction, journalEntry, loginUser);
-        } catch (error) {
-          if (error instanceof RecordNotFoundError) {
-            throw new Error('Invalid Payment Method Type Id');
-          } else {
-            throw error;
-          }
-        }
-      }
-      /*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(): Promise<PaymentMethod[]> {
-    return new Promise((resolve, reject) => {
-      if (this.CompanyId !== 'New') {
-        FinanceCompany._PaymentMethodRepository
-          .findAll({
-            where: {
-              CompanyId: this.CompanyId,
-            },
-            // transaction: this._DbTransaction,
-          })
-          .then((paymentMethod) => {
-            const paymentMethodObjects = paymentMethod.map(
-              (paymentMethodData) => {
-                return new Promise((resolve, reject) => {
-                  FinanceCompany._PaymentMethodTypeRepository
-                    .findAll({
-                      where: {
-                        MethodId: paymentMethodData.MethodId,
-                      },
-                      // transaction: this._DbTransaction,
-                      raw: true,
-                    })
-                    .then((paymentMethodTypes) => {
-                      const paymentMethodObjects = {
-                        ...paymentMethodData.get({ plain: true }),
-                        Types: paymentMethodTypes,
-                      };
-                      resolve(paymentMethodObjects);
-                    })
-                    .catch((err) => {
-                      reject(err);
-                    });
-                }).then((paymentMethods) => paymentMethods);
-              },
-            );
-            return Promise.all(paymentMethodObjects);
-          })
-          .then((paymentMethodObjects) => {
-            this._PaymentMethods = paymentMethodObjects;
-            resolve(this._PaymentMethods);
-          })
-          .catch((err) => {
-            reject(err);
-          });
-      } else {
-        resolve(this._PaymentMethods);
-      }
-    });
-  }
-
-  get TaxCodes(): Promise<Tax[]> {
-    return new Promise((resolve, reject) => {
-      if (this.CompanyId !== 'New') {
-        FinanceCompany._TaxRepository
-          .findAll({
-            where: {
-              CompanyId: this.CompanyId,
-            },
-            transaction: this._DbTransaction,
-          })
-          .then((taxes) => {
-            const taxList = [];
-            taxes.forEach((tax) => {
-              taxList.push(
-                new Tax({
-                  TaxCode: tax.TaxCode,
-                  TaxRate:
-                    typeof tax.TaxRate === 'number'
-                      ? tax.TaxRate
-                      : parseFloat(tax.TaxRate),
-                  Description: tax.Description,
-                  CompanyId: tax.CompanyId,
-                  CreatedAt: tax.CreatedAt,
-                  CreatedById: tax.CreatedById,
-                  UpdatedAt: tax.UpdatedAt,
-                  UpdatedById: tax.UpdatedById,
-                }),
-              );
-            });
-            this._Taxes = taxList;
-            resolve(this._Taxes);
-          })
-          .catch((err) => {
-            reject(err);
-          });
-      } else {
-        resolve(this._Taxes);
-      }
-    });
-  }
-
-  /**
-   * Method to load / reload the payment methods based on the configuration file
-   */
-  async LoadPaymentMethods(
-    companyId: string,
-    paymentMethods: any,
-    transaction?: any,
-  ): Promise<void> {
-    const paymentMethod = new PaymentMethod();
-    for (const method in paymentMethods) {
-      const paymentMethodData =
-        await FinanceCompany._PaymentMethodRepository.findOne({
-          where: {
-            MethodId: paymentMethods[method].id,
-            Name: paymentMethods[method].name,
-          },
-          transaction: transaction,
-        });
-
-      if (!paymentMethodData) {
-        const newPaymentMethod =
-          await FinanceCompany._PaymentMethodRepository.create(
-            {
-              MethodId: paymentMethods[method].id,
-              Name: paymentMethods[method].name,
-              CompanyId: companyId,
-            },
-            {
-              transaction: transaction,
-            },
-          );
-
-        this._PaymentMethods.push(newPaymentMethod);
-      }
-      this._PaymentMethods.push(paymentMethodData);
-    }
-
-    this._PaymentMethods.forEach(async (item) => {
-      const p = item?.get({ plain: true });
-
-      for (const method in paymentMethods) {
-        if (!p) {
-          continue;
-        }
-
-        if (p.MethodId === paymentMethods[method]?.id) {
-          const paymentMethodTypeData =
-            await FinanceCompany._PaymentMethodTypeRepository.findOne({
-              where: {
-                MethodId: p.MethodId,
-              },
-              transaction: transaction,
-            });
-
-          if (!paymentMethodTypeData) {
-            const configPaymentMethodTypes = paymentMethods[method]?.types;
-
-            for (const methodType in configPaymentMethodTypes) {
-              // TODO: Create a seeder for payment method account
-              /*validate whether account data already exists*/
-              const accountData =
-                await FinanceCompany._AccountRepository.findOne({
-                  where: {
-                    AccountNo: configPaymentMethodTypes[methodType].accountNo,
-                  },
-                  transaction: transaction,
-                });
-
-              /*generating account data if not exist */
-              if (!accountData) {
-                const accountPayload = {
-                  CompanyId: companyId,
-                  Name: configPaymentMethodTypes[methodType].name,
-                  AccountType: 'PaymentMethod',
-                  CreatedAt: new Date(),
-                  CreatedById: 'System',
-                  AccSystemRefId: 'REF',
-                  PostedToAccSystemYN: 'N',
-                };
-
-                try {
-                  await FinanceCompany._AccountRepository.create(
-                    {
-                      AccountNo: configPaymentMethodTypes[methodType].accountNo,
-                      ...accountPayload,
-                    },
-                    {
-                      transaction: transaction,
-                    },
-                  );
-
-                  await FinanceCompany._AccountRepository.create(
-                    {
-                      AccountNo:
-                        configPaymentMethodTypes[methodType]
-                          .processingFeeAccountNo,
-                      ...accountPayload,
-                    },
-                    {
-                      transaction: transaction,
-                    },
-                  );
-                } catch (err) {
-                  throw err;
-                }
-              }
-
-              const paymentMethodTypePayload = {
-                MethodId: p.MethodId,
-                MethodTypeId: configPaymentMethodTypes[methodType].id,
-                Name: configPaymentMethodTypes[methodType].name,
-                AccountNo: configPaymentMethodTypes[methodType].accountNo,
-                ProcessingFeeRate:
-                  configPaymentMethodTypes[methodType].processingFeeRate,
-                ProcessingFeeAccountNo:
-                  configPaymentMethodTypes[methodType].processingFeeAccountNo,
-              };
-
-              try {
-                await paymentMethod.newPaymentMethodType(
-                  paymentMethodTypePayload,
-                  transaction,
-                );
-              } catch (err) {}
-            }
-          }
-        }
-      }
-    });
-  }
-
-  /**
-   * Method to load / reload the payment methods based on the configuration file
-   */
-  async LoadTaxCodes(
-    companyId: string,
-    companyTaxes: any,
-    transaction?: any,
-  ): Promise<void> {
-    for (const tax in companyTaxes) {
-      let tx = await FinanceCompany._TaxRepository.findOne({
-        where: {
-          TaxCode: companyTaxes[tax].taxCode,
-        },
-        transaction: transaction,
-      });
-
-      if (!tx) {
-        const newTx = await FinanceCompany._TaxRepository.create(
-          {
-            TaxCode: companyTaxes[tax].taxCode,
-            TaxRate: companyTaxes[tax].taxRate,
-            Description: companyTaxes[tax].description,
-            CompanyId: companyId,
-            UpdatedAt: new Date(),
-            CreatedById: 'System',
-            CreatedAt: new Date(),
-            UpdatedById: 'System',
-          },
-          {
-            transaction: transaction,
-          },
-        );
-
-        tx = newTx;
-      }
-      this._Taxes.push(new Tax(tx.get({ plain: true })));
-    }
-  }
-
-  async collectPaymentForMultipleCustomers(
-    dbTransaction: any,
-    loginUser: LoginUserBase,
-    payment: Payment,
-    creditTransaction: {
-      AccountNo: string;
-      Currency: string;
-      Amount: number;
-    }[],
-    receiptNo?: string,
-    collectPaymentType: CollectPaymentType = CollectPaymentType.AUTOMATIC,
-  ): Promise<Payment> {
-    //Method to collect payment for multiple customer.
-    try {
-      //Part 1: Privilege Checking\
-      const systemCode =
-        await ApplicationConfig.getComponentConfigValue('system-code');
-      const isPrivileged = await loginUser.checkPrivileges(
-        systemCode,
-        'Collect Payment For Multiple Customers',
-      );
-
-      if (!isPrivileged) {
-        throw new Error('User is not authorized to perform this action');
-      }
-
-      //Part 2: Validation
-      //Make sure that the payment has at least 1 payment item
-      const paymentItems = await payment.getPaymentItems();
-      if (paymentItems.length < 1) {
-        throw new Error(
-          'Atleast one payment item is required to identify what payment is being paid for.',
-        );
-      }
-
-      //Make sure that the payment has at least 1 payment method
-      const paymentPaidWithItems = await payment.getPaymentPaidWith();
-      if (paymentPaidWithItems.length < 1) {
-        throw new Error(
-          'Atleast one payment paid with item is required to identify how the payment was made.',
-        );
-      }
-
-      //Make sure the payment items length is equal to creditTransactions length records.
-      if (paymentItems.length !== creditTransaction.length) {
-        throw new Error(
-          'Payment items length is not equal to creditTransaction length',
-        );
-      }
-
-      //Make sure the payment items total Amount is equal to credit transactions total Amount.
-      let totalAmount = 0;
-      paymentItems.forEach((paymentItem) => {
-        totalAmount += paymentItem.Amount;
-      });
-
-      const totalCreditTransactionAmount = creditTransaction.reduce(
-        (accumulator, currentValue) => {
-          return accumulator + currentValue.Amount;
-        },
-        0,
-      );
-
-      if (totalAmount !== totalCreditTransactionAmount) {
-        throw new Error(
-          'Payment items total Amount is dnot equal to credit transactions total Amount',
-        );
-      }
-
-      //Part 3:Generate Receipt  (KIV)
-
-      //Part 4: Saving Payment, Payment Items and Payment Paid with Details to the Database
-
-      //Set below Payment attributes:
-      payment.PaymentId = this._createId().toUpperCase();
-      payment.PaymentType = PaymentType.PAYMENT_RECEIVED;
-      payment.ReceivedBy = loginUser.ObjectId;
-      payment.IssuedBy = loginUser.ObjectId;
-
-      //Call Payment Repository create() method by passing:
-      await FinanceCompany._PaymentRepository.create(
-        {
-          PaymentId: payment.PaymentId,
-          PaymentType: payment.PaymentType,
-          PaymentDate: payment.PaymentDate,
-          Description: payment.Description,
-          Currency: payment.Currency,
-          Amount: payment.Amount,
-          Status:
-            collectPaymentType === CollectPaymentType.MANUAL
-              ? PaymentStatus.PENDING
-              : PaymentStatus.CONFIRMED,
-          PostedToAccSystemYN: 'N',
-          ReceivedBy: payment.ReceivedBy,
-          IssuedBy: payment.IssuedBy,
-          Remarks: payment.Remarks,
-          RelatedObjectId: payment.RelatedObjectId,
-          RelatedObjectType: payment.RelatedObjectType,
-          ReceiptDocNo: payment.ReceiptDocNo,
-          UpdatedAt: new Date(),
-          UpdatedBy: loginUser.ObjectId,
-          CreatedAt: new Date(),
-          CreatedBy: loginUser.ObjectId,
-        },
-        { transaction: dbTransaction },
-      );
-
-      //Map Payment.PaymentItems and insert record by passing dbTransaction
-      paymentItems.forEach(async (paymentItem) => {
-        await FinanceCompany._PaymentItemRepository.create(
-          {
-            PaymentId: payment.PaymentId,
-            PayForObjectId: paymentItem.PayForObjectId,
-            PayForObjectType: paymentItem.PayForObjectType,
-            Currency: paymentItem.Currency,
-            Amount: paymentItem.Amount,
-            Name: paymentItem.Name,
-            Description: paymentItem.Description,
-          },
-          { transaction: dbTransaction },
-        );
-      });
-
-      // Map Payment.PaymentPaidWith and insert record by passing dbTransaction.
-      paymentPaidWithItems.forEach(async (paymentPaidWithItem) => {
-        await FinanceCompany._PaymentPaidWithRepository.create(
-          {
-            PaymentId: payment.PaymentId,
-            MethodTypeId: paymentPaidWithItem.MethodTypeId,
-            Currency: paymentPaidWithItem.Currency,
-            Amount: paymentPaidWithItem.Amount,
-            Status: paymentPaidWithItem.Status,
-            LedgerNo: paymentPaidWithItem.TransactionId,
-            RefBank: paymentPaidWithItem.RefBank,
-            RefName: paymentPaidWithItem.RefName,
-            RefNo: paymentPaidWithItem.RefNo,
-            RefOther1: paymentPaidWithItem.RefOther1,
-            RefOther2: paymentPaidWithItem.RefOther2,
-            RefOther3: paymentPaidWithItem.RefOther3,
-            RefOther4: paymentPaidWithItem.RefOther4,
-            RefOther5: paymentPaidWithItem.RefOther5,
-            Remarks: paymentPaidWithItem.Remarks,
-            PaymentMediaId: paymentPaidWithItem.PaymentMediaId,
-          },
-          { transaction: dbTransaction },
-        );
-      });
-
-      //Part 5: Registering the Journal Entries for the transaction
-      //Initialise TransactionDate
-      // const transactionDate = new Date();
-      // //Initialise new JournalEntry
-      // const journalEntry = new JournalEntry(dbTransaction);
-      // journalEntry.init({
-      //   CompanyId: this.CompanyId,
-      //   Name: 'Collect-payments for ' + payment.PaymentId,
-      // });
-
-      // // For each Payment.PaymentPaidWith:
-      // for (const paymentPaidWithItem of paymentPaidWithItems) {
-      //   const paymentMethodType = await PaymentMethodType.initMethodType(
-      //     dbTransaction,
-      //     paymentPaidWithItem.MethodTypeId,
-      //   );
-
-      //   //Initialise new Debit LedgerTransaction by calling JournalEntry.newLedgerTransaction() method and set below attributes:
-      //   const debitLT = await journalEntry.newLedgerTransaction(
-      //     TransactionTypeOptions.DEBIT,
-      //   );
-      //   debitLT.AccountNo = paymentMethodType.AccountNo;
-      //   debitLT.Currency = paymentPaidWithItem.Currency;
-      //   debitLT.DebitAmount = paymentPaidWithItem.Amount;
-      //   debitLT.Date = transactionDate;
-      //   debitLT.Description = 'Payment Received';
-      //   debitLT.RelatedPaymentId = payment.PaymentId;
-      // }
-
-      // //For each creditTransactions, Initialise new Credit LedgerTransaction by calling JournalEntry.newLedgerTransaction() method
-      // for (const ct of creditTransaction) {
-      //   const creditLT = await journalEntry.newLedgerTransaction(
-      //     TransactionTypeOptions.CREDIT,
-      //   );
-      //   creditLT.AccountNo = ct.AccountNo;
-      //   creditLT.Currency = ct.Currency;
-      //   creditLT.CreditAmount = ct.Amount;
-      //   creditLT.Date = transactionDate;
-      //   creditLT.Description = 'Payment Received';
-      //   creditLT.RelatedPaymentId = payment.PaymentId;
-      // }
-
-      // // Call this.postJournal()
-      // await this.postJournal(dbTransaction, journalEntry, loginUser);
-
-      return payment;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  /**
-   * Confirms a payment and performs necessary actions such as creating a payment receipt and registering journal entries.
-   * @param dbTransaction - The database transaction object.
-   * @param loginUser - The logged-in user object.
-   * @param customer - The customer object.
-   * @param payment - The payment object.
-   * @param status - The status of the payment (CONFIRMED, REJECTED, or FAILED).
-   * @param remarks - Additional remarks for the payment.
-   * @param ctAccountNo - Optional. The account number for the credit transaction.
-   * @param receiptNo - Optional. The receipt number for the payment.
-   * @returns A promise that resolves when the payment is confirmed.
-   * @throws Throws an error if the user does not have the necessary privileges, if the payment is not found, if the payment status is not 'Pending', or if an invalid status is provided.
-   */
-  async confirmPayment(
-    dbTransaction: any,
-    loginUser: LoginUserBase,
-    customer: FinanceCustomerBase,
-    payment: Payment,
-    status:
-      | PaymentStatus.CONFIRMED
-      | PaymentStatus.REJECTED
-      | PaymentStatus.FAILED,
-    remarks: string,
-    ctAccountNo?: string,
-    receiptNo?: string,
-  ): Promise<void> {
-    try {
-      this._DbTransaction = dbTransaction;
-      const systemCode =
-        ApplicationConfig.getComponentConfigValue('system-code');
-
-      const isPrivileged = await loginUser.checkPrivileges(
-        systemCode,
-        'FinanceCompany - Confirm Payment',
-      );
-      if (!isPrivileged) {
-        throw new ClassError(
-          'FinanceCompany',
-          'FinanceCompanyConfirmPaymentErrMsg00',
-          `You do not have 'Payment - Confirm' privilege.`,
-        );
-      }
-
-      if (payment.PaymentId === 'New') {
-        throw new ClassError(
-          'FinanceCompany',
-          'FinanceCompanyConfirmPaymentErrMsg01',
-          `Payment not found.`,
-        );
-      }
-
-      if (payment.Status !== PaymentStatus.PENDING) {
-        throw new ClassError(
-          'Payment',
-          'PaymentConfirmPaymentErrMsg02',
-          `Payment status is not 'Pending'.`,
-        );
-      }
-
-      payment.Remarks = remarks;
-      let receiptDocNo = null;
-      switch (status) {
-        case PaymentStatus.REJECTED:
-          payment.Status = PaymentStatus.REJECTED;
-          break;
-        case PaymentStatus.FAILED:
-          payment.Status = PaymentStatus.FAILED;
-          break;
-        case PaymentStatus.CONFIRMED:
-          payment.Status = PaymentStatus.CONFIRMED;
-          //Creating the payment receipt
-          /*Generating the receipt*/
-          const receiptDocuments: any =
-            await FinanceCompany._DocumentRepository.findAll({
-              where: {
-                DocType: DocType.RECEIPT,
-                CompanyId: this.ObjectId,
-              },
-            });
-
-          const receipt = new Document(dbTransaction);
-
-          if (receiptNo) {
-            receipt.DocNo = receiptNo;
-          } else {
-            receipt.DocNo = `EZC-RCT-${receiptDocuments.length + 1}`;
-          }
-          receipt.DocType = DocType.RECEIPT;
-          receipt.DocDate = new Date();
-          receipt.CompanyId = this.ObjectId;
-          receipt.Currency = payment.Currency;
-          receipt.Description = 'Payment Received';
-          receipt.IssuedById = loginUser.ObjectId;
-          receipt.IssuedToId = customer.CustomerId;
-          receipt.IssuedToType = type(customer);
-          receipt.RelatedObjectId = payment.RelatedObjectId;
-          receipt.RelatedObjectType = payment.RelatedObjectType;
-          receipt.UseAccSystemDocYN = 'N';
-          receipt.CreatedById = loginUser.ObjectId;
-          receipt.UpdatedById = loginUser.ObjectId;
-
-          const paymentItems = await payment.getPaymentItems(dbTransaction);
-          for (const paymentItem of paymentItems) {
-            const receiptItem = new DocumentItem(dbTransaction, receipt);
-            receiptItem.Name = `Payment for ${paymentItem.PayForObjectType} No. ${paymentItem.PayForObjectId}`;
-            receiptItem.NameBM = `Bayaran untuk ${paymentItem.PayForObjectType} No. ${paymentItem.PayForObjectId}`;
-            receiptItem.Description = '-';
-            receiptItem.Currency = paymentItem.Currency;
-            receiptItem.UnitPrice = paymentItem.Amount;
-            receiptItem.Quantity = 1;
-            receiptItem.Amount = receiptItem.UnitPrice * receiptItem.Quantity;
-            receiptItem.ItemId = receipt.DocNo;
-            receiptItem.ItemType = type(payment);
-            receiptItem.CtAccountNo = ctAccountNo;
-
-            await paymentItem.paid(dbTransaction);
-            await receipt.newDocumentItem(receiptItem);
-          }
-
-          const receiptMedia = await receipt.generateReceipt(
-            receipt.IssuedById,
-            customer,
-            dbTransaction,
-          );
-
-          /*Saving the receipt document and document items to the database*/
-          await FinanceCompany._DocumentRepository.create(
-            {
-              DocNo: receipt.DocNo,
-              DocType: receipt.DocType,
-              DocDate: receipt.DocDate,
-              CompanyId: receipt.CompanyId,
-              Currency: receipt.Currency,
-              Amount: receipt.Amount,
-              Description: receipt.Description,
-              Status: receipt.Status,
-              IssuedById: receipt.IssuedById,
-              IssuedToId: receipt.IssuedToId,
-              IssuedToType: receipt.IssuedToType,
-              RelatedObjectId: receipt.RelatedObjectId,
-              RelatedObjectType: receipt.RelatedObjectType,
-              CreatedById: receipt.CreatedById,
-              CreatedAt: new Date(),
-              UpdatedById: receipt.UpdatedById,
-              UpdatedAt: new Date(),
-              DocPDFFileMediaId: receiptMedia.PDFMedia.MediaId,
-              DocHTMLFileMediaId: receiptMedia.HTMLMedia.MediaId,
-              AccSystemRefId: receipt.AccSystemRefId,
-              PostedToAccSystemYN: receipt.PostedToAccSystemYN,
-              PostedById:
-                receipt.PostedToAccSystemYN == 'Y' ? receipt.PostedById : null,
-              PostedDateTime: new Date(),
-              UseAccSystemDocYN: receipt.UseAccSystemDocYN,
-            },
-            {
-              transaction: dbTransaction,
-            },
-          );
-
-          const receiptItems = await receipt.getDocumentItems(dbTransaction);
-
-          for (const receiptItem of receiptItems) {
-            await FinanceCompany._DocumentItemRepository.create(
-              {
-                DocumentItemId: this._createId().toUpperCase(),
-                DocNo: receipt.DocNo,
-                Name: receiptItem.Name,
-                NameBM: receiptItem.NameBM,
-                Description: receiptItem.Description,
-                ItemId: receiptItem.ItemId,
-                ItemType: receiptItem.ItemType,
-                ItemSKU: receiptItem.ItemSKU,
-                ItemSerialNo: receiptItem.ItemSerialNo,
-                Currency: receiptItem.Currency,
-                UnitPrice: receiptItem.UnitPrice,
-                Quantity: receiptItem.Quantity,
-                QuantityUOM: receiptItem.QuantityUOM,
-                Amount: receiptItem.Amount,
-                TaxCode: receiptItem.TaxCode,
-                TaxAmount: receiptItem.TaxAmount,
-                TaxRate: receiptItem.TaxRate,
-                TaxInclusiveYN: receiptItem.TaxInclusiveYN,
-                DtAccountNo: receiptItem.DtAccountNo
-                  ? receiptItem.DtAccountNo
-                  : null,
-                CtAccountNo: receiptItem.CtAccountNo
-                  ? receiptItem.CtAccountNo
-                  : null,
-              },
-              {
-                transaction: dbTransaction,
-              },
-            );
-          }
-          //Set the receipt doc no to the payment
-          payment.ReceiptDocNo = receipt.DocNo;
-          receiptDocNo = receipt.DocNo;
-
-          /*Registering the Journal Entries for the transaction*/
-          const transactionDate = new Date();
-          const paymentPaidWithItems =
-            await payment.getPaymentPaidWith(dbTransaction);
-
-          for (const paymentPaidWith of paymentPaidWithItems) {
-            let paymentMethodType = await PaymentMethodType.initMethodType(
-              dbTransaction,
-              paymentPaidWith.MethodTypeId,
-            );
-
-            const journalEntry = new JournalEntry(dbTransaction);
-
-            journalEntry.init({
-              CompanyId: this.CompanyId,
-              Name: 'Collect-payments for ' + payment.PaymentId,
-            });
-
-            const debitLT = await journalEntry.newLedgerTransaction(
-              TransactionTypeOptions.DEBIT,
-            );
-            debitLT.AccountNo = paymentMethodType.AccountNo;
-            debitLT.Currency = paymentPaidWith.Currency;
-            debitLT.DebitAmount = paymentPaidWith.Amount;
-            debitLT.Date = transactionDate;
-            debitLT.Description = 'Payment Received'; //customer.FullName;
-            debitLT.Name = customer.FullName;
-            debitLT.RelatedObjectId = payment.PaymentId;
-            debitLT.RelatedObjectType = 'Payment';
-            debitLT.RelatedPaymentId = payment.PaymentId;
-
-            const creditLT = await journalEntry.newLedgerTransaction(
-              TransactionTypeOptions.CREDIT,
-            );
-
-            if (ctAccountNo) {
-              creditLT.AccountNo = ctAccountNo;
-            } else {
-              const arAccount = await customer.getAccountReceivable();
-              creditLT.AccountNo = arAccount.AccountNo;
-            }
-            creditLT.Currency = paymentPaidWith.Currency;
-            creditLT.CreditAmount = paymentPaidWith.Amount;
-            creditLT.Date = transactionDate;
-            creditLT.Description = 'Payment Received'; //paymentMethodType.Name;
-            creditLT.Name = paymentMethodType.Name;
-            creditLT.RelatedObjectId = payment.PaymentId;
-            creditLT.RelatedObjectType = type(payment);
-            creditLT.RelatedPaymentId = payment.PaymentId;
-
-            await this.postJournal(dbTransaction, journalEntry, loginUser);
-          }
-          break;
-        default:
-          throw new ClassError(
-            'FinanceCompany',
-            'FinanceCompanyConfirmPaymentErrMsg03',
-            `Invalid status.`,
-          );
-      }
-
-      await FinanceCompany._PaymentRepository.update(
-        {
-          ReceiptDocNo: receiptDocNo,
-          Status: payment.Status,
-          UpdatedAt: new Date(),
-          UpdatedBy: loginUser.ObjectId,
-        },
-        {
-          where: {
-            PaymentId: payment.PaymentId,
-          },
-          transaction: dbTransaction,
-        },
-      );
-    } catch (error) {
-      throw error;
-    }
-  }
-}