@tomei/finance 0.3.0 → 0.3.2

package/migrations/finance-account-migration.js

@@ -8,28 +8,26 @@ module.exports = {
         primaryKey: true,
         allowNull: false,
       },
-      ParentAccountNo: {
+      CompanyId: {
         type: Sequelize.STRING(30),
-        allowNull: true,
-      },
-      SystemCode: {
-        type: Sequelize.STRING(10),
         allowNull: false,
+        references: {
+          model: 'finance_Company',
+          key: 'CompanyId',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
       },
-      AccSystemCode: {
-        type: Sequelize.STRING(10),
-        allowNull: false,
-      },
-      AccSystemRefId: {
-        type: Sequelize.STRING(10),
-        allowNull: false,
+      ParentAccountNo: {
+        type: Sequelize.STRING(30),
+        allowNull: true,
       },
       Name: {
         type: Sequelize.STRING(200),
-        allowNull: true,
+        allowNull: false,
       },
       Description: {
-        type: Sequelize.TEXT,
+        type: Sequelize.STRING(2000),
         allowNull: true,
       },
       AccountType: {
@@ -62,8 +60,8 @@ module.exports = {
         type: Sequelize.DATE,
       },
       CreatedById: {
+        type: Sequelize.STRING(30),
         allowNull: false,
-        type: Sequelize.STRING,
       },
       UpdatedAt: {
         allowNull: true,
@@ -71,8 +69,24 @@ module.exports = {
         type: Sequelize.DATE,
       },
       UpdatedById: {
+        type: Sequelize.STRING(30),
+        allowNull: true,
+      },
+      AccSystemRefId: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+      },
+      PostedToAccSystemYN: {
+        type: Sequelize.ENUM(['Y', 'N']),
+        allowNull: false,
+      },
+      PostedById: {
+        type: Sequelize.STRING(30),
+        allowNull: true,
+      },
+      PostedDateTime: {
+        type: Sequelize.DATE,
         allowNull: true,
-        type: Sequelize.STRING,
       },
     });
   },

package/migrations/finance-company-migration.js

@@ -20,20 +20,6 @@ module.exports = {
         type: Sequelize.STRING(10),
         allowNull: false,
       },
-      AccSystemRefId: {
-        type: Sequelize.STRING(30),
-        allowNull: false,
-      },
-      PostedToAccSystemYN: {
-        type: Sequelize.ENUM(['Y', 'N']),
-        allowNull: false,
-      },
-      PostedById: {
-        type: Sequelize.STRING(30),
-      },
-      PostedDateTime: {
-        type: Sequelize.DATE,
-      },
     });
   },
 

package/migrations/finance-payment-item-migration.js

@@ -30,6 +30,10 @@ module.exports = {
         type: Sequelize.DECIMAL(10, 2),
         allowNull: false,
       },
+      TaxCode: {
+        type: Sequelize.STRING(10),
+        allowNull: true,
+      },
     });
   },
 

package/migrations/finance-payment-method-migration.js

@@ -0,0 +1,21 @@
+'use strict';
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable('finance_PaymentMethod', {
+      MethodId: {
+        type: Sequelize.STRING(30),
+        primaryKey: true,
+        allowNull: false,
+      },
+      Name: {
+        type: Sequelize.STRING(100),
+        allowNull: false,
+      },
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable('finance_PaymentMethod');
+  },
+};

package/migrations/finance-payment-method-type-migration.js

@@ -0,0 +1,55 @@
+'use strict';
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable('finance_PaymentMethodType', {
+      MethodId: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        references: {
+          model: 'finance_PaymentMethod',
+          key: 'MethodId',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+      MethodTypeId: {
+        type: Sequelize.STRING(30),
+        primaryKey: true,
+        allowNull: false,
+      },
+      Name: {
+        type: Sequelize.STRING(100),
+        allowNull: false,
+      },
+      AccountNo: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        references: {
+          model: 'finance_Account',
+          key: 'AccountNo',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+      ProcessingFeeRate: {
+        type: Sequelize.DECIMAL(10, 2),
+        allowNull: false,
+      },
+      ProcessingFeeAccountNo: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        references: {
+          model: 'finance_Account',
+          key: 'AccountNo',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable('finance_PaymentMethodType');
+  },
+};

package/migrations/finance-payment-migration.js

@@ -8,16 +8,6 @@ module.exports = {
         primaryKey: true,
         allowNull: false,
       },
-      AccountNo: {
-        type: Sequelize.STRING(30),
-        allowNull: false,
-        references: {
-          model: 'finance_Account',
-          key: 'AccountNo',
-        },
-        onUpdate: 'CASCADE',
-        onDelete: 'CASCADE',
-      },
       PaymentType: {
         type: Sequelize.ENUM(['Payment Received', 'Payout']),
         defaultValue: 'Payment Received',
@@ -27,6 +17,26 @@ module.exports = {
         type: Sequelize.DATE,
         allowNull: false,
       },
+      CompanyId: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        references: {
+          model: 'finance_Company',
+          key: 'CompanyId',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+      MethodTypeId: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        references: {
+          model: 'finance_PaymentMethodType',
+          key: 'MethodTypeId',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
       Currency: {
         type: Sequelize.CHAR(3),
         allowNull: false,
@@ -39,27 +49,19 @@ module.exports = {
         type: Sequelize.STRING(20),
         allowNull: false,
       },
-      Method: {
-        type: Sequelize.STRING,
-        allowNull: false,
-      },
-      MethodParty: {
-        type: Sequelize.STRING(255),
-        allowNull: false,
-      },
-      MethodAccountName: {
+      TransactionId: {
         type: Sequelize.STRING(100),
         allowNull: true,
       },
-      MethodAccountNo: {
+      TransactionApprovalCode: {
         type: Sequelize.STRING(100),
         allowNull: true,
       },
-      TransactionId: {
+      TransactionAccountName: {
         type: Sequelize.STRING(100),
         allowNull: true,
       },
-      ApprovalId: {
+      TransactionAccountNo: {
         type: Sequelize.STRING(100),
         allowNull: true,
       },
@@ -68,18 +70,33 @@ module.exports = {
         allowNull: false,
       },
       UpdatedAt: {
-        allowNull: false,
-        defaultValue: new Date(),
         type: Sequelize.DATE,
+        allowNull: false,
       },
       UpdatedBy: {
+        type: Sequelize.STRING(30),
         allowNull: false,
-        type: Sequelize.STRING,
       },
       Remarks: {
         type: Sequelize.TEXT,
         allowNull: true,
       },
+      AccSystemRefId: {
+        type: Sequelize.STRING(30),
+        allowNull: true,
+      },
+      PostedToAccSystemYN: {
+        type: Sequelize.ENUM(['Y', 'N']),
+        allowNull: false,
+      },
+      PostedById: {
+        type: Sequelize.STRING(30),
+        allowNull: true,
+      },
+      PostedDateTime: {
+        type: Sequelize.DATE,
+        allowNull: true,
+      },
     });
   },
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomei/finance",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "NestJS package for finance module",
   "main": "dist/index.js",
   "scripts": {
@@ -35,7 +35,7 @@
     "@nestjs/platform-express": "^9.0.8",
     "@nestjs/sequelize": "^9.0.0",
     "@nestjs/swagger": "^6.1.4",
-    "@tomei/general": "file:../General",
+    "@tomei/general": "^0.0.26",
     "@tomei/media": "^0.4.0",
     "axios": "^1.1.3",
     "class-transformer": "^0.5.1",
@@ -44,9 +44,9 @@
     "dotenv": "^16.0.3",
     "intuit-oauth": "^4.0.0",
     "mariadb": "^3.0.2",
+    "puppeteer": "^19.4.0",
     "sequelize-typescript": "^2.1.3",
-    "uniqid": "^5.4.0",
-    "puppeteer": "^19.4.0"
+    "uniqid": "^5.4.0"
   },
   "devDependencies": {
     "@types/multer": "^1.4.7",

package/src/account/account.repository.ts

@@ -1,44 +1,11 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/sequelize';
-import { BaseRepository } from '@tomei/general';
-import {
-  IAccountAttr,
-  ICreateAccountAttr,
-} from './interfaces/account-attr.interface';
-import { IAccountRepository } from './interfaces/account.repository.interface';
+import { RepositoryBase, IRepositoryBase } from '@tomei/general';
 import AccountModel from '../models/account.entity';
 
-@Injectable()
 export class AccountRepository
-  extends BaseRepository<AccountModel>
-  implements IAccountRepository
+  extends RepositoryBase<AccountModel>
+  implements IRepositoryBase<AccountModel>
 {
-  constructor(
-    @InjectModel(AccountModel)
-    private readonly accountModel: typeof AccountModel,
-  ) {
-    super(accountModel);
-  }
-
-  create(data: ICreateAccountAttr, options?: any): Promise<AccountModel> | any {
-    return this.accountModel.create({ ...data }, options);
-  }
-
-  findAll(options: any): Promise<AccountModel[]> {
-    return this.accountModel.findAll(options);
-  }
-
-  findAllWithPagination(
-    options: any,
-  ): Promise<{ count: number; rows: AccountModel[] }> {
-    return this.accountModel.findAndCountAll(options);
-  }
-
-  findOne(options: any): Promise<AccountModel> {
-    return this.accountModel.findOne(options);
-  }
-
-  update(data: IAccountAttr, options?: any): any {
-    return this.accountModel.update({ ...data }, options);
+  constructor() {
+    super(AccountModel);
   }
 }

package/src/account/account.ts

@@ -1,94 +1,139 @@
-import { IAccountRepository } from './interfaces/account.repository.interface';
-import { ObjectBase, LoginUserBase, RecordNotFoundError } from '@tomei/general';
-import { IBaseRepository } from '@tomei/general/dist/interfaces/repository.base.interface';
+import { RecordNotFoundError } from '@tomei/general';
 import { AccountSystemEntity } from '../account-system-entity/account-system-entity';
 import AccountModel from '../models/account.entity';
+import { AccountRepository } from './account.repository';
 
-export class Account extends AccountSystemEntity {
-  protected BaseRepository;
-  ObjectId: string;
-  ObjectName: string;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { getConfig } = require('../config');
 
-  accountRepository: IAccountRepository;
+export default class Account extends AccountSystemEntity {
   AccountNo: string;
-  Owner: LoginUserBase;
-  RelatedObject: ObjectBase;
-  TableName: string;
-  private isNewRecord = true;
-  private OwnerId: string;
-  private OwnerType: string;
-  private RelatedObjectId: string;
-  private RelatedObjectType: string;
-  private ParentAccountNo: string;
-
-  SystemCode: string;
-  AccSystemCode: string;
+  ParentAccountNo?: string;
   Name: string;
   Description: string;
   AccountType: string;
   AccountSubtype: string;
-
-  CreatedAt: Date;
+  OwnerId: string;
+  OwnerType: string;
+  RelatedObjectId: string;
+  RelatedObjectType: string;
   CreatedById: string;
+  CreatedAt: Date;
+  UpdatedAt: Date;
+  UpdatedById: string;
 
-  constructor(
-    accountRepository?: IBaseRepository<AccountModel>,
-    accountNo?: string,
-  ) {
-    super();
-    if (accountRepository && accountNo) {
-      this.accountRepository = accountRepository;
-      this.AccountNo = accountNo;
-      const accountData = this.accountRepository.findOne({
-        where: { AccountNo: accountNo },
-      });
-      if (accountData) {
-        this.isNewRecord = false;
-        this.ParentAccountNo = accountData.ParentAccountNo;
-        this.SystemCode = accountData.SystemCode;
-        this.AccSystemCode = accountData.AccSystemCode;
-        this.AccSystemRefId = accountData.AccSystemRefId;
-        this.Name = accountData.Name;
-        this.Description = accountData.Description;
-        this.AccountType = accountData.AccountType;
-        this.AccountSubtype = accountData.AccountSubtype;
-        this.OwnerId = accountData.OwnerId;
-        this.OwnerType = accountData.OwnerType;
-        this.RelatedObjectId = accountData.RelatedObjectId;
-        this.RelatedObjectType = accountData.RelatedObjectType;
-        this.AccSystemCode = accountData.AccSystemCode;
-      } else {
-        const notFoundError = new RecordNotFoundError('No Record Found.');
-        throw notFoundError;
-      }
-    } else if (accountRepository || accountNo) {
-      throw new Error('AccountNo and AccountRepository both are required.');
-    }
+  private static _RepositoryBase = new AccountRepository();
+
+  private _DbTransaction: any;
+  private _IsNewRecord = true;
+
+  private get IsNewRecord() {
+    return this._IsNewRecord;
   }
 
-  public get name(): string {
-    return this.Name;
+  private set IsNewRecord(record: boolean) {
+    this._IsNewRecord = record;
   }
 
-  public get accountType(): string {
-    return this.AccountType;
+  /* AccountSystemEntity Implementation */
+  get RepositoryBase() {
+    return Account._RepositoryBase;
   }
 
-  public get accountSubType(): string {
-    return this.AccountSubtype;
+  /* ObjectBase Implementation */
+  get ObjectId() {
+    return this.AccountNo;
   }
 
-  public get parentAccountNo(): string {
-    return this.ParentAccountNo;
+  get ObjectName() {
+    return this.Name;
   }
 
-  validateAccountValue() {
-    if (!this.SystemCode) {
-      throw new Error('SystemCode is required.');
+  get TableName() {
+    return 'finance_Account';
+  }
+
+  constructor(dbTransaction?: any, accountNo?: string) {
+    super();
+    if (dbTransaction) {
+      this._DbTransaction = dbTransaction;
     }
-    if (!this.AccSystemCode) {
-      throw new Error('AccSystemCode is required.');
+    if (accountNo) {
+      this.RepositoryBase.findOne({
+        where: {
+          AccountNo: accountNo,
+        },
+        transaction: dbTransaction,
+      })
+        .then((accountData) => {
+          if (accountData) {
+            this.IsNewRecord = false;
+            this.CompanyId = accountData.CompanyId;
+            this.ParentAccountNo = accountData.ParentAccountNo;
+            this.Name = accountData.Name;
+            this.Description = accountData.Description;
+            this.AccountType = accountData.AccountType;
+            this.AccountSubtype = accountData.AccountSubType;
+            this.OwnerId = accountData.OwnerId;
+            this.OwnerType = accountData.OwnerType;
+            this.RelatedObjectId = accountData.RelatedObjectId;
+            this.RelatedObjectType = accountData.RelatedObjectType;
+            this.CreatedById = accountData.CreatedById;
+            this.CreatedAt = accountData.CreatedAt;
+            this.UpdatedById = accountData.UpdatedById;
+            this.UpdatedAt = accountData.UpdatedAt;
+            this.AccSystemRefId = accountData.AccSystemRefId;
+            this.PostedToAccSystemYN = accountData.PostedToAccSystemYN;
+            this.PostedById = accountData.PostedById;
+            this.PostedDateTime = accountData.PostedDateTime;
+          } else {
+            const notFoundError = new RecordNotFoundError('No Record Found.');
+            throw notFoundError;
+          }
+        })
+        .catch((err) => {
+          // tslint:disable-next-line:no-console
+          console.log('Account Class constructor err: ', err);
+        });
     }
+  }
+
+  /**
+   * Account static constructor
+   *
+   * Create the Customer Account Receivable (AR) and Customer Account Payable (AP) default accounts.
+   * The static constructor is to run once each time the program loads and check if the default accounts have been created.
+   * If it has not, it will create the accounts.
+   */
+  static async Account() {
+    const dbTransaction = null;
+    let DefaultAccountReceivable: Account = null;
+    let DefaultAccountPayable: Account = null;
+
+    // const config = getConfig();
+    // config.systemConfig['EZC']
+
+    try {
+      DefaultAccountReceivable = new Account(dbTransaction, 'EZC-AR');
+    } catch (err) {
+      DefaultAccountReceivable = new Account(dbTransaction);
+      DefaultAccountReceivable.AccountNo = null;
+      DefaultAccountReceivable.AccountType = 'Account Receivable';
+      DefaultAccountReceivable.OwnerId = 'System';
+      DefaultAccountReceivable.OwnerType = '';
+    }
+
+    try {
+      DefaultAccountPayable = new Account(dbTransaction, 'EZC-AP');
+    } catch (err) {
+      DefaultAccountPayable = new Account(dbTransaction);
+      DefaultAccountPayable.AccountNo = null;
+      DefaultAccountPayable.AccountType = 'Account Payable';
+      DefaultAccountPayable.OwnerId = 'System';
+    }
+  }
+
+  validateAccountValue() {
     if (!this.AccSystemRefId) {
       throw new Error('AccSystemAccountId is required.');
     }
@@ -97,7 +142,7 @@ export class Account extends AccountSystemEntity {
     }
   }
 
-  isParentAccountExsits() {
+  isParentAccountExists() {
     if (this.ParentAccountNo) return true;
     return false;
   }
@@ -108,11 +153,9 @@ export class Account extends AccountSystemEntity {
     dbTransaction?: any,
   ): Promise<AccountModel> {
     this.AccSystemRefId = AccSystemRefId;
-    const data = await this.accountRepository.create(
+    const data = await this.RepositoryBase.create(
       {
         AccountNo: this.AccountNo,
-        SystemCode: this.SystemCode,
-        AccSystemCode: this.AccSystemCode,
         AccSystemRefId: this.AccSystemRefId,
         Name: this.Name,
         Description: this.Description,
@@ -129,30 +172,4 @@ export class Account extends AccountSystemEntity {
     );
     return data;
   }
-
-  /**
-   * This method will return finance_Account.AccountNo
-   * @returns {Promise<string>} AccountNo
-   */
-  async getAccountNo(): Promise<string> {
-    if (this.AccountNo) {
-      return this.AccountNo;
-    } else {
-      try {
-        const account = await this.accountRepository.findOne({
-          OwnerId: this.OwnerId,
-          AccSystemRefId: this.AccSystemRefId,
-        });
-
-        if (account) {
-          this.AccountNo = account.AccountNo;
-          return this.AccountNo;
-        } else {
-          throw new Error('Account need to be created first.');
-        }
-      } catch (error) {
-        throw error;
-      }
-    }
-  }
 }

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

@@ -2,16 +2,24 @@ import { ObjectBase, LoginUserBase } from '@tomei/general';
 
 export interface IAccountAttr {
   AccountNo: string;
-  SystemCode: string;
+  CompanyId: string;
+  ParentAccountNo?: string;
   Name: string;
-  OwnerId: string;
-  OwnerType: string;
-  RelatedObjectId: string;
-  RelatedObjectType: string;
+  Description?: string;
+  AccountType: string;
+  AccountSubType?: string;
+  OwnerId?: string;
+  OwnerType?: string;
+  RelatedObjectId?: string;
+  RelatedObjectType?: string;
   CreatedAt: Date;
   CreatedById: string;
-  UpdatedAt: Date;
-  UpdatedById: string;
+  UpdatedAt?: Date;
+  UpdatedById?: string;
+  AccSystemRefId: string;
+  PostedToAccSystemYN: string;
+  PostedById?: string;
+  PostedDateTime?: Date;
 }
 
 export interface ICreateAccountAttr {

package/src/account-system-entity/account-system-entity.ts

@@ -1,4 +1,4 @@
-import { IBaseRepository, LoginUserBase, ObjectBase } from '@tomei/general';
+import { IRepositoryBase, LoginUserBase, ObjectBase } from '@tomei/general';
 // import { FinanceCompany } from '../finance-company';
 import { PostHistoryRepository } from './post-history.repository';
 import cuid from 'cuid';
@@ -11,7 +11,7 @@ export abstract class AccountSystemEntity extends ObjectBase {
   private _AccSystemRefId = '';
   private _PostedById = '';
   private _PostedDateTime: Date;
-  protected abstract BaseRepository: IBaseRepository<any>;
+  protected abstract RepositoryBase: IRepositoryBase<any>;
   private static PostHistoryRepository = new PostHistoryRepository();
 
   get CompanyId(): string {
@@ -73,8 +73,8 @@ export abstract class AccountSystemEntity extends ObjectBase {
       this._PostedDateTime = new Date();
 
       /*updating the posted fields to the table either using direct
-       * SQL or BaseRepository*/
-      const entity = await this.BaseRepository.findByPk(this.ObjectId);
+       * SQL or RepositoryBase*/
+      const entity = await this.RepositoryBase.findByPk(this.ObjectId);
       const updated = await entity.update(
         {
           PostedToAccSystemYN: this._PostedToAccSystemYN,