@tomei/finance 0.3.33 → 0.3.35

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

@@ -8,7 +8,9 @@ import {
   BelongsTo,
 } from 'sequelize-typescript';
 import AccountModel from './account.entity';
+import DocumentModel from './document.entity';
 import JournalEntryModel from './journal-entry.entity';
+import PaymentModel from './payment.entity';
 
 @Table({
   tableName: 'finance_LedgerTransaction',
@@ -56,22 +58,12 @@ export default class LedgerTransactionModel extends Model {
   })
   Date: Date;
 
-  @ApiProperty({
-    type: String,
-    description: 'Name of the ledger transaction',
-  })
-  @Column({
-    allowNull: false,
-    type: DataType.STRING(200),
-  })
-  Name: string;
-
   @ApiProperty({
     type: String,
     description: 'Description of the ledger transaction',
   })
   @Column({
-    allowNull: true,
+    allowNull: false,
     type: DataType.STRING(1000),
   })
   Description: string;
@@ -111,7 +103,7 @@ export default class LedgerTransactionModel extends Model {
     description: 'RelatedObjectId',
   })
   @Column({
-    allowNull: false,
+    allowNull: true,
     type: DataType.STRING(30),
   })
   RelatedObjectId: string;
@@ -121,14 +113,36 @@ export default class LedgerTransactionModel extends Model {
     description: 'RelatedObjectType',
   })
   @Column({
-    allowNull: false,
+    allowNull: true,
     type: DataType.STRING(200),
   })
   RelatedObjectType: string;
 
+  @ApiProperty({ type: String, description: 'DocNo' })
+  @ForeignKey(() => DocumentModel)
+  @Column({
+    allowNull: true,
+    type: DataType.STRING(30),
+  })
+  RelatedDocNo: string;
+
+  @ApiProperty({ type: String, description: 'PaymentId' })
+  @ForeignKey(() => PaymentModel)
+  @Column({
+    allowNull: true,
+    type: DataType.STRING(30),
+  })
+  RelatedPaymentId: string;
+
   @BelongsTo(() => AccountModel)
   Account: AccountModel;
 
   @BelongsTo(() => JournalEntryModel)
   JournalEntry: JournalEntryModel;
+
+  @BelongsTo(() => DocumentModel)
+  Document: DocumentModel;
+
+  @BelongsTo(() => PaymentModel)
+  Payment: PaymentModel;
 }

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

@@ -43,10 +43,16 @@ export default class PaymentItemModel extends Model {
   Amount: number;
 
   @Column({
-    type: DataType.STRING(30),
+    type: DataType.STRING(200),
     allowNull: true,
   })
-  TaxCode: string;
+  Name: string;
+
+  @Column({
+    type: DataType.STRING(1000),
+    allowNull: false,
+  })
+  Description: string;
 
   @BelongsTo(() => PaymentModel)
   Payment: PaymentModel;

package/src/models/payment-paid-with.entity.ts

@@ -0,0 +1,97 @@
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  BelongsTo,
+  Column,
+  DataType,
+  ForeignKey,
+  Model,
+  Table,
+} from 'sequelize-typescript';
+import { PaymentStatus } from '../enum';
+import PaymentMethodTypeModel from './payment-method-type.entity';
+import PaymentModel from './payment.entity';
+
+@Table({
+  tableName: 'finance_PaymentPaidWith',
+  createdAt: false,
+  updatedAt: false,
+})
+export default class PaymentPaidWithModel extends Model {
+  @ApiProperty({
+    example: 'cl6nzvo780000qcw38ihpd8w6',
+    description: 'PaymentId',
+  })
+  @ForeignKey(() => PaymentModel)
+  @Column({
+    primaryKey: true,
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  PaymentId: string;
+
+  @ApiProperty({
+    example: 'cl6nzvo780000qcw38ihpd8w6',
+    description: 'MethodTypeId',
+  })
+  @ForeignKey(() => PaymentMethodTypeModel)
+  @Column({
+    primaryKey: true,
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  MethodTypeId: string;
+
+  @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: PaymentStatus;
+
+  @Column({
+    allowNull: true,
+    type: DataType.STRING(100),
+  })
+  TransactionId: string;
+
+  @Column({
+    allowNull: true,
+    type: DataType.STRING(100),
+  })
+  TransactionApprovalCode: string;
+
+  @Column({
+    allowNull: true,
+    type: DataType.STRING(100),
+  })
+  TransactionApprovalName: string;
+
+  @Column({
+    allowNull: true,
+    type: DataType.STRING(100),
+  })
+  TransactionAccountNo: string;
+
+  @Column({
+    allowNull: true,
+    type: DataType.TEXT,
+  })
+  Remarks: string;
+
+  @BelongsTo(() => PaymentModel)
+  Payment: PaymentModel;
+
+  @BelongsTo(() => PaymentMethodTypeModel)
+  PaymentMethodType: PaymentMethodTypeModel;
+}

package/src/models/payment.entity.ts

@@ -1,18 +1,14 @@
 import { ApiProperty } from '@nestjs/swagger';
 import {
-  BelongsTo,
   Column,
   DataType,
-  ForeignKey,
   HasMany,
   Model,
   Table,
   UpdatedAt,
 } from 'sequelize-typescript';
 import { PaymentType, PaymentStatus } from '../enum';
-import FinanceCompanyModel from './finance-company.entity';
 import PaymentItemModel from './payment-item.entity';
-import PaymentMethodTypeModel from './payment-method-type.entity';
 
 @Table({
   tableName: 'finance_Payment',
@@ -39,27 +35,11 @@ export default class PaymentModel extends Model {
   })
   PaymentDate: Date;
 
-  @ApiProperty({
-    example: 'cl6nzvo780000qcw38ihpd8w6',
-    description: 'CompanyId',
-  })
-  @ForeignKey(() => FinanceCompanyModel)
-  @Column({
-    allowNull: false,
-    type: DataType.STRING(30),
-  })
-  CompanyId: string;
-
-  @ApiProperty({
-    example: 'cl6nzvo780000qcw38ihpd8w6',
-    description: 'MethodTypeId',
-  })
-  @ForeignKey(() => PaymentMethodTypeModel)
   @Column({
     allowNull: false,
-    type: DataType.STRING(30),
+    type: DataType.STRING(1000),
   })
-  MethodTypeId: string;
+  Description: string;
 
   @Column({
     allowNull: false,
@@ -170,10 +150,4 @@ export default class PaymentModel extends Model {
 
   @HasMany(() => PaymentItemModel)
   PaymentItems: PaymentItemModel[];
-
-  @BelongsTo(() => FinanceCompanyModel)
-  FinanceCompany: FinanceCompanyModel;
-
-  @BelongsTo(() => PaymentMethodTypeModel)
-  PaymentMethodType: PaymentMethodTypeModel;
 }

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

@@ -4,15 +4,10 @@ export class IPaymentAttr {
   PaymentId: string;
   PaymentType: PaymentType;
   PaymentDate: Date;
-  CompanyId: string;
-  MethodTypeId: string;
+  Description: string;
   Currency: string;
   Amount: number;
   Status: PaymentStatus;
-  TransactionId?: string;
-  TransactionApprovalCode?: string;
-  TransactionAccountName?: string;
-  TransactionAccountNo?: string;
   ReceivedBy: string;
   UpdatedAt: Date;
   UpdatedBy: string;

package/src/payment/payment.ts

@@ -7,29 +7,29 @@ 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';
+import PaymentPaidWith from '../payment-paid-with/payment-paid-with';
+import { PaymentPaidWithRepository } from 'src/payment-paid-with/payment-paid-with.repository';
 
 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;
+  Description = '';
+  Currency = 'MYR';
+  Amount = 0;
+  Status: PaymentStatus;
+  ReceivedBy = '';
+  UpdatedBy = '';
+  UpdatedAt: Date;
+  Remarks = '';
 
   private static _RepositoryBase = new PaymentRepository();
   private static _PaymentItemRepository = new PaymentItemRepository();
+  private static _PaymentPaidWithRepository = new PaymentPaidWithRepository();
 
   private _DbTransaction: any;
   private _PaymentItems = [];
+  private _PaymentPaidWith = [];
 
   paymentItemRepository: PaymentItemRepository;
 
@@ -41,38 +41,6 @@ export default class Payment extends AccountSystemEntity {
     this._PaymentId = id;
   }
 
-  public get Status() {
-    return this._Status;
-  }
-
-  private set Status(status: PaymentStatus) {
-    this._Status = status;
-  }
-
-  public get ReceivedBy() {
-    return this._ReceivedBy;
-  }
-
-  public set ReceivedBy(id: string) {
-    this._ReceivedBy = id;
-  }
-
-  public get UpdatedBy() {
-    return this._UpdatedBy;
-  }
-
-  private set UpdatedBy(id: string) {
-    this._UpdatedBy = id;
-  }
-
-  public get UpdatedAt() {
-    return this._UpdatedAt;
-  }
-
-  private set UpdatedAt(date: Date) {
-    this._UpdatedAt = date;
-  }
-
   /* AccountSystemEntity Implementation */
   get RepositoryBase() {
     return Payment._RepositoryBase;
@@ -107,15 +75,10 @@ export default class Payment extends AccountSystemEntity {
           if (paymentData) {
             this.PaymentType = paymentData.PaymentType;
             this.PaymentDate = paymentData.PaymentDate;
-            this.CompanyId = paymentData.CompanyId;
-            this.MethodTypeId = paymentData.MethodTypeId;
+            this.Description = paymentData.Description;
             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;
@@ -190,12 +153,54 @@ export default class Payment extends AccountSystemEntity {
     });
   }
 
+  get PaymentPaidWith(): Promise<PaymentPaidWith[]> {
+    return new Promise((resolve, reject) => {
+      if (this.PaymentId !== 'New') {
+        Payment._PaymentPaidWithRepository
+          .findAll({
+            where: {
+              PaymentId: this.PaymentId,
+            },
+            transaction: this._DbTransaction,
+          })
+          .then((paymentPaidWithItems) => {
+            const paymentPaidWithObjects = paymentPaidWithItems.map(
+              (paymentPaidWithItem) => {
+                new PaymentPaidWith(
+                  new Payment(
+                    this._DbTransaction,
+                    paymentPaidWithItem.PaymentId,
+                  ),
+                  paymentPaidWithItem.MethodTypeId,
+                );
+              },
+            );
+            return Promise.all(paymentPaidWithObjects);
+          })
+          .then((paymentPaidWithObjects) => {
+            this._PaymentPaidWith = paymentPaidWithObjects;
+            resolve(this._PaymentPaidWith);
+          })
+          .catch((err) => {
+            reject(err);
+          });
+      }
+      resolve(this._PaymentItems);
+    });
+  }
+
   newPaymentItem(objectBeingPaidFor: ObjectBase): PaymentItem {
     const paymentItem = new PaymentItem(this, objectBeingPaidFor);
     this._PaymentItems.push(paymentItem);
     return paymentItem;
   }
 
+  newPaymentPaidWIth(paymentMethodId: string) {
+    const paymentPaidWith = new PaymentPaidWith(this, paymentMethodId);
+    this._PaymentPaidWith.push(paymentPaidWith);
+    return paymentPaidWith;
+  }
+
   init(Params: IPaymentParams): void {
     if (Params.Currency) this.Currency = Params.Currency;
     if (Params.PaymentType) this.PaymentType = Params.PaymentType;

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

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

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

@@ -2,11 +2,14 @@ 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;
+  private _PaymentId = '';
+  private _PayForObjectId = '';
+  private _PayForObjectType = '';
   Currency = 'MYR';
   Amount = 0;
+  Name = '';
+  Description = '';
+  Remarks = '';
 
   get PaymentId() {
     return this._PaymentId;

package/src/payment-paid-with/interfaces/payment-paid-with.interface.ts

@@ -0,0 +1,14 @@
+import { PaymentStatus } from '../../enum';
+
+export class IPaymentPaidWithAttr {
+  PaymentId: string;
+  MethodTypeId: string;
+  Currency: string;
+  Amount: number;
+  Status: PaymentStatus;
+  TransactionId?: string;
+  TransactionApprovalCode?: string;
+  TransactionApprovalName?: string;
+  TransactionAccountNo?: string;
+  Remarks?: string;
+}

package/src/payment-paid-with/payment-paid-with.repository.ts

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

package/src/payment-paid-with/payment-paid-with.ts

@@ -0,0 +1,54 @@
+import { ObjectBase } from '@tomei/general';
+import { PaymentStatus } from '../enum';
+import Payment from '../payment/payment';
+import { PaymentPaidWithRepository } from './payment-paid-with.repository';
+
+export default class PaymentPaidWith extends ObjectBase {
+  private _PaymentId = '';
+  private _MethodTypeId = '';
+  Currency = 'MYR';
+  Amount = 0;
+  Status: PaymentStatus;
+  TransactionId = '';
+  TransactionApprovalCode = '';
+  TransactionApprovalName = '';
+  TransactionAccountNo = '';
+  Remarks = '';
+
+  private static _RepositoryBase = new PaymentPaidWithRepository();
+
+  public get PaymentId() {
+    return this._PaymentId;
+  }
+
+  public set PaymentId(id: string) {
+    this._PaymentId = id;
+  }
+
+  public get MethodTypeId() {
+    return this._MethodTypeId;
+  }
+
+  public set MethodTypeId(id: string) {
+    this._MethodTypeId = id;
+  }
+
+  /* ObjectBase Implementation */
+  get ObjectId() {
+    return '';
+  }
+
+  get ObjectName() {
+    return '';
+  }
+
+  get TableName() {
+    return 'finance_PaymentPaidWith';
+  }
+
+  constructor(payment: Payment, paymentMethodTypeId: string) {
+    super();
+    this.PaymentId = payment.PaymentId;
+    this.MethodTypeId = paymentMethodTypeId;
+  }
+}