@tomei/finance 0.3.0 → 0.3.2

package/src/index.ts

@@ -1,11 +1,14 @@
-import { Account } from './account/account';
+import Account from './account/account';
 import FinanceCompany from './finance-company/finance-company';
-import { FinanceCustomerBase } from './customer/customer';
-import { Document } from './document/document';
-import { DocumentItem } from './document/document-item';
-import { JournalEntry } from './journal-entry/journal-entry';
-import { LedgerTransaction } from './ledger-transaction/ledger-transaction';
-import { Payment } from './payment/payment';
+import FinanceCustomerBase from './customer/customer';
+import Document from './document/document';
+import DocumentItem from './document/document-item';
+import JournalEntry from './journal-entry/journal-entry';
+import LedgerTransaction from './ledger-transaction/ledger-transaction';
+import Payment from './payment/payment';
+import PaymentItem from './payment-item/payment-item';
+import PaymentMethod from './payment-method/payment-method';
+import PaymentMethodType from './payment-method-type/payment-method-type';
 
 export {
   FinanceCompany,
@@ -16,6 +19,9 @@ export {
   JournalEntry,
   LedgerTransaction,
   Payment,
+  PaymentItem,
+  PaymentMethod,
+  PaymentMethodType,
 };
 export * as FinanceEnum from './enum';
 export * as FinanceInterfaces from './interfaces';

package/src/interfaces/account-system.interface.ts

@@ -1,5 +1,5 @@
-import { Payment } from '../payment/payment';
-import { FinanceCustomerBase } from '../customer/customer';
+import Payment from '../payment/payment';
+import FinanceCustomerBase from '../customer/customer';
 
 export interface IAccountSystem {
   createAccount(payload: any): Promise<any>;

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

@@ -1,40 +1,11 @@
-import { InjectModel } from '@nestjs/sequelize';
+import { RepositoryBase, IRepositoryBase } from '@tomei/general';
 import JournalEntryModel from '../models/journal-entry.entity';
-import { IJournalEntryRepository } from './interfaces/journal-entry.repository.interface';
-import { IJournalEntryAttr } from './interfaces/journal-entry-attr.interface';
-import { Injectable } from '@nestjs/common/decorators';
 
-@Injectable()
 export class JournalEntryRepository
-  implements IJournalEntryRepository<JournalEntryModel>
+  extends RepositoryBase<JournalEntryModel>
+  implements IRepositoryBase<JournalEntryModel>
 {
-  constructor(
-    @InjectModel(JournalEntryModel)
-    private readonly journalEntryModel: typeof JournalEntryModel,
-  ) {}
-
-  create(
-    data: IJournalEntryAttr | any,
-    options?: any,
-  ): Promise<JournalEntryModel> | any {
-    return this.journalEntryModel.create(data, options);
-  }
-
-  findAll(options?: any): Promise<JournalEntryModel[]> {
-    return this.journalEntryModel.findAll(options);
-  }
-
-  findAllWithPagination(
-    options: any,
-  ): Promise<{ count: number; rows: JournalEntryModel[] }> {
-    return this.journalEntryModel.findAndCountAll(options);
-  }
-
-  findOne(options: any): Promise<JournalEntryModel> {
-    return this.journalEntryModel.findOne(options);
-  }
-
-  update(data: IJournalEntryAttr, options?: any): any {
-    return this.journalEntryModel.update({ ...data }, options);
+  constructor() {
+    super(JournalEntryModel);
   }
 }

package/src/journal-entry/journal-entry.ts

@@ -1,33 +1,29 @@
 import * as cuid from 'cuid';
 import { Op } from 'sequelize';
-import { ILedgerTransactionTypeOptionsAttr } from '../ledger-transaction/interfaces/ledger-transaction-attr.interface';
-import { JournalEntryRepository } from './journal-entry.repository';
 import { IJournalEntryAttr } from './interfaces/journal-entry-attr.interface';
 import { TransactionTypeOptions } from '../enum';
 import JournalEntryModel from '../models/journal-entry.entity';
-import { IBaseRepository } from '@tomei/general';
 import { AccountSystemEntity } from '../account-system-entity/account-system-entity';
 import { LedgerTransactionRepository } from '../ledger-transaction/ledger-transaction.repository';
-import { LedgerTransaction } from '../ledger-transaction/ledger-transaction';
+import LedgerTransaction from '../ledger-transaction/ledger-transaction';
+import { JournalEntryRepository } from './journal-entry.repository';
+import { RecordNotFoundError } from '@tomei/general';
 
-export class JournalEntry extends AccountSystemEntity {
+export default class JournalEntry extends AccountSystemEntity {
   private _JournalEntryId: string;
   Date: Date;
   Name: string;
   Description: string;
 
-  private _JournalEntryModel: IBaseRepository<JournalEntryModel> =
-    new JournalEntryModel();
-  protected _BaseRepository: IBaseRepository;
-
-  _TableName: string;
-  _ObjectId: string;
-  _ObjectName: string;
+  private static _RepositoryBase = new JournalEntryRepository();
+  private static _LedgerTransactionRepository =
+    new LedgerTransactionRepository();
 
-  journalEntryRepository: JournalEntryRepository;
   ledgerTransactionRepository: LedgerTransactionRepository;
-  private _DebitTransactions: any = null;
-  private _CreditTransactions: any = null;
+
+  private _DbTransaction: any;
+  private _DebitTransactions = null;
+  private _CreditTransactions = null;
 
   get JournalEntryId() {
     return this._JournalEntryId;
@@ -37,82 +33,177 @@ export class JournalEntry extends AccountSystemEntity {
     this._JournalEntryId = id;
   }
 
-  override get BaseRepository() {
-    return this._JournalEntryModel;
+  get RepositoryBase() {
+    return JournalEntry._RepositoryBase;
   }
 
-  override get TableName() {
+  get TableName() {
     return 'finance_JournalEntry';
   }
 
-  override get ObjectName() {
+  get ObjectName() {
     return this.Name;
   }
 
-  override get ObjectId() {
+  get ObjectId() {
     return this._JournalEntryId;
   }
 
-  constructor(dbTransaction: any);
-  constructor(dbTransaction: any, journalEntryId: string);
-  constructor(dbTransaction: any, journalEntryId?: string) {
+  constructor(dbTransaction?: any, journalEntryId?: string) {
     super();
-    this.journalEntryRepository = this.ledgerTransactionRepository.findOne({
-      where: {
-        JournalEntryId: journalEntryId,
-      },
-      transaction: dbTransaction,
-    });
+    if (dbTransaction) {
+      this._DbTransaction = dbTransaction;
+    }
+    if (journalEntryId) {
+      this.RepositoryBase.findOne({
+        where: {
+          JournalEntryId: journalEntryId,
+        },
+        transaction: dbTransaction,
+      })
+        .then((journalEntryData) => {
+          if (journalEntryData) {
+            this.CompanyId = journalEntryData.CompanyId;
+            this.Date = journalEntryData.Date;
+            this.Name = journalEntryData.Name;
+            this.Description = journalEntryData.Description;
+            this.AccSystemRefId = journalEntryData.AccSystemRefId;
+            this.PostedToAccSystemYN = journalEntryData.PostedToAccSystemYN;
+            this.PostedById = journalEntryData.PostedById;
+            this.PostedDateTime = journalEntryData.PostedDateTime;
+          } else {
+            const notFoundError = new RecordNotFoundError('No Record Found.');
+            throw notFoundError;
+          }
+        })
+        .catch((err) => {
+          console.log('Journal entry constructor err: ', err);
+        });
+    }
   }
 
-  public get DebitTransactions() {
-    if (this._DebitTransactions === null) {
-      // this._DebitTransactions = new LedgerTransaction(
-      //   this.ledgerTransactionRepository,
-      // );
+  get DebitTransactions(): Promise<LedgerTransaction[]> {
+    return new Promise((resolve, reject) => {
       if (this.JournalEntryId !== 'New') {
-        this.ledgerTransactionRepository
+        JournalEntry._LedgerTransactionRepository
           .findAll({
             where: {
               JournalEntryId: {
                 [Op.ne]: 'New',
               },
-              TransactionType: TransactionTypeOptions.Debit,
+              TransactionType: TransactionTypeOptions.DEBIT,
             },
+            transaction: this._DbTransaction,
+          })
+          .then((debitTransactions) => {
+            const debitTransactionObjects = debitTransactions.map(
+              (debitTransactionData) => {
+                new LedgerTransaction(
+                  this._DbTransaction,
+                  debitTransactionData.TransactionId,
+                );
+              },
+            );
+            return Promise.all(debitTransactionObjects);
+          })
+          .then((debitTransactionObjects) => {
+            this._DebitTransactions = debitTransactionObjects;
+            resolve(this._DebitTransactions);
           })
-          .then((allDebitTransactions) => {
-            this._DebitTransactions = allDebitTransactions;
+          .catch((err) => {
+            reject(err);
           });
       }
-    }
-
-    return this._DebitTransactions;
+      resolve(this._DebitTransactions);
+    });
   }
 
-  public get CreditTransactions() {
-    if (this._CreditTransactions === null) {
-      // this._CreditTransactions = new LedgerTransaction(
-      //   this.ledgerTransactionRepository,
-      // );
+  get CreditTransactions(): Promise<LedgerTransaction[]> {
+    return new Promise((resolve, reject) => {
       if (this.JournalEntryId !== 'New') {
-        this.ledgerTransactionRepository
+        JournalEntry._LedgerTransactionRepository
           .findAll({
             where: {
               JournalEntryId: {
                 [Op.ne]: 'New',
               },
-              TransactionType: TransactionTypeOptions.Credit,
+              TransactionType: TransactionTypeOptions.CREDIT,
             },
+            transaction: this._DbTransaction,
+          })
+          .then((creditTransaction) => {
+            const creditTransactionObjects = creditTransaction.map(
+              (creditTransactionData) => {
+                new LedgerTransaction(
+                  this._DbTransaction,
+                  creditTransactionData.TransactionId,
+                );
+              },
+            );
+            return Promise.all(creditTransactionObjects);
+          })
+          .then((creditTransactionObjects) => {
+            this._CreditTransactions = creditTransactionObjects;
+            resolve(this._CreditTransactions);
           })
-          .then((allCreditTransactions) => {
-            this._CreditTransactions = allCreditTransactions;
+          .catch((err) => {
+            reject(err);
           });
       }
-    }
-
-    return this._CreditTransactions;
+      resolve(this._CreditTransactions);
+    });
   }
 
+  // public get DebitTransactions() {
+  //   if (this._DebitTransactions === null) {
+  //     // this._DebitTransactions = new LedgerTransaction(
+  //     //   this.ledgerTransactionRepository,
+  //     // );
+  //     if (this.JournalEntryId !== 'New') {
+  //       JournalEntry._LedgerTransactionRepository
+  //         .findAll({
+  //           where: {
+  //             JournalEntryId: {
+  //               [Op.ne]: 'New',
+  //             },
+  //             TransactionType: TransactionTypeOptions.DEBIT,
+  //           },
+  //           transaction: this._DbTransaction,
+  //         })
+  //         .then((allDebitTransactions) => {
+  //           this._DebitTransactions = allDebitTransactions;
+  //         });
+  //     }
+  //   }
+
+  //   return this._DebitTransactions;
+  // }
+
+  // public get CreditTransactions() {
+  //   if (this._CreditTransactions === null) {
+  //     // this._CreditTransactions = new LedgerTransaction(
+  //     //   this.ledgerTransactionRepository,
+  //     // );
+  //     if (this.JournalEntryId !== 'New') {
+  //       JournalEntry._LedgerTransactionRepository
+  //         .findAll({
+  //           where: {
+  //             JournalEntryId: {
+  //               [Op.ne]: 'New',
+  //             },
+  //             TransactionType: TransactionTypeOptions.CREDIT,
+  //           },
+  //           transaction: this._DbTransaction,
+  //         })
+  //         .then((allCreditTransactions) => {
+  //           this._CreditTransactions = allCreditTransactions;
+  //         });
+  //     }
+  //   }
+
+  //   return this._CreditTransactions;
+  // }
+
   init(params: IJournalEntryAttr) {
     this.JournalEntryId = params.JournalEntryId;
     this.Date = params.Date;
@@ -136,11 +227,11 @@ export class JournalEntry extends AccountSystemEntity {
   }
 
   async create() {
-    return await this.journalEntryRepository.create(this.getData);
+    return await this.RepositoryBase.create(this.getData);
   }
 
   async save(userId: string, dbTransaction?: any): Promise<JournalEntryModel> {
-    const data = await this.journalEntryRepository.create(
+    const data = await this.RepositoryBase.create(
       {
         JournalEntryId: this.JournalEntryId,
         Date: this.Date,
@@ -155,12 +246,21 @@ export class JournalEntry extends AccountSystemEntity {
     return data;
   }
 
-  async newLedgerTransaction({
-    transactionType,
-  }: ILedgerTransactionTypeOptionsAttr): Promise<any> {
+  /**
+   * Create a new LedgerTransaction
+   *
+   * @see {@link FinanceCompany.issueInvoice} - for implementation
+   *
+   * @param transactionType - Indicating the type of ledger transaction to create
+   *
+   * @returns {LedgerTransaction}
+   */
+  async newLedgerTransaction(
+    transactionType: TransactionTypeOptions,
+  ): Promise<LedgerTransaction> {
     this.init({
-      CompanyId: cuid(),
-      JournalEntryId: 'New',
+      JournalEntryId: cuid(),
+      CompanyId: this.CompanyId,
       Date: new Date(),
       Name: '',
       Description: '',
@@ -175,13 +275,13 @@ export class JournalEntry extends AccountSystemEntity {
     );
 
     const newLedgerTransaction = await ledgerTransaction.newLedgerTransaction(
-      { transactionType },
+      transactionType,
       this.JournalEntryId,
     );
 
-    if (transactionType === TransactionTypeOptions.Debit) {
+    if (transactionType === TransactionTypeOptions.DEBIT) {
       this.DebitTransactions;
-    } else if (transactionType === TransactionTypeOptions.Credit) {
+    } else if (transactionType === TransactionTypeOptions.CREDIT) {
       this.CreditTransactions;
     }
 

package/src/ledger-transaction/interfaces/ledger-transaction-attr.interface.ts

@@ -1,4 +1,3 @@
-import { TransactionTypeOptions } from '../../enum';
 export interface ILedgerTransactionAttr {
   TransactionId: string;
   TransactionType: string;
@@ -13,7 +12,3 @@ export interface ILedgerTransactionAttr {
   RelatedObjectId: string;
   RelatedObjectType: string;
 }
-
-export interface ILedgerTransactionTypeOptionsAttr {
-  transactionType: TransactionTypeOptions;
-}

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

@@ -1,30 +1,11 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/sequelize';
 import LedgerTransactionModel from '../models/ledger-transaction.entity';
-import { ILedgerTransactionAttr } from './interfaces/ledger-transaction-attr.interface';
-import { ILedgerTransactionRepository } from './interfaces/ledger-transaction.repository.interface';
+import { RepositoryBase, IRepositoryBase } from '@tomei/general';
 
-@Injectable()
 export class LedgerTransactionRepository
-  implements ILedgerTransactionRepository<LedgerTransactionModel>
+  extends RepositoryBase<LedgerTransactionModel>
+  implements IRepositoryBase<LedgerTransactionModel>
 {
-  constructor(
-    @InjectModel(LedgerTransactionModel)
-    private readonly ledgerTransactionModel: typeof LedgerTransactionModel,
-  ) {}
-
-  create(
-    data: ILedgerTransactionAttr | any,
-    options?: any,
-  ): Promise<LedgerTransactionModel> | any {
-    return this.ledgerTransactionModel.create(data, options);
-  }
-
-  findAll(options?: any): Promise<LedgerTransactionModel[]> {
-    return this.ledgerTransactionModel.findAll(options);
-  }
-
-  findOne(options: any): Promise<LedgerTransactionModel> | any {
-    return this.ledgerTransactionModel.findOne(options);
+  constructor() {
+    super(LedgerTransactionModel);
   }
 }

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

@@ -1,12 +1,9 @@
-import {
-  ILedgerTransactionAttr,
-  ILedgerTransactionTypeOptionsAttr,
-} from './interfaces/ledger-transaction-attr.interface';
+import { ILedgerTransactionAttr } from './interfaces/ledger-transaction-attr.interface';
 import { TransactionTypeOptions } from '../enum/transaction-type.enum';
 import { LedgerTransactionRepository } from './ledger-transaction.repository';
 import * as uniqid from 'uniqid';
 
-export class LedgerTransaction {
+export default class LedgerTransaction {
   TransactionId: string;
   JournalEntryId: string;
   AccountNo: string;
@@ -22,9 +19,8 @@ export class LedgerTransaction {
   TransactionType: string;
 
   ledgerTransactionRepository: LedgerTransactionRepository;
-  constructor(ledgerTransactionRepository: LedgerTransactionRepository) {
-    this.ledgerTransactionRepository = ledgerTransactionRepository;
-  }
+
+  constructor(dbTransaction?: any, transactionId?: string) {}
 
   init(params?: ILedgerTransactionAttr) {
     this.TransactionId = params.TransactionId;
@@ -63,12 +59,12 @@ export class LedgerTransaction {
   }
 
   async newLedgerTransaction(
-    { transactionType }: ILedgerTransactionTypeOptionsAttr,
+    transactionType: TransactionTypeOptions,
     journalEntryId?: string,
   ): Promise<any> {
     this.init({
       TransactionId: uniqid(),
-      TransactionType: 'Debit',
+      TransactionType: transactionType,
       JournalEntryId: '',
       AccountNo: '',
       Date: new Date(),
@@ -81,9 +77,9 @@ export class LedgerTransaction {
       RelatedObjectType: '',
     });
 
-    if (transactionType === TransactionTypeOptions.Debit) {
+    if (transactionType === TransactionTypeOptions.DEBIT) {
       this.TransactionType = 'Debit';
-    } else if (transactionType === TransactionTypeOptions.Credit) {
+    } else if (transactionType === TransactionTypeOptions.CREDIT) {
       this.TransactionType = 'Credit';
     }
 

package/src/models/account.entity.ts

@@ -1,5 +1,7 @@
 import { ApiProperty } from '@nestjs/swagger';
 import {
+  ForeignKey,
+  BelongsTo,
   Column,
   CreatedAt,
   Model,
@@ -11,6 +13,7 @@ import {
 import LedgerTransactionModel from './ledger-transaction.entity';
 import PaymentModel from './payment.entity';
 import DocumentItemModel from './document-item.entity';
+import FinanceCompanyModel from './finance-company.entity';
 
 @Table({ tableName: 'finance_Account', createdAt: false, updatedAt: false })
 export default class AccountModel extends Model {
@@ -22,48 +25,31 @@ export default class AccountModel extends Model {
   })
   AccountNo: string;
 
-  @ApiProperty({ type: String, description: 'Parent account of this object' })
-  @Column({
-    type: DataType.STRING(30),
-  })
-  ParentAccountNo: string;
-
-  @ApiProperty({
-    type: String,
-    description: 'System Code eg. "EZC", "CRM"',
-  })
-  @Column({
-    allowNull: false,
-    type: DataType.STRING(10),
-  })
-  SystemCode: string;
-
   @ApiProperty({
-    type: String,
-    description: 'Finance account system code eg. "quickbook"',
+    example: 'cl6nzvo780000qcw38ihpd8w6',
+    description: 'CompanyId',
   })
+  @ForeignKey(() => FinanceCompanyModel)
   @Column({
     allowNull: false,
-    type: DataType.STRING(10),
+    type: DataType.STRING(30),
   })
-  AccSystemCode: string;
+  CompanyId: string;
 
-  @ApiProperty({
-    type: String,
-    description: 'Account id in finance system',
-  })
+  //copy from finance account migration table
+  @ApiProperty({ type: String, description: 'Parent account of this object' })
   @Column({
-    allowNull: false,
-    type: DataType.STRING(10),
+    type: DataType.STRING(30),
+    allowNull: true,
   })
-  AccSystemRefId: string;
+  ParentAccountNo: string;
 
   @ApiProperty({
     type: String,
     description: 'Name of the account',
   })
   @Column({
-    allowNull: true,
+    allowNull: false,
     type: DataType.STRING(200),
   })
   Name: string;
@@ -74,7 +60,7 @@ export default class AccountModel extends Model {
   })
   @Column({
     allowNull: true,
-    type: DataType.TEXT,
+    type: DataType.STRING(2000),
   })
   Description: string;
 
@@ -83,7 +69,7 @@ export default class AccountModel extends Model {
     description: 'Account Type',
   })
   @Column({
-    allowNull: true,
+    allowNull: false,
     type: DataType.STRING(100),
   })
   AccountType: string;
@@ -143,7 +129,10 @@ export default class AccountModel extends Model {
     example: '138140891dd211b288d34bc7b4312a49',
     description: 'The CreatedById for Media.',
   })
-  @Column({ allowNull: false, type: DataType.STRING(30) })
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
   CreatedById: string;
 
   @ApiProperty({
@@ -157,9 +146,52 @@ export default class AccountModel extends Model {
     example: '138140891dd211b288d34bc7b4312a49',
     description: 'The UpdatedById for Media.',
   })
-  @Column({ allowNull: false, type: DataType.STRING(30) })
+  @Column({
+    allowNull: true,
+    type: DataType.STRING(30),
+  })
   UpdatedById: string;
 
+  @ApiProperty({
+    type: String,
+    description: 'Account id in finance system',
+  })
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(10),
+  })
+  AccSystemRefId: string;
+
+  @ApiProperty({
+    example: 'N',
+    description: 'PostedToAccSystemYN',
+  })
+  @Column({
+    allowNull: false,
+    type: DataType.ENUM('Y', 'N'),
+  })
+  PostedToAccSystemYN: string;
+
+  @ApiProperty({
+    example: '138140891dd211b288',
+    description: 'PostedById',
+  })
+  @Column({
+    allowNull: true,
+    type: DataType.STRING(30),
+  })
+  PostedById: string;
+
+  @ApiProperty({
+    example: new Date(),
+    description: 'PostedToAccSystem Date',
+  })
+  @Column({
+    allowNull: true,
+    type: DataType.DATE,
+  })
+  PostedDateTime: Date;
+
   @HasMany(() => PaymentModel)
   Payments: PaymentModel[];
 
@@ -168,4 +200,7 @@ export default class AccountModel extends Model {
 
   @HasMany(() => LedgerTransactionModel)
   LedgerTransactions: LedgerTransactionModel[];
+
+  @BelongsTo(() => FinanceCompanyModel)
+  FinanceCompany: FinanceCompanyModel;
 }