@tomei/finance 0.3.31 → 0.3.33

package/src/customer/customer.ts

@@ -9,6 +9,10 @@ import FinanceCustomerModel from '../models/customer.entity';
 import { AccountSystemEntity } from '../account-system-entity/account-system-entity';
 import { FinanceCustomerRepository } from './finance-customer.repository';
 import * as cuid from 'cuid';
+import Account from '../account/account';
+import { AccountRepository } from '../account/account.repository';
+import type from '../helpers/typeof';
+import * as FinanceDb from '../database';
 
 // const AccountSystemEntity = import('../account-system-entity').then(({AccountSystemEntity}) => AccountSystemEntity);
 export default abstract class FinanceCustomerBase
@@ -22,6 +26,11 @@ export default abstract class FinanceCustomerBase
   abstract Email: string;
   abstract DefaultAddress: IAddress;
 
+  private _AccountReceivable: Account;
+  private _AccountPayable: Account;
+
+  private static _AccountRepository = new AccountRepository();
+
   // note: getDetails from spec is void type. Meaning that this probably needed a fix soon
   async getDetails(): Promise<{
     FullName: string;
@@ -72,6 +81,92 @@ export default abstract class FinanceCustomerBase
     }
   }
 
+  get AccountReceivable(): Promise<Account> {
+    return new Promise((resolve, reject) => {
+      let transaction;
+      if (this._AccountReceivable) {
+        resolve(this._AccountReceivable);
+      } else {
+        FinanceDb.getConnection()
+          .transaction()
+          .then((t) => {
+            transaction = t;
+            return FinanceCustomerBase._AccountRepository.findOne({
+              where: {
+                AccountType: 'Account Receivable',
+                OwnerId: this.CustomerId,
+                OwnerType: type(this),
+              },
+            });
+          })
+          .then((accountData) => {
+            this._AccountReceivable = new Account(transaction);
+            if (accountData) {
+              this._AccountReceivable.AccountNo = accountData.AccountNo;
+              this._AccountReceivable.ParentAccountNo =
+                accountData.ParentAccountNo;
+              this._AccountReceivable.AccountType = accountData.AccountType;
+              this._AccountReceivable.OwnerId = accountData.OwnerId;
+              this._AccountReceivable.OwnerType = accountData.OwnerType;
+            } else {
+              this._AccountReceivable.AccountNo = `${this.CustSystemCode}-AR-123456789`;
+              this._AccountReceivable.ParentAccountNo = `${this.CustSystemCode}-AR`;
+              this._AccountReceivable.AccountType = 'Account Receivable';
+              this._AccountReceivable.OwnerId = this.CustomerId;
+              this._AccountReceivable.OwnerType = type(this);
+            }
+            resolve(this._AccountReceivable);
+          })
+          .catch((err) => {
+            reject(err);
+          });
+      }
+    });
+  }
+
+  get AccountPayable(): Promise<Account> {
+    return new Promise((resolve, reject) => {
+      let transaction;
+      if (this._AccountPayable) {
+        resolve(this._AccountPayable);
+      } else {
+        FinanceDb.getConnection()
+          .transaction()
+          .then((t) => {
+            transaction = t;
+            return FinanceCustomerBase._AccountRepository.findOne({
+              where: {
+                AccountType: 'Account Payable',
+                OwnerId: this.CustomerId,
+                OwnerType: type(this),
+              },
+            });
+          })
+          .then((accountData) => {
+            this._AccountPayable = new Account(transaction);
+            if (accountData) {
+              this._AccountPayable.AccountNo = accountData.AccountNo;
+              this._AccountPayable.ParentAccountNo =
+                accountData.ParentAccountNo;
+              this._AccountPayable.AccountType = accountData.AccountType;
+              this._AccountPayable.OwnerId = accountData.OwnerId;
+              this._AccountPayable.OwnerType = accountData.OwnerType;
+            } else {
+              this._AccountPayable.AccountNo = `${this.CustSystemCode}-AP-123456789`;
+              this._AccountPayable.ParentAccountNo = `${this.CustSystemCode}-AP`;
+              this._AccountPayable.AccountType = 'Account Payable';
+              this._AccountPayable.OwnerId = this.CustomerId;
+              this._AccountPayable.OwnerType = type(this);
+            }
+            resolve(this._AccountPayable);
+          })
+          .catch((err) => {
+            reject(err);
+          });
+      }
+    });
+  }
+
   /*
    * Get the billing address for a person.
    **/

package/src/document/document.ts

@@ -21,6 +21,11 @@ import FinanceCompany from '../finance-company/finance-company';
 import FinanceCustomerBase from '../customer/customer';
 import DocumentModel from '../models/document.entity';
 
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const getConfig = require('../config');
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const config = getConfig();
+
 export default class Document extends AccountSystemEntity {
   private _DocNo = 'New';
   private _DocType: DocType;
@@ -127,6 +132,7 @@ export default class Document extends AccountSystemEntity {
 
   constructor(dbTransaction?: any, docNo?: string) {
     super();
+    console.log(config, '<<< test config from finance');
     if (dbTransaction) {
       this._DbTransaction = dbTransaction;
     }

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

@@ -14,7 +14,12 @@ import { IAccountSystem } from '../interfaces';
 import { FinanceCompanyRepository } from './finance-company.repository';
 import { FinanceCustomerRepository } from '../customer/finance-customer.repository';
 import { LedgerTransactionRepository } from '../ledger-transaction/ledger-transaction.repository';
-import { DocType, PaymentStatus, TransactionTypeOptions } from '../enum';
+import {
+  DocType,
+  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';
@@ -26,7 +31,7 @@ import { PaymentMethodTypeRepository } from '../payment-method-type/payment-meth
 import PaymentMethod from '../payment-method/payment-method';
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
-const { getConfig } = require('../config');
+const getConfig = require('../config');
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const config = getConfig();
 
@@ -982,7 +987,7 @@ export default class FinanceCompany extends ObjectBase {
    * @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
+   * @param ctAccountNo - The account number of the customer's Account Receivable account to transact, else the default customer account payable receivable will be used
    *
    * @returns {Payment} - Payment object representing the full detals of the payment collection recorded
    */
@@ -1008,6 +1013,7 @@ export default class FinanceCompany extends ObjectBase {
       }
 
       payment.PaymentId = cuid();
+      payment.PaymentType = PaymentType.PAYMENT_RECEIVED;
 
       await FinanceCompany._PaymentRepository.create(
         {
@@ -1070,8 +1076,7 @@ export default class FinanceCompany extends ObjectBase {
       if (ctAccountNo) {
         creditLT.AccountNo = ctAccountNo;
       } else {
-        // const config = getConfig();
-        creditLT.AccountNo = customer.CustSystemCode + '-AR';
+        creditLT.AccountNo = (await customer.AccountReceivable).AccountNo;
       }
       creditLT.Currency = payment.Currency;
       creditLT.CreditAmount = payment.Amount;
@@ -1092,6 +1097,122 @@ export default class FinanceCompany extends ObjectBase {
     }
   }
 
+  /**
+   * 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 detals of the payment collection recorded
+   */
+  async makePayment(
+    dbTransaction: any,
+    loginUser: LoginUserBase,
+    payment: Payment,
+    customer: FinanceCustomerBase,
+    dtAccountNo?: 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();
+      payment.PaymentType = PaymentType.PAYOUT;
+
+      await FinanceCompany._PaymentRepository.create(
+        {
+          PaymentId: payment.PaymentId,
+          PaymentType: payment.PaymentType,
+          PaymentDate: payment.PaymentDate,
+          CompanyId: this.CompanyId,
+          MethodTypeId: payment.MethodTypeId,
+          Currency: payment.Currency,
+          Amount: payment.Amount,
+          Status: PaymentStatus.SUCCESSFUL,
+          TransactionId: payment.TransactionId,
+          TransactionApprovalCode: payment.TransactionApprovalCode,
+          TransactionAccountName: payment.TransactionAccountName,
+          TransactionAccountNo: payment.TransactionAccountNo,
+          ReceivedBy: payment.ReceivedBy,
+          PostedToAccSystemYN: 'N',
+          UpdatedAt: new Date(),
+          UpdatedBy: loginUser.ObjectId,
+          CreatedAt: new Date(),
+          CreatedBy: loginUser.ObjectId,
+        },
+        { transaction: dbTransaction },
+      );
+
+      paymentItems.forEach(async (paymentItem) => {
+        await FinanceCompany._PaymentItemRepository.create(
+          {
+            PaymentId: payment.PaymentId,
+            PayForObjectId: paymentItem.PayForObjectId,
+            PayForObjectType: paymentItem.PayForObjectType,
+            Currency: paymentItem.Currency,
+            Amount: paymentItem.Amount,
+          },
+          { transaction: dbTransaction },
+        );
+      });
+
+      const journalEntry = new JournalEntry(dbTransaction);
+      //Temporary fix to successfully save journal entry in PostJournal
+      journalEntry.init({
+        CompanyId: this.CompanyId,
+        Name: 'Make Payment for ' + payment.PaymentId,
+      });
+      const transactionDate = new Date();
+
+      const creditLT = await journalEntry.newLedgerTransaction(
+        TransactionTypeOptions.CREDIT,
+      );
+      creditLT.AccountNo = paymentMethodType.AccountNo;
+      creditLT.Currency = payment.Currency;
+      creditLT.CreditAmount = payment.Amount;
+      creditLT.Date = transactionDate;
+      creditLT.Name = customer.FullName;
+
+      const debitLT = await journalEntry.newLedgerTransaction(
+        TransactionTypeOptions.DEBIT,
+      );
+      if (dtAccountNo) {
+        debitLT.AccountNo = dtAccountNo;
+      } else {
+        debitLT.AccountNo = (await customer.AccountPayable).AccountNo;
+      }
+      debitLT.Currency = payment.Currency;
+      debitLT.DebitAmount = payment.Amount;
+      debitLT.Date = transactionDate;
+      debitLT.Name = paymentMethodType.Name;
+
+      await this.postJournal(dbTransaction, journalEntry);
+
+      /*todo: saving a record into the activity history table*/
+
+      return payment;
+    } catch (error) {
+      if (error instanceof RecordNotFoundError) {
+        throw new Error('Invalid PaymentMethodType id');
+      } else {
+        throw error;
+      }
+    }
+  }
+
   get PaymentMethods() {
     if (this._PaymentMethods === null || this._PaymentMethods.length === 0) {
       this.LoadPaymentMethods();
@@ -1104,7 +1225,7 @@ export default class FinanceCompany extends ObjectBase {
    */
   async LoadPaymentMethods(): Promise<void> {
     /*Retrieve the payment method from the config file */
-    const { companyId, paymentMethods } = config.systemConfig['EZC'];
+    const { companyId, paymentMethods } = config.financeCompanies['TXG-FS'];
     const paymentMethod = new PaymentMethod();
 
     for (const method in paymentMethods) {
@@ -1145,6 +1266,11 @@ export default class FinanceCompany extends ObjectBase {
               MethodId: paymentMethodTypeData.MethodId,
               MethodTypeId: configPaymentMethodTypes[methodType].id,
               Name: configPaymentMethodTypes[methodType].name,
+              AccountNo: configPaymentMethodTypes[methodType].accountno,
+              ProcessingFeeRate:
+                configPaymentMethodTypes[methodType].processingFeeRate,
+              ProcessingFeeAccountNo:
+                configPaymentMethodTypes[methodType].processingFeeAccountNo,
             };
 
             await paymentMethod.newPaymentMethodType(paymentMethodTypePayload);

package/src/helpers/typeof.ts

@@ -0,0 +1,29 @@
+export default function type(value: any): string {
+  if (value === null) {
+    return 'null';
+  }
+  const baseType = typeof value;
+
+  if (!['object', 'function'].includes(baseType)) {
+    return baseType;
+  }
+
+  const tag = value[Symbol.toStringTag];
+  if (typeof tag === 'string') {
+    return tag;
+  }
+
+  if (
+    baseType === 'function' &&
+    Function.prototype.toString.call(value).startsWith('class')
+  ) {
+    return 'class';
+  }
+
+  const className = value.constructor.name;
+  if (typeof className === 'string' && className !== '') {
+    return className;
+  }
+
+  return baseType;
+}

package/src/ledger-transaction/ledger-transaction.ts

@@ -26,6 +26,9 @@ export default class LedgerTransaction {
     if (dbTransaction) {
       this._DbTransaction = dbTransaction;
     }
+    if (transactionId) {
+      this.TransactionId = transactionId;
+    }
   }
 
   init(params?: ILedgerTransactionAttr) {