@tomei/finance 0.3.34 → 0.3.35

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,28 +35,6 @@ 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),
-  })
-  MethodTypeId: string;
-
   @Column({
     allowNull: false,
     type: DataType.STRING(1000),
@@ -176,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,16 +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,30 +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 = '';
   Description = '';
   Currency = 'MYR';
   Amount = 0;
-  private _Status: PaymentStatus;
-  TransactionId = '';
-  TransactionApprovalCode = '';
-  TransactionAccountName = '';
-  TransactionAccountNo = '';
-  private _ReceivedBy = '';
-  private _UpdatedBy = '';
-  private _UpdatedAt: Date;
+  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;
 
@@ -42,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;
@@ -108,16 +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;
@@ -192,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

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

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

@@ -9,6 +9,7 @@ export default class PaymentItem extends ObjectBase {
   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;
+  }
+}