@tomei/finance 0.3.0 → 0.3.2

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

@@ -1,32 +1,43 @@
 import axios from 'axios';
+import * as cuid from 'cuid';
 import {
   HashTable,
-  IBaseRepository,
   LoginUserBase,
   ObjectBase,
+  RecordNotFoundError,
 } from '@tomei/general';
-import { BadRequestException } from '@nestjs/common';
+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 * as cuid from 'cuid';
 import { FinanceCompanyRepository } from './finance-company.repository';
 import { FinanceCustomerRepository } from '../customer/finance-customer.repository';
-import { JournalEntryRepository } from '../journal-entry/journal-entry.repository';
-import { Account } from '../account/account';
 import { LedgerTransactionRepository } from '../ledger-transaction/ledger-transaction.repository';
-import { FinanceCustomerBase } from '../customer/customer';
-import { JournalEntry } from '../journal-entry/journal-entry';
+import { DocType, 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';
+
+const { getConfig } = require('../config');
+const config = getConfig();
 
 export default class FinanceCompany extends ObjectBase {
   private _CompanyId = 'New';
   private _CompSystemCode = '';
   private _CompSystemRefId = '';
   private _AccSystemCode = '';
-  private _AccSystemRefId = '';
-  protected BaseRepository: IBaseRepository;
   private static _htFinanceCompanyIds = new HashTable();
   private static _htFinanceCompanies = new HashTable();
-  private static financeCompanyRepository = new FinanceCompanyRepository();
-  journalEntryRepository: JournalEntryRepository;
+  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();
+
   financeCustomerRepository: FinanceCustomerRepository;
   ledgerTransactionRepository: LedgerTransactionRepository;
   AccountingSystem: IAccountSystem;
@@ -55,10 +66,6 @@ export default class FinanceCompany extends ObjectBase {
     this._AccSystemCode = code;
   }
 
-  get AccSystemRefId() {
-    return this._AccSystemRefId;
-  }
-
   get CompanyId() {
     return this._CompanyId;
   }
@@ -109,7 +116,7 @@ export default class FinanceCompany extends ObjectBase {
 
       /*Retrieve the finance company from finance_Company table using compSystemCode,
        * CompSystemRefId and accSystemCode */
-      const company = await FinanceCompany.financeCompanyRepository.findOne({
+      const company = await FinanceCompany._financeCompanyRepository.findOne({
         where: {
           CompSystemCode: compSystemCode,
           CompSystemRefId: compSystemRefId,
@@ -138,7 +145,7 @@ export default class FinanceCompany extends ObjectBase {
     if (!FinanceCompany._htFinanceCompanies.get(companyId)) {
       /*Retrieve the finance company from finance_Company table using compSystemCode,
        * CompSystemRefId and accSystemCode */
-      const company = await FinanceCompany.financeCompanyRepository.findOne({
+      const company = await FinanceCompany._financeCompanyRepository.findOne({
         where: { CompanyId: companyId },
       });
 
@@ -188,7 +195,7 @@ export default class FinanceCompany extends ObjectBase {
     );
 
     /*Validating if the finance company already exists in finance_Company*/
-    const company = await FinanceCompany.financeCompanyRepository.findOne({
+    const company = await FinanceCompany._financeCompanyRepository.findOne({
       where: {
         CompSystemCode: compSystemCode,
         CompSystemRefId: compSystemRefId,
@@ -206,13 +213,12 @@ export default class FinanceCompany extends ObjectBase {
     financeCompany.ObjectId = cuid();
 
     /*Save the FinanceCompany to the finance_Company table*/
-    await FinanceCompany.financeCompanyRepository.create(
+    await FinanceCompany._financeCompanyRepository.create(
       {
         CompanyId: financeCompany.CompanyId,
         CompSystemCode: financeCompany.CompSystemCode,
         CompSystemRefId: financeCompany.CompSystemRefId,
         AccSystemCode: financeCompany.AccSystemCode,
-        AccSystemRefId: financeCompany.AccSystemRefId,
       },
       {
         transaction: dbTransaction,
@@ -236,7 +242,7 @@ export default class FinanceCompany extends ObjectBase {
   ) {
     try {
       if (customer.CustSystemCode || customer.CustSystemRefId) {
-        throw new BadRequestException(
+        throw new Error(
           'CustSystemCode and CustomerRefId are required fields.',
         );
       }
@@ -252,7 +258,7 @@ export default class FinanceCompany extends ObjectBase {
       });
 
       if (financeCustomerData) {
-        throw new BadRequestException('Customer already created previously.');
+        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
@@ -274,10 +280,7 @@ export default class FinanceCompany extends ObjectBase {
         EntityId: newCustomer.CustomerId,
       };
 
-      await axios.post(
-        `${process.env.COMMON_API_URL}/activity-histories`,
-        payload,
-      );
+      await axios.post(`${config.commonApiUrl}/activity-histories`, payload);
 
       return customer;
     } catch (error) {
@@ -286,27 +289,26 @@ export default class FinanceCompany extends ObjectBase {
   }
 
   async postJournal(dbTransaction: any, journalEntry: JournalEntry) {
+    const debitTransactions = await journalEntry.DebitTransactions;
+    const creditTransactions = await journalEntry.CreditTransactions;
     try {
-      if (
-        journalEntry.CreditTransactions?.length < 1 ||
-        journalEntry.DebitTransactions?.length < 1
-      ) {
-        throw new BadRequestException(
+      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 = journalEntry.CreditTransactions.reduce(
+      const totalCreditAmount = creditTransactions.reduce(
         (accumulator, currentValue) => accumulator + currentValue.CreditAmount,
         0,
       );
-      const totalDebitAmount = journalEntry.DebitTransactions.reduce(
+      const totalDebitAmount = debitTransactions.reduce(
         (accumulator, currentValue) => accumulator + currentValue.DebitAmount,
         0,
       );
 
       if (totalCreditAmount !== totalDebitAmount) {
-        throw new BadRequestException(
+        throw new Error(
           'Credit ledger transaction and debit ledger transaction should the same amount',
         );
       }
@@ -314,7 +316,7 @@ export default class FinanceCompany extends ObjectBase {
       const newJournalEntry = await journalEntry.save('test', dbTransaction);
 
       const allLedgerTransactions =
-        await this.ledgerTransactionRepository.findAll();
+        await this.ledgerTransactionRepository.findAll({});
 
       for (const ledgerTransaction of allLedgerTransactions) {
         ledgerTransaction.JournalEntryId = newJournalEntry.JournalEntryId;
@@ -335,10 +337,7 @@ export default class FinanceCompany extends ObjectBase {
         EntityId: newJournalEntry.JournalEntryId,
       };
 
-      await axios.post(
-        `${process.env.COMMON_API_URL}/activity-histories`,
-        payload,
-      );
+      await axios.post(`${config.commonApiUrl}/activity-histories`, payload);
     } catch (error) {
       throw error;
     }
@@ -349,17 +348,17 @@ export default class FinanceCompany extends ObjectBase {
       account.validateAccountValue();
 
       let createAccountPayload: any = {
-        Name: account.name,
+        Name: account.Name,
         AcctNum: account.AccountNo,
-        AccountType: account.accountType,
-        AccountSubType: account.accountSubType,
+        AccountType: account.AccountType,
+        AccountSubType: account.AccountSubtype,
       };
 
-      if (account.isParentAccountExsits()) {
+      if (account.isParentAccountExists()) {
         createAccountPayload = {
           ...createAccountPayload,
           CurrencyRef: 'MYR',
-          ParentRef: account.parentAccountNo,
+          ParentRef: account.ParentAccountNo,
           SubAccount: true,
         };
       }
@@ -386,14 +385,652 @@ export default class FinanceCompany extends ObjectBase {
         EntityId: newAccount.AccountNo,
       };
 
-      await axios.post(
-        `${process.env.COMMON_API_URL}/activity-histories`,
-        payload,
-      );
+      await axios.post(`${config.commonApiUrl}/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(
+    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.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: 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: 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 invoice*/
+      if (invoice.UseAccSystemDocYN) {
+        /*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 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);
+
+      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(`${config.commonApiUrl}/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: 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 invoice*/
+      if (invoice.UseAccSystemDocYN) {
+        /*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) {
+        /*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.DebitAmount = creditNote.Amount;
+      creditTransaction.Date = transactionDate;
+      creditTransaction.Name = creditNote.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 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: payment.Status,
+        TransactionId: payment.TransactionId,
+        TransactionApprovalCode: payment.TransactionApprovalCode,
+        TransactionAccountName: payment.TransactionAccountName,
+        TransactionAccountNo: payment.TransactionAccountNo,
+        ReceivedBy: payment.ReceivedBy,
+        UpdatedAt: new Date(),
+        UpdatedBy: loginUser.ObjectId,
+        CreatedAt: new Date(),
+        CreatedBy: loginUser.ObjectId,
+      });
+
+      paymentItems.forEach(async (paymentItem) => {
+        await FinanceCompany._PaymentItemRepository.create({
+          PaymentId: payment.PaymentId,
+          PayForObjectId: paymentItem.PayForObjectId,
+          PayForObjectType: paymentItem.PayForObjectType,
+          Currency: paymentItem.Currency,
+          Amount: paymentItem.Amount,
+        });
+      });
+
+      const journalEntry = new JournalEntry(dbTransaction);
+      const transactionDate = new Date();
+
+      const debitLT = await journalEntry.newLedgerTransaction(
+        TransactionTypeOptions.DEBIT,
+      );
+      debitLT.AccountNo = paymentMethodType.AccountNo;
+      debitLT.Currency = payment.Currency;
+      debitLT.CreditAmount = 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.DebitAmount = 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;
+      }
+    }
+  }
 }