@tomei/finance 0.1.3 → 0.1.4

package/migrations/finance-account-migration.js

@@ -1,59 +1,59 @@
-'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,
+      },
+      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');
+  },
+};

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

@@ -0,0 +1,39 @@
+'use strict';
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable('finance_PaymentItem', {
+      PaymentId: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        primaryKey: true,
+        references: {
+          model: 'finance_Payment',
+          key: 'PaymentId',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+      PayForObjectId: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+      },
+      PayForObjectType: {
+        type: Sequelize.STRING(200),
+        allowNull: false,
+      },
+      Currency: {
+        type: Sequelize.CHAR(3),
+        allowNull: false,
+      },
+      Amount: {
+        type: Sequelize.DECIMAL(10, 2),
+        allowNull: false,
+      },
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable('finance_PaymentItem');
+  },
+};

package/migrations/finance-payment-migration.js

@@ -0,0 +1,89 @@
+'use strict';
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable('finance_Payment', {
+      PaymentId: {
+        type: Sequelize.STRING(30),
+        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',
+        allowNull: false,
+      },
+      PaymentDate: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      Currency: {
+        type: Sequelize.CHAR(3),
+        allowNull: false,
+      },
+      Amount: {
+        type: Sequelize.DECIMAL(10, 2),
+        allowNull: false,
+      },
+      Status: {
+        type: Sequelize.STRING(20),
+        allowNull: false,
+      },
+      Method: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      MethodParty: {
+        type: Sequelize.STRING(255),
+        allowNull: false,
+      },
+      MethodAccountName: {
+        type: Sequelize.STRING(100),
+        allowNull: true,
+      },
+      MethodAccountNo: {
+        type: Sequelize.STRING(100),
+        allowNull: true,
+      },
+      TransactionId: {
+        type: Sequelize.STRING(100),
+        allowNull: true,
+      },
+      ApprovalId: {
+        type: Sequelize.STRING(100),
+        allowNull: true,
+      },
+      ReceivedBy: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+      },
+      UpdatedAt: {
+        allowNull: false,
+        defaultValue: new Date(),
+        type: Sequelize.DATE,
+      },
+      UpdatedBy: {
+        allowNull: false,
+        type: Sequelize.STRING,
+      },
+      Remarks: {
+        type: Sequelize.TEXT,
+        allowNull: true,
+      },
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable('finance_Payment');
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomei/finance",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "NestJS package for finance module",
   "main": "dist/index.js",
   "scripts": {
@@ -70,6 +70,6 @@
     ]
   },
   "dependencies": {
-    "@tomei/general": "^0.0.7"
+    "@tomei/general": "^0.0.10"
   }
 }

package/src/account/account.ts

@@ -9,6 +9,7 @@ import { IAccountSystem } from 'src/interfaces';
 export class Account {
   accountRepository: IAccountRepository;
 
+  private AccountNo: string;
   private OwnerId: string;
   private OwnerType: string;
   private RelatedObjectId: string;
@@ -54,6 +55,28 @@ export class Account {
     this.isParamsInitialized = true;
   }
 
+  async getAccountNo() {
+    if (this.AccountNo) {
+      return this.AccountNo;
+    } else {
+      try {
+        const account = await this.accountRepository.findOne({
+          OwnerId: this.OwnerId,
+          AccSystemId: this.AccSystemId,
+        });
+
+        if (account) {
+          this.AccountNo = account.AccountNo;
+          return this.AccountNo;
+        } else {
+          throw new Error('Account need to be created first.');
+        }
+      } catch (error) {
+        throw error;
+      }
+    }
+  }
+
   async create(userId: string, client: IAccountSystem, dbOptions: any) {
     try {
       if (!this.Owner || !this.RelatedObject) {
@@ -107,13 +130,13 @@ export class Account {
         };
       }
 
-      const data = await client.createAccount(createAccountPayload);
+      const accountId = await client.createAccount(createAccountPayload);
 
       const account = await this.accountRepository.create(
         {
-          AccountNo: data.Id,
+          AccountNo: accountId,
           SystemCode: this.AccSystemId,
-          Name: data.AcctNum,
+          Name: this.Owner.FullName,
           OwnerId: this.OwnerId,
           OwnerType: this.OwnerType,
           RelatedObjectId: this.RelatedObjectId,

package/src/account/entities/account.entity.ts

@@ -6,7 +6,9 @@ import {
   Table,
   DataType,
   UpdatedAt,
+  HasMany,
 } from 'sequelize-typescript';
+import { PaymentModel } from '../../payment/entities/payment.entity';
 
 @Table({ tableName: 'finance_Account', createdAt: false, updatedAt: false })
 export class AccountModel extends Model {
@@ -99,4 +101,7 @@ export class AccountModel extends Model {
   })
   @Column({ allowNull: false, type: DataType.STRING(30) })
   UpdatedById: string;
+
+  @HasMany(() => PaymentModel)
+  PaymentModel: PaymentModel[];
 }

package/src/customer/customer.ts

@@ -132,7 +132,7 @@ export class Customer extends PersonBase {
       await this.getDetails();
       await this.getDefaultAddress();
 
-      const customerData = await this.accountingSystem.createCustomer({
+      this.CustomerId = await this.accountingSystem.createCustomer({
         FullName: this.FullName,
         Email: this.Email,
         ContractNo: this.ContactNo,
@@ -141,9 +141,8 @@ export class Customer extends PersonBase {
 
       this.AccSystemId =
         getConfig().systemConfig[this.systemCode].accountingSystem;
-      this.CustomerId = customerData.Id;
       return await this.financeCustomerRepository.create({
-        CustomerId: customerData.Id,
+        CustomerId: this.CustomerId,
         AccSystemId: this.AccSystemId,
       });
     } catch (error) {

package/src/enum/index.ts

@@ -1,3 +1,5 @@
 import { ClientScopes } from './quick-book-client-scopes.enum';
+import { PaymentType } from './payment-type.enum';
+import { PaymentMethod } from './payment-method.enum';
 
-export { ClientScopes };
+export { ClientScopes, PaymentType, PaymentMethod };

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

@@ -0,0 +1,3 @@
+export enum PaymentMethod {
+  Cash = 'Cash', // example
+}

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

@@ -0,0 +1,4 @@
+export enum PaymentType {
+  PAYMENT_RECEIVED = 'Payment Received',
+  PAYOUT = 'Payout',
+}

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

@@ -1,3 +1,6 @@
+import { Customer } from '../customer';
+import { Payment } from '../payment';
+
 export interface IAccountSystem {
   createAccount(payload: any): Promise<any>;
   createInvoice(payload: any): Promise<any>;
@@ -5,4 +8,6 @@ export interface IAccountSystem {
   createCreditNote(payload: any): Promise<any>;
   postTransaction(payload: any): Promise<any>;
   createCustomer(payload: any): Promise<any>;
+  makePayment(customer: Customer, paymentInfo: Payment): Promise<any>;
+  collectPayments(customer: Customer, paymentInfo: Payment): Promise<any>;
 }

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

@@ -0,0 +1,47 @@
+import {
+  BelongsTo,
+  Column,
+  DataType,
+  ForeignKey,
+  Model,
+  Table,
+} from 'sequelize-typescript';
+import { PaymentModel } from './payment.entity';
+
+@Table({ tableName: 'finance_Payment', createdAt: false, updatedAt: false })
+export class PaymentItemModel extends Model {
+  @ForeignKey(() => PaymentModel)
+  @Column({
+    primaryKey: true,
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  PaymentId: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  PayForObjectId: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(100),
+  })
+  PayForObjectType: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.CHAR(3),
+  })
+  Currency: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.DECIMAL(10, 2),
+  })
+  Amount: number;
+
+  @BelongsTo(() => PaymentModel)
+  Payment: PaymentModel;
+}

package/src/payment/entities/payment.entity.ts

@@ -0,0 +1,125 @@
+import {
+  BelongsTo,
+  Column,
+  DataType,
+  ForeignKey,
+  HasMany,
+  Model,
+  Table,
+} from 'sequelize-typescript';
+import { PaymentType } from '../../enum/payment-type.enum';
+import { AccountModel } from '../../account/entities/account.entity';
+import { PaymentItemModel } from './payment-item.entity';
+
+@Table({ tableName: 'finance_Payment', createdAt: false, updatedAt: false })
+export class PaymentModel extends Model {
+  @Column({
+    primaryKey: true,
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  PaymentId: string;
+
+  @ForeignKey(() => AccountModel)
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  AccountNo: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  PaymentType: PaymentType;
+
+  @Column({
+    allowNull: false,
+    type: DataType.DATE,
+  })
+  PaymentDate: Date;
+
+  @Column({
+    allowNull: false,
+    type: DataType.CHAR(3),
+  })
+  Currency: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.DECIMAL(10, 2),
+  })
+  Amount: number;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  Status: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING,
+  })
+  Method: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(255),
+  })
+  MethodParty: string;
+
+  @Column({
+    allowNull: true,
+    type: DataType.STRING(100),
+  })
+  MethodAccountName: string;
+
+  @Column({
+    allowNull: true,
+    type: DataType.STRING(100),
+  })
+  MethodAccountNo: string;
+
+  @Column({
+    allowNull: true,
+    type: DataType.STRING(100),
+  })
+  TransactionId: string;
+
+  @Column({
+    allowNull: true,
+    type: DataType.STRING(100),
+  })
+  ApprovalId: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  ReceivedBy: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.DATE,
+  })
+  UpdatedAt: Date;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  UpdatedBy: string;
+
+  @Column({
+    allowNull: true,
+    type: DataType.TEXT,
+  })
+  Remarks: string;
+
+  @BelongsTo(() => AccountModel)
+  Account: AccountModel;
+
+  @HasMany(() => PaymentItemModel)
+  PaymentItems: PaymentItemModel[];
+}

package/src/payment/index.ts

@@ -0,0 +1,21 @@
+import { PaymentModel } from './entities/payment.entity';
+import { IPaymentAttr } from './interfaces/payment-attr.interface';
+import { IPaymentRepository } from './interfaces/payment.repository.interface';
+import { PaymentItemModel } from './entities/payment-item.entity';
+import { IPaymentItemAttr } from './interfaces/payment-item-attr.interface';
+import { IPaymentItemRepository } from './interfaces/payment-item.repository.interface';
+import { Payment } from './payment';
+import { PaymentRepository } from './payment.repository';
+import { PaymentItemRepository } from './payment-item.repository';
+
+export {
+  PaymentModel,
+  PaymentItemModel,
+  Payment,
+  PaymentRepository,
+  PaymentItemRepository,
+  IPaymentRepository,
+  IPaymentItemRepository,
+  IPaymentAttr,
+  IPaymentItemAttr,
+};

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

@@ -0,0 +1,21 @@
+import { PaymentType } from '../../enum';
+
+export class IPaymentAttr {
+  PaymentId: string;
+  AccountNo: string;
+  PaymentType: PaymentType;
+  PaymentDate: Date;
+  Currency: string;
+  Amount: number;
+  Status: string;
+  Method: string;
+  MethodParty: string;
+  MethodAccountName?: string;
+  MethodAccountNo?: string;
+  TransactionId?: string;
+  ApprovalId?: string;
+  ReceivedBy: string;
+  UpdatedAt: Date;
+  UpdatedBy: string;
+  Remarks?: string;
+}

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

@@ -0,0 +1,7 @@
+export class IPaymentItemAttr {
+  PaymentId: string;
+  PayForObjectId: string;
+  PayForObjectType: string;
+  Currency: string;
+  Amount: number;
+}

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

@@ -0,0 +1,4 @@
+import { IBaseRepository } from '@tomei/general';
+import { PaymentItemModel } from '../entities/payment-item.entity';
+
+export type IPaymentItemRepository = IBaseRepository<PaymentItemModel>;

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

@@ -0,0 +1,4 @@
+import { IBaseRepository } from '@tomei/general';
+import { PaymentModel } from '../entities/payment.entity';
+
+export type IPaymentRepository = IBaseRepository<PaymentModel>;

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

@@ -0,0 +1,44 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/sequelize';
+import { BaseRepository } from '@tomei/general';
+import { PaymentItemModel } from './entities/payment-item.entity';
+import { IPaymentItemAttr } from './interfaces/payment-item-attr.interface';
+import { IPaymentItemRepository } from './interfaces/payment-item.repository.interface';
+
+@Injectable()
+export class PaymentItemRepository
+  extends BaseRepository<PaymentItemModel>
+  implements IPaymentItemRepository
+{
+  constructor(
+    @InjectModel(PaymentItemModel)
+    private readonly paymentItemModel: typeof PaymentItemModel,
+  ) {
+    super(paymentItemModel);
+  }
+
+  create(
+    data: IPaymentItemAttr,
+    options?: any,
+  ): Promise<PaymentItemModel> | any {
+    return this.paymentItemModel.create({ ...data }, options);
+  }
+
+  findAll(options: any): Promise<PaymentItemModel[]> {
+    return this.paymentItemModel.findAll(options);
+  }
+
+  findAllWithPagination(
+    options: any,
+  ): Promise<{ count: number; rows: PaymentItemModel[] }> {
+    return this.paymentItemModel.findAndCountAll(options);
+  }
+
+  findOne(options: any): Promise<PaymentItemModel> {
+    return this.paymentItemModel.findOne(options);
+  }
+
+  update(data: IPaymentItemAttr, options?: any): any {
+    return this.paymentItemModel.update({ ...data }, options);
+  }
+}