@tomei/finance 0.3.0 → 0.3.2

package/src/payment/payment.ts

@@ -1,204 +1,206 @@
-import { IBaseRepository, PaymentItemBase } from '@tomei/general';
-import { PaymentMethod, PaymentType } from '../enum';
-import { IAccountSystem } from '../interfaces';
-import { IPaymentRepository } from './interfaces/payment.repository.interface';
-import { IPaymentItemRepository } from './interfaces/payment-item.repository.interface';
-import { Sequelize } from 'sequelize-typescript';
-import { IPaymentAttr } from './interfaces/payment-attr.interface';
-import PaymentModel from '../models/payment.entity';
-import axios from 'axios';
+import { ObjectBase, RecordNotFoundError } from '@tomei/general';
+import { PaymentType } from '../enum';
 import { IPaymentParams } from './interfaces/payment-params.interface';
 import { AccountSystemEntity } from '../account-system-entity/account-system-entity';
-import { Account } from '../account/account';
-import { FinanceCustomerBase } from '../customer/customer';
-
-export class Payment extends AccountSystemEntity {
-  protected BaseRepository: IBaseRepository;
-  TableName: string;
-  ObjectId: string;
-  ObjectName: string;
-  private Amount: number;
-  private Currency: string;
-  private Method: PaymentMethod;
-  private MethodParty: string;
-  private Status: string;
-  private PaymentType: PaymentType;
-  private PaymentDate: Date;
-  private AccountNo: string;
-  private SystemCode: string;
-  private OwnerId: string;
-  private OwnerType: string;
-  private RelatedObjectId: string;
-  private RelatedObjectType: string;
-  private CreatedAt: Date;
-  private CreatedById: string;
-  private UpdatedAt: Date;
-  private UpdatedById: string;
-  private Customer: FinanceCustomerBase;
-  private ReceivableAccount: Account;
-  private DepositAccount: Account;
-  private ReceivableAccountNo: string;
-  private DepositAccountNo: string;
-  private PaymentItems: PaymentItemBase[];
-  private AccountingSystem: IAccountSystem;
-  private PaymentRepository: IPaymentRepository;
-  private PaymentItemRepository: IPaymentItemRepository;
-  private sequelize: Sequelize;
-  AccSystemCode: string;
-
-  constructor(
-    AccountingSystem: IAccountSystem,
-    PaymentRepository: IPaymentRepository,
-    PaymentItemRepository: IPaymentItemRepository,
-    Customer: FinanceCustomerBase,
-    ReceivableAccount: Account,
-    DepositAccount: Account,
-    PaymentItems: PaymentItemBase[],
-    Params?: IPaymentParams,
-    sequelize?: Sequelize,
-  ) {
-    super();
-    this.AccountingSystem = AccountingSystem;
-    this.PaymentRepository = PaymentRepository;
-    this.PaymentItemRepository = PaymentItemRepository;
-    this.Customer = Customer;
-    this.ReceivableAccount = ReceivableAccount;
-    this.DepositAccount = DepositAccount;
-    this.PaymentItems = PaymentItems;
-    if (Params) {
-      this.init(Params);
-    }
-    if (sequelize) {
-      this.sequelize = sequelize;
-    }
+import { PaymentStatus } from '../enum/payment-status.enum';
+import { PaymentRepository } from './payment.repository';
+import { PaymentItemRepository } from '../payment-item/payment-item.repository';
+import PaymentItemModel from '../models/payment-item.entity';
+import PaymentItem from '../payment-item/payment-item';
+
+export default class Payment extends AccountSystemEntity {
+  private _PaymentId = 'New';
+  PaymentType: PaymentType;
+  PaymentDate: Date;
+  MethodTypeId: string;
+  Currency: string;
+  Amount: number;
+  private _Status: PaymentStatus;
+  TransactionId: string;
+  TransactionApprovalCode: string;
+  TransactionAccountName: string;
+  TransactionAccountNo: string;
+  private _ReceivedBy: string;
+  private _UpdatedBy: string;
+  private _UpdatedAt: Date;
+  Remarks: string;
+
+  private static _RepositoryBase = new PaymentRepository();
+  private static _PaymentItemRepository = new PaymentItemRepository();
+
+  private _DbTransaction: any;
+  private _PaymentItems = null;
+
+  paymentItemRepository: PaymentItemRepository;
+
+  public get PaymentId() {
+    return this._PaymentId;
   }
 
-  init(Params: IPaymentParams): void {
-    if (Params.Currency) this.Currency = Params.Currency;
-    if (Params.Method) this.Method = Params.Method;
-    if (Params.MethodParty) this.MethodParty = Params.MethodParty;
-    if (Params.PaymentType) this.PaymentType = Params.PaymentType;
+  public set PaymentId(id: string) {
+    this._PaymentId = id;
   }
 
-  getAmount(): number {
-    if (!this.Amount) {
-      if (this.PaymentItems.length === 0) {
-        throw new Error('Payment must have at least one payment item');
-      }
-      this.PaymentItems.forEach((paymentItem) => {
-        this.Amount += paymentItem.Amount;
-      });
-    }
-    return this.Amount;
+  public get Status() {
+    return this._Status;
   }
 
-  getCurrency(): string {
-    if (!this.Currency) {
-      throw new Error('Currency is missing.');
-    }
-    return this.Currency;
+  private set Status(status: PaymentStatus) {
+    this._Status = status;
   }
 
-  setSequelize(sequelize: Sequelize): void {
-    this.sequelize = sequelize;
+  public get ReceivedBy() {
+    return this._ReceivedBy;
   }
 
-  async getDepositAccountNo(): Promise<string> {
-    if (!this.DepositAccountNo) {
-      this.DepositAccountNo = await this.DepositAccount.getAccountNo();
-    }
-    return this.DepositAccountNo;
+  private set ReceivedBy(id: string) {
+    this._ReceivedBy = id;
   }
 
-  async getReceivableAccountNo(): Promise<string> {
-    if (!this.ReceivableAccountNo) {
-      this.ReceivableAccountNo = await this.ReceivableAccount.getAccountNo();
-    }
-    return this.ReceivableAccountNo;
+  public get UpdatedBy() {
+    return this._UpdatedBy;
   }
 
-  getPaymentItems(): PaymentItemBase[] {
-    return this.PaymentItems;
+  private set UpdatedBy(id: string) {
+    this._UpdatedBy = id;
   }
 
-  async create() {
-    const transaction = await this.sequelize.transaction();
-    try {
-      if (!this.sequelize) {
-        throw new Error('sequelize instance used for transaction is required.');
-      }
-      if (!this.PaymentType) {
-        throw new Error('Payment Type is required.');
-      }
-      if (!this.Method) {
-        throw new Error('Method is required.');
-      }
-      if (this.PaymentItems.length === 0) {
-        throw new Error('Payment must have at least one payment item');
-      }
+  public get UpdatedAt() {
+    return this._UpdatedAt;
+  }
+
+  private set UpdatedAt(date: Date) {
+    this._UpdatedAt = date;
+  }
+
+  /* AccountSystemEntity Implementation */
+  get RepositoryBase() {
+    return Payment._RepositoryBase;
+  }
+
+  /* ObjectBase Implementation */
+  get ObjectId() {
+    return this.PaymentId;
+  }
+
+  get ObjectName() {
+    return this.PaymentId;
+  }
 
-      this.ReceivableAccountNo = await this.ReceivableAccount.getAccountNo();
-      this.DepositAccountNo = await this.DepositAccount.getAccountNo();
-
-      this.ObjectId = await this.AccountingSystem.makePayment(
-        this.Customer,
-        this,
-      );
-
-      this.Status = 'Successfull';
-      const paymentAttribute: IPaymentAttr = {
-        PaymentId: this.ObjectId,
-        AccountNo: this.DepositAccountNo,
-        PaymentType: this.PaymentType,
-        PaymentDate: new Date(),
-        Currency: this.Currency,
-        Amount: this.Amount,
-        Status: this.Status,
-        Method: this.Method,
-        MethodParty: this.MethodParty,
-        ReceivedBy: this.ReceivableAccountNo,
-        UpdatedAt: new Date(),
-        UpdatedBy: 'System', //still ambigous
-      };
-      const payment = await this.PaymentRepository.create(paymentAttribute, {
-        transaction,
-      });
-      const paymentItemsData = [];
-      this.PaymentItems.forEach(async (paymentItem) => {
-        paymentItemsData.push({
-          PaymentId: this.ObjectId,
-          PayForObjectId: paymentItem.ObjectId,
-          PayForObjectType: paymentItem.Type,
-          Amount: paymentItem.Amount,
-          Currency: paymentItem.Currency,
+  get TableName() {
+    return 'finance_Payment';
+  }
+
+  constructor(dbTransaction?: any, paymentId?: string) {
+    super();
+    if (dbTransaction) {
+      this._DbTransaction = dbTransaction;
+    }
+    if (paymentId) {
+      this.RepositoryBase.findOne({
+        where: {
+          PaymentId: paymentId,
+        },
+        transaction: dbTransaction,
+      })
+        .then((paymentData) => {
+          if (paymentData) {
+            this.PaymentType = paymentData.PaymentType;
+            this.PaymentDate = paymentData.PaymentDate;
+            this.CompanyId = paymentData.CompanyId;
+            this.MethodTypeId = paymentData.MethodTypeId;
+            this.Currency = paymentData.Currency;
+            this.Amount = paymentData.Amount;
+            this.Status = paymentData.Status;
+            this.TransactionId = paymentData.TransactionId;
+            this.TransactionApprovalCode = paymentData.TransactionApprovalCode;
+            this.TransactionAccountName = paymentData.TransactionAccountName;
+            this.TransactionAccountNo = paymentData.TransactionAccountNo;
+            this.ReceivedBy = paymentData.ReceivedBy;
+            this.UpdatedAt = paymentData.UpdatedAt;
+            this.UpdatedBy = paymentData.UpdatedBy;
+            this.Remarks = paymentData.Remarks;
+            this.AccSystemRefId = paymentData.AccSystemRefId;
+            this.PostedToAccSystemYN = paymentData.PostedToAccSystemYN;
+            this.PostedById = paymentData.PostedById;
+            this.PostedDateTime = paymentData.PostedDateTime;
+          } else {
+            const notFoundError = new RecordNotFoundError('No Record Found.');
+            throw notFoundError;
+          }
+        })
+        .catch((err) => {
+          // tslint:disable-next-line:no-console
+          console.log('Payment Class constructor err: ', err);
         });
-      });
-
-      await this.PaymentItemRepository.bulkCreate(paymentItemsData, {
-        transaction,
-      });
-
-      const payload = {
-        Action: 'Create',
-        Activity: 'Payment Created',
-        Description: `Account (ID: ${this.ObjectId}) has been created`,
-        EntityType: typeof PaymentModel,
-        EntityValueBefore: JSON.stringify({}),
-        EntityValueAfter: JSON.stringify(payment),
-        PerformedById: payment.UpdatedBy,
-        PerformedAt: payment.UpdatedAt,
-        EntityId: this.ObjectId,
-      };
-
-      await axios.post(
-        `${process.env.COMMON_API_URL}/activity-histories`,
-        payload,
-      );
-
-      await transaction.commit();
-    } catch (error) {
-      await transaction.rollback();
-      throw error;
     }
   }
+
+  // public get PaymentItems() {
+  //   if (this._PaymentItems === null) {
+  //     this._PaymentItems = new Array<PaymentItemModel>();
+  //     if (this.PaymentId !== 'New') {
+  //       this.paymentItemRepository
+  //         .findAll({
+  //           where: {
+  //             PaymentId: this.PaymentId,
+  //           },
+  //         })
+  //         .then((allPaymentItems) => {
+  //           this._PaymentItems = allPaymentItems;
+  //         });
+  //     }
+  //   }
+
+  //   return this._PaymentItems;
+  // }
+
+  get PaymentItems(): Promise<PaymentItem[]> {
+    return new Promise((resolve, reject) => {
+      if (this.PaymentId !== 'New') {
+        Payment._PaymentItemRepository
+          .findAll({
+            where: {
+              PaymentId: this.PaymentId,
+            },
+            transaction: this._DbTransaction,
+          })
+          .then((paymentItems) => {
+            const paymentItemObjects = paymentItems.map((paymentItem) => {
+              new PaymentItem(
+                new Payment(this._DbTransaction, paymentItem.PaymentId),
+                {
+                  ObjectId: this.ObjectId,
+                  ObjectName: this.ObjectName,
+                  TableName: this.TableName,
+                },
+              );
+            });
+            return Promise.all(paymentItemObjects);
+          })
+          .then((paymentItemObjects) => {
+            this._PaymentItems = paymentItemObjects;
+            resolve(this._PaymentItems);
+          })
+          .catch((err) => {
+            reject(err);
+          });
+      }
+      resolve(this._PaymentItems);
+    });
+  }
+
+  newPaymentItem(objectBeingPaidFor: ObjectBase): PaymentItem {
+    const paymentItem = new PaymentItem(
+      new Payment(null, this.PaymentId),
+      objectBeingPaidFor,
+    );
+    this._PaymentItems.push(paymentItem);
+    return paymentItem;
+  }
+
+  init(Params: IPaymentParams): void {
+    if (Params.Currency) this.Currency = Params.Currency;
+    if (Params.PaymentType) this.PaymentType = Params.PaymentType;
+  }
 }

package/src/{payment → payment-item}/interfaces/payment-item-attr.interface.ts

@@ -4,4 +4,5 @@ export class IPaymentItemAttr {
   PayForObjectType: string;
   Currency: string;
   Amount: number;
+  TaxCode?: string;
 }

package/src/payment-item/payment-item.repository.ts

@@ -0,0 +1,11 @@
+import { RepositoryBase, IRepositoryBase } from '@tomei/general';
+import PaymentItemModel from '../models/payment-item.entity';
+
+export class PaymentItemRepository
+  extends RepositoryBase<PaymentItemModel>
+  implements IRepositoryBase<PaymentItemModel>
+{
+  constructor() {
+    super(PaymentItemModel);
+  }
+}

package/src/payment-item/payment-item.ts

@@ -0,0 +1,54 @@
+import { ObjectBase } from '@tomei/general';
+import Payment from '../payment/payment';
+
+export default class PaymentItem extends ObjectBase {
+  private _PaymentId: string;
+  private _PayForObjectId: string;
+  private _PayForObjectType: string;
+  Currency = 'MYR';
+  Amount = 0;
+
+  get PaymentId() {
+    return this._PaymentId;
+  }
+
+  private set PaymentId(id: string) {
+    this._PaymentId = id;
+  }
+
+  get PayForObjectId() {
+    return this._PayForObjectId;
+  }
+
+  private set PayForObjectId(id: string) {
+    this._PayForObjectId = id;
+  }
+
+  get PayForObjectType(): string {
+    return this._PayForObjectType;
+  }
+
+  private set PayForObjectType(type: string) {
+    this._PayForObjectType = type;
+  }
+
+  /* ObjectBase Implementation */
+  get ObjectId() {
+    return '';
+  }
+
+  get ObjectName() {
+    return '';
+  }
+
+  get TableName() {
+    return 'finance_PaymentItem';
+  }
+
+  constructor(payment: Payment, objectBeingPaidFor: ObjectBase) {
+    super();
+    this.PaymentId = payment.PaymentId;
+    this.PayForObjectId = objectBeingPaidFor.ObjectId;
+    this.PayForObjectType = objectBeingPaidFor.constructor.name;
+  }
+}

package/src/payment-method/interfaces/payment-method-attr.interface.ts

@@ -0,0 +1,4 @@
+export interface IPaymentMethodAttr {
+  MethodId: string;
+  Name: string;
+}

package/src/payment-method/payment-method.repository.ts

@@ -0,0 +1,11 @@
+import { RepositoryBase, IRepositoryBase } from '@tomei/general';
+import PaymentMethodModel from '../models/payment-method.entity';
+
+export class PaymentMethodRepository
+  extends RepositoryBase<PaymentMethodModel>
+  implements IRepositoryBase<PaymentMethodModel>
+{
+  constructor() {
+    super(PaymentMethodModel);
+  }
+}

package/src/payment-method/payment-method.ts

@@ -0,0 +1,95 @@
+import { ObjectBase, RecordNotFoundError } from '@tomei/general';
+import { PaymentMethodRepository } from './payment-method.repository';
+import PaymentMethodType from '../payment-method-type/payment-method-type';
+import { PaymentMethodTypeRepository } from '../payment-method-type/payment-method-type.repository';
+
+export default class PaymentMethod extends ObjectBase {
+  MethodId = 'New';
+  CompanyId = '';
+  Name = '';
+
+  private static _RepositoryBase = new PaymentMethodRepository();
+  private static _PaymentMethodTypeRepository =
+    new PaymentMethodTypeRepository();
+
+  private _DbTransaction: any;
+  private _PaymentMethodTypes: PaymentMethodType[] = [];
+
+  constructor(dbTransaction?: any, methodId?: string) {
+    super();
+    if (dbTransaction) {
+      this._DbTransaction = dbTransaction;
+    }
+    if (methodId) {
+      this.MethodId = methodId;
+      PaymentMethod._RepositoryBase
+        .findOne({
+          where: {
+            MethodId: methodId,
+          },
+          transaction: dbTransaction,
+        })
+        .then((methodData) => {
+          if (methodData) {
+            this.Name = methodData.Name;
+          } else {
+            throw new RecordNotFoundError('No record found.');
+          }
+        })
+        .catch((err) => {
+          console.log('Payment method constructor err: ', err);
+        });
+    }
+  }
+
+  get ObjectId() {
+    return this.MethodId;
+  }
+
+  get ObjectName() {
+    return this.Name;
+  }
+
+  get TableName() {
+    return 'finance_PaymentMethod';
+  }
+
+  get PaymentMethodTypes(): Promise<PaymentMethodType[]> {
+    return new Promise((resolve, reject) => {
+      if (this.MethodId !== 'New') {
+        PaymentMethod._PaymentMethodTypeRepository
+          .findAll({
+            where: {
+              MethodId: this.MethodId,
+            },
+            transaction: this._DbTransaction,
+          })
+          .then((paymentMethodTypes) => {
+            const paymentMethodTypeObjects = paymentMethodTypes.map(
+              (paymentMethodTypeData) =>
+                new PaymentMethodType(
+                  this._DbTransaction,
+                  paymentMethodTypeData.MethodTypeId,
+                ),
+            );
+            return Promise.all(paymentMethodTypeObjects);
+          })
+          .then((paymentMethodTypeObjects) => {
+            this._PaymentMethodTypes = paymentMethodTypeObjects;
+            resolve(this._PaymentMethodTypes);
+          })
+          .catch((err) => {
+            reject(err);
+          });
+      }
+      resolve(this._PaymentMethodTypes);
+    });
+  }
+
+  get NewPaymentMethodType(): PaymentMethodType {
+    const newPaymentMethodType = new PaymentMethodType();
+    newPaymentMethodType.MethodId = this.MethodId;
+    this._PaymentMethodTypes.push(newPaymentMethodType);
+    return newPaymentMethodType;
+  }
+}

package/src/payment-method-type/interfaces/payment-method-type-attr.interface.ts

@@ -0,0 +1,8 @@
+export interface IPaymentMethodTypeAttr {
+  MethodTypeId: string;
+  MethodId: string;
+  Name: string;
+  AccountNo: string;
+  ProcessingFeeRate: number;
+  ProcessingFeeAccountNo: string;
+}

package/src/payment-method-type/payment-method-type.repository.ts

@@ -0,0 +1,11 @@
+import { RepositoryBase, IRepositoryBase } from '@tomei/general';
+import PaymentMethodType from '../models/payment-method-type.entity';
+
+export class PaymentMethodTypeRepository
+  extends RepositoryBase<PaymentMethodType>
+  implements IRepositoryBase<PaymentMethodType>
+{
+  constructor() {
+    super(PaymentMethodType);
+  }
+}

package/src/payment-method-type/payment-method-type.ts

@@ -0,0 +1,58 @@
+import { ObjectBase, RecordNotFoundError } from '@tomei/general';
+import { PaymentMethodTypeRepository } from './payment-method-type.repository';
+
+export default class PaymentMethodType extends ObjectBase {
+  MethodTypeId = 'New';
+  MethodId = '';
+  Name = '';
+  AccountNo = '';
+  ProcessingFeeRate = 0.0;
+  ProcessingFeeAccountNo = '';
+
+  private _DbTransaction: any;
+
+  private static _RepositoryBase = new PaymentMethodTypeRepository();
+
+  constructor(dbTransaction?: any, methodTypeId?: string) {
+    super();
+    if (dbTransaction) {
+      this._DbTransaction = dbTransaction;
+    }
+    if (methodTypeId) {
+      this.MethodTypeId = methodTypeId;
+      PaymentMethodType._RepositoryBase
+        .findOne({
+          where: {
+            MethodTypeId: this.MethodTypeId,
+          },
+          transaction: this._DbTransaction,
+        })
+        .then((paymentMethodTypeData) => {
+          if (paymentMethodTypeData) {
+            this.Name = paymentMethodTypeData.Name;
+            this.AccountNo = paymentMethodTypeData.AccountNo;
+            this.ProcessingFeeRate = paymentMethodTypeData.ProcessingFeeRate;
+            this.ProcessingFeeAccountNo =
+              paymentMethodTypeData.ProcessingFeeAccountNo;
+          } else {
+            throw new RecordNotFoundError('No record found.');
+          }
+        })
+        .catch((err) => {
+          console.log('Payment method type constructor err: ', err);
+        });
+    }
+  }
+
+  get ObjectId() {
+    return this.MethodTypeId;
+  }
+
+  get ObjectName() {
+    return this.Name;
+  }
+
+  get TableName() {
+    return 'finance_PaymentMethodType';
+  }
+}

package/src/account/interfaces/account.repository.interface.ts

@@ -1,4 +0,0 @@
-import { IBaseRepository } from '@tomei/general';
-import AccountModel from '../../models/account.entity';
-
-export type IAccountRepository = IBaseRepository<AccountModel>;

package/src/document/interfaces/document.repository.interface.ts

@@ -1,4 +0,0 @@
-import { IBaseRepository } from '@tomei/general';
-import DocumentModel from '../../models/document.entity';
-
-export type IDocumentRepository = IBaseRepository<DocumentModel>;

package/src/journal-entry/interfaces/journal-entry.repository.interface.ts

@@ -1,11 +0,0 @@
-export interface IJournalEntryRepository<T> {
-  create?(data: T | any, options?: any): Promise<T> | any;
-
-  findAll?(options?: any): Promise<T[]>;
-
-  findAllWithPagination(options: any): Promise<{ count: number; rows: T[] }>;
-
-  findOne?(options: any): Promise<T>;
-
-  update?(data: any, options?: any): Promise<any>;
-}