@tomei/finance 0.2.1 → 0.2.2

package/migrations/finance-account-migration.js

@@ -1,59 +1,83 @@
-'use strict';
-
-module.exports = {
-  async up(queryInterface, Sequelize) {
-    await queryInterface.createTable('finance_Account', {
-      AccountNo: {
-        type: Sequelize.STRING(30),
-        primaryKey: true,
-        allowNull: false,
-      },
-      SystemCode: {
-        type: Sequelize.STRING(10),
-        allowNull: false,
-      },
-      Name: {
-        type: Sequelize.STRING(200),
-        allowNull: true,
-      },
-      OwnerId: {
-        type: Sequelize.STRING(30),
-        allowNull: false,
-      },
-      OwnerType: {
-        type: Sequelize.STRING(200),
-        allowNull: false,
-      },
-      RelatedObjectId: {
-        type: Sequelize.STRING(30),
-        allowNull: false,
-      },
-      RelatedObjectType: {
-        type: Sequelize.STRING(200),
-        allowNull: false,
-      },
-      CreatedAt: {
-        allowNull: false,
-        defaultValue: new Date(),
-        type: Sequelize.DATE,
-      },
-      CreatedById: {
-        allowNull: false,
-        type: Sequelize.STRING,
-      },
-      UpdatedAt: {
-        allowNull: true,
-        defaultValue: new Date(),
-        type: Sequelize.DATE,
-      },
-      UpdatedById: {
-        allowNull: true,
-        type: Sequelize.STRING,
-      },
-    });
-  },
-
-  async down(queryInterface) {
-    await queryInterface.dropTable('finance_Account');
-  },
-};
+'use strict';
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable('finance_Account', {
+      AccountNo: {
+        type: Sequelize.STRING(30),
+        primaryKey: true,
+        allowNull: false,
+      },
+      ParentAccountNo: {
+        type: Sequelize.STRING(30),
+        allowNull: true,
+      },
+      SystemCode: {
+        type: Sequelize.STRING(10),
+        allowNull: false,
+      },
+      AccSystemCode: {
+        type: Sequelize.STRING(10),
+        allowNull: false,
+      },
+      AccSystemAccountId: {
+        type: Sequelize.STRING(10),
+        allowNull: false,
+      },
+      Name: {
+        type: Sequelize.STRING(200),
+        allowNull: true,
+      },
+      Description: {
+        type: Sequelize.TEXT,
+        allowNull: true,
+      },
+      AccountType: {
+        type: Sequelize.STRING(100),
+        allowNull: false,
+      },
+      AccountSubtype: {
+        type: Sequelize.STRING(100),
+        allowNull: true,
+      },
+      OwnerId: {
+        type: Sequelize.STRING(30),
+        allowNull: true,
+      },
+      OwnerType: {
+        type: Sequelize.STRING(200),
+        allowNull: true,
+      },
+      RelatedObjectId: {
+        type: Sequelize.STRING(30),
+        allowNull: true,
+      },
+      RelatedObjectType: {
+        type: Sequelize.STRING(200),
+        allowNull: true,
+      },
+      CreatedAt: {
+        allowNull: false,
+        defaultValue: new Date(),
+        type: Sequelize.DATE,
+      },
+      CreatedById: {
+        allowNull: false,
+        type: Sequelize.STRING,
+      },
+      UpdatedAt: {
+        allowNull: true,
+        defaultValue: new Date(),
+        type: Sequelize.DATE,
+      },
+      UpdatedById: {
+        allowNull: true,
+        type: Sequelize.STRING,
+      },
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable('finance_Account');
+  },
+};

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

@@ -0,0 +1,99 @@
+'use strict';
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable('finance_DocumentItem', {
+      DocumentItemId: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        primaryKey: true,
+      },
+      DocNo:{
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        references: {
+          model: 'finance_Document',
+          key: 'DocNo',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+      Name:{
+        type: Sequelize.STRING(200),
+        allowNull: false,
+      },
+      NameBM:{
+        type: Sequelize.STRING(200),
+        allowNull: false,
+      },
+      Description: {
+        type: Sequelize.STRING(1000),
+        allowNull: true,
+      },
+      ItemId: {
+        type: Sequelize.STRING(30),
+        allowNull: true,
+      },
+      ItemType: {
+        type: Sequelize.STRING(200),
+        allowNull: true,
+      },
+      ItemSKU: {
+        type: Sequelize.STRING(30),
+        allowNull: true,
+      },
+      ItemSerialNo: {
+        type: Sequelize.STRING(30),
+        allowNull: true,
+      },
+      Currency: {
+        type: Sequelize.CHAR(3),
+        allowNull: false,
+      },
+      UnitPrice: {
+        type: Sequelize.DECIMAL(10, 2),
+        allowNull: true,
+      },
+      Quantity: {
+        type: Sequelize.DECIMAL(10, 2),
+        allowNull: false,
+      },
+      QuantityUOM: {
+        type: Sequelize.STRING(20),
+        allowNull: true,
+      },
+      Amount: {
+        type: Sequelize.DECIMAL(10, 2),
+        allowNull: false,
+      },
+      TaxCode: {
+        type: Sequelize.STRING(30),
+        allowNull: true,
+      },
+      DtAccountNo:{
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        references: {
+          model: 'finance_Account',
+          key: 'AccountNo',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+      CtAccountNo:{
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        references: {
+          model: 'finance_Account',
+          key: 'AccountNo',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable('finance_DocumentItem');
+  },
+};

package/migrations/finance-document-migration.js

@@ -0,0 +1,77 @@
+'use strict';
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable('finance_Document', {
+      DocNo: {
+        type: Sequelize.STRING(30),
+        primaryKey: true,
+        allowNull: false,
+      },
+      DocType: {
+        type: Sequelize.ENUM(['Invoice', 'Debit Note', 'Credit Note', 'Quotation', 'Receipt']),
+        allowNull: false,
+      },
+      DocDate: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      SystemCode: {
+        type: Sequelize.STRING(10),
+        allowNull: false,
+      },
+      Currency: {
+        type: Sequelize.CHAR(3),
+        allowNull: false,
+      },
+      Amount: {
+        type: Sequelize.DECIMAL(10, 2),
+        allowNull: false,
+      },
+      Description: {
+        type: Sequelize.STRING(1000),
+        allowNull: false,
+      },
+      Status: {
+        type: Sequelize.STRING(20),
+        allowNull: false,
+      },
+      IssuedById: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+      },
+      IssuedToId: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+      },
+      IssuedToType: {
+        type: Sequelize.STRING(200),
+        allowNull: false,
+      },
+      AccSystemCode: {
+        type: Sequelize.STRING(10),
+        allowNull: false,
+      },
+      PostedToAccYN: {
+        type: Sequelize.CHAR(1),
+        allowNull: false,
+      },
+      UseAccSystemDocYN: {
+        type: Sequelize.CHAR(1),
+        allowNull: false,
+      },
+      DocPDFFilePath: {
+        type: Sequelize.STRING(500),
+        allowNull: false,
+      },
+      DocHTMLFilePath: {
+        type: Sequelize.STRING(500),
+        allowNull: false,
+      },
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable('finance_Document');
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomei/finance",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "NestJS package for finance module",
   "main": "dist/index.js",
   "scripts": {
@@ -34,7 +34,7 @@
     "@nestjs/core": "^9.0.8",
     "@nestjs/platform-express": "^9.0.8",
     "@nestjs/sequelize": "^9.0.0",
-    "@tomei/general": "^0.0.13",
+    "@tomei/general": "^0.0.14",
     "axios": "^1.1.3",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.13.2",

package/src/account/account.ts

@@ -1,66 +1,119 @@
-import { ICreateAccountAttr } from './interfaces/account-attr.interface';
 import { IAccountRepository } from './interfaces/account.repository.interface';
-import * as uniqid from 'uniqid';
 import { AccountModel } from './entities/account.entity';
-import axios from 'axios';
-import { getConfig } from '../config';
-import { IAccountSystem } from 'src/interfaces';
-import { ObjectBase, PersonBase } from '@tomei/general';
+import { ObjectBase, PersonBase, RecordNotFoundError } from '@tomei/general';
+import { IBaseRepository } from '@tomei/general/dist/interfaces/repository.base.interface';
 export class Account {
   accountRepository: IAccountRepository;
+  AccountNo: string;
+  Owner: PersonBase;
+  RelatedObject: ObjectBase;
 
-  private AccountNo: string;
+  private isNewRecord = true;
   private OwnerId: string;
   private OwnerType: string;
   private RelatedObjectId: string;
   private RelatedObjectType: string;
-  private AccSystemId: string;
-
-  ParentAccountNo: string;
-  Owner: PersonBase;
-  RelatedObject: ObjectBase;
-  AccountType: string;
-  AccountSubType: string;
-  AccountingSystem: IAccountSystem;
-
-  isParamsInitialized: boolean;
+  private ParentAccountNo: string;
+  private SystemCode: string;
+  private AccSystemAccountId: string;
+  private AccSystemCode: string;
+  private Name: string;
+  private Description: string;
+  private AccountType: string;
+  private AccountSubtype: string;
 
   constructor(
-    accountRepository: IAccountRepository,
-    accountingSystem: IAccountSystem,
-    SystemCode: string,
-    params?: ICreateAccountAttr,
+    accountRepository: IBaseRepository<AccountModel>,
+    accountNo: string,
   ) {
     this.accountRepository = accountRepository;
-    this.AccountingSystem = accountingSystem;
-    this.AccSystemId = getConfig().systemConfig[SystemCode].accountingSystem;
-    if (params) {
-      this.init(params);
+    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.AccSystemAccountId = accountData.AccSystemAccountId;
+      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;
     }
   }
 
-  init(params: ICreateAccountAttr) {
-    this.Owner = params.Owner;
-    this.OwnerId = params.Owner.ObjectId;
-    this.OwnerType = typeof params.Owner;
+  public get name(): string {
+    return this.Name;
+  }
 
-    if (params.RelatedObject) {
-      this.RelatedObject = params.RelatedObject;
-      this.RelatedObjectId = params.RelatedObject.ObjectId;
-      this.RelatedObjectType = typeof params.RelatedObject;
-    }
-    if (params.AccountType) this.AccountType = params.AccountType;
-    if (params.AccountSubType) this.AccountSubType = params.AccountSubType;
-    if (params.ParentAccountNo) this.ParentAccountNo = params.ParentAccountNo;
+  public get accountType(): string {
+    return this.AccountType;
+  }
+
+  public get accountSubType(): string {
+    return this.AccountSubtype;
+  }
 
-    if (
-      this.Owner &&
-      this.RelatedObject &&
-      this.AccountType &&
-      this.AccountSubType
-    ) {
-      this.isParamsInitialized = true;
+  public get parentAccountNo(): string {
+    return this.ParentAccountNo;
+  }
+
+  validateAccountValue() {
+    if (!this.SystemCode) {
+      throw new Error('SystemCode is required.');
+    }
+    if (!this.AccSystemCode) {
+      throw new Error('AccSystemCode is required.');
     }
+    if (!this.AccSystemAccountId) {
+      throw new Error('AccSystemAccountId is required.');
+    }
+    if (!this.AccountType) {
+      throw new Error('AccountType is required.');
+    }
+  }
+
+  isParentAccountExsits() {
+    if (this.ParentAccountNo) return true;
+    return false;
+  }
+
+  async save(
+    accSystemAccountId: string,
+    userId: string,
+    dbTransaction?: any,
+  ): Promise<AccountModel> {
+    this.AccSystemAccountId = accSystemAccountId;
+    const data = await this.accountRepository.create(
+      {
+        AccountNo: this.AccountNo,
+        SystemCode: this.SystemCode,
+        AccSystemCode: this.AccSystemCode,
+        AccSystemAccountId: this.AccSystemAccountId,
+        Name: this.Name,
+        Description: this.Description,
+        AccountType: this.AccountType,
+        AccountSubtype: this.AccountSubtype,
+        OwnerId: this.OwnerId,
+        OwnerType: this.OwnerType,
+        RelatedObjectId: this.RelatedObjectId,
+        RelatedObjectType: this.RelatedObjectType,
+        CreatedAt: new Date(),
+        CreatedById: userId,
+      },
+      dbTransaction,
+    );
+    return data;
   }
 
   /**
@@ -74,7 +127,7 @@ export class Account {
       try {
         const account = await this.accountRepository.findOne({
           OwnerId: this.OwnerId,
-          AccSystemId: this.AccSystemId,
+          AccSystemAccountId: this.AccSystemAccountId,
         });
 
         if (account) {
@@ -88,102 +141,4 @@ export class Account {
       }
     }
   }
-
-  /**
-   * This method will return finance_Account.AccountNo
-   * @returns {Promise<string>} AccountNo
-   */
-  async create() {
-    try {
-      if (!this.Owner || !this.RelatedObject) {
-        throw new Error(
-          'Owner must be set before creating an account." or "RelatedObject must be set before creating an account.',
-        );
-      }
-
-      if (!this.isParamsInitialized) {
-        throw new Error(
-          'Account parameters must be initialized before creating an account.',
-        );
-      }
-
-      const ownerData = this.Owner.getDetails();
-      if (!ownerData) {
-        throw new Error(
-          'Please save owner information in the database before creating an account',
-        );
-      }
-
-      let isFull = true;
-      for (const key in ownerData) {
-        if (ownerData.hasOwnProperty(key)) {
-          if (!ownerData[key]) {
-            isFull = false;
-            break;
-          }
-        }
-      }
-
-      if (!isFull) {
-        throw new Error(
-          'Please save owner information in the database before creating an account',
-        );
-      }
-
-      let createAccountPayload: any = {
-        Name: this.Owner.FullName,
-        AcctNum: uniqid(),
-        AccountType: this.AccountType,
-        AccountSubType: this.AccountSubType,
-      };
-
-      if (this.ParentAccountNo) {
-        createAccountPayload = {
-          ...createAccountPayload,
-          CurrencyRef: 'MYR',
-          ParentRef: this.ParentAccountNo,
-          SubAccount: true,
-        };
-      }
-
-      const accountId = await this.AccountingSystem.createAccount(
-        createAccountPayload,
-      );
-
-      const account = await this.accountRepository.create({
-        AccountNo: accountId,
-        SystemCode: this.AccSystemId,
-        Name: this.Owner.FullName,
-        OwnerId: this.OwnerId,
-        OwnerType: this.OwnerType,
-        RelatedObjectId: this.RelatedObjectId,
-        RelatedObjectType: this.RelatedObjectType,
-        CreatedAt: new Date(),
-        CreatedById: 'System',
-        UpdatedAt: new Date(),
-        UpdatedById: 'System',
-      });
-
-      const payload = {
-        Action: 'Create',
-        Activity: 'Account Created',
-        Description: `Account (ID: ${account.AccountNo}) has been created`,
-        EntityType: typeof AccountModel,
-        EntityValueBefore: JSON.stringify({}),
-        EntityValueAfter: JSON.stringify(account),
-        PerformedById: account.CreatedById,
-        PerformedAt: new Date(),
-        EntityId: account.AccountNo,
-      };
-
-      await axios.post(
-        `${process.env.COMMON_API_URL}/activity-histories`,
-        payload,
-      );
-
-      return account;
-    } catch (error) {
-      throw error;
-    }
-  }
 }