@tomei/finance 0.3.85 → 0.3.86

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

@@ -85,10 +85,10 @@ export default class LedgerTransaction {
           Currency: this.Currency,
           DebitAmount: this.DebitAmount,
           CreditAmount: this.CreditAmount,
-          RelatedObjectId: this.RelatedObjectId,
-          RelatedObjectType: this.RelatedObjectType,
-          RelatedDocNo: this.RelatedDocNo,
-          RelatedPaymentId: this.RelatedPaymentId,
+          RelatedObjectId: this.RelatedObjectId || undefined,
+          RelatedObjectType: this.RelatedObjectType || undefined,
+          RelatedDocNo: this.RelatedDocNo || undefined,
+          RelatedPaymentId: this.RelatedPaymentId || undefined,
         },
         { transaction: dbTransaction },
       );

package/src/payment/payment.ts

@@ -65,59 +65,47 @@ export default class Payment extends AccountSystemEntity {
       this._DbTransaction = dbTransaction;
     }
     if (paymentId) {
-      this.RepositoryBase.findOne({
+      this.PaymentId = paymentId;
+    }
+  }
+
+  static async initPayment(
+    dbTransaction: any,
+    paymentId: string,
+  ): Promise<Payment> {
+    try {
+      const paymentData = await this._RepositoryBase.findOne({
         where: {
           PaymentId: paymentId,
         },
         transaction: dbTransaction,
-      })
-        .then((paymentData) => {
-          if (paymentData) {
-            this.PaymentType = paymentData.PaymentType;
-            this.PaymentDate = paymentData.PaymentDate;
-            this.Description = paymentData.Description;
-            this.Currency = paymentData.Currency;
-            this.Amount = paymentData.Amount;
-            this.Status = paymentData.Status;
-            this.ReceivedBy = paymentData.ReceivedBy;
-            this.UpdatedAt = paymentData.UpdatedAt;
-            this.UpdatedBy = paymentData.UpdatedBy;
-            this.Remarks = paymentData.Remarks;
-            this.AccSystemRefId = paymentData.AccSystemRefId;
-            this.PostedToAccSystemYN = paymentData.PostedToAccSystemYN;
-            this.PostedById = paymentData.PostedById;
-            this.PostedDateTime = paymentData.PostedDateTime;
-          } else {
-            const notFoundError = new RecordNotFoundError('No Record Found.');
-            throw notFoundError;
-          }
-        })
-        .catch((err) => {
-          // tslint:disable-next-line:no-console
-          console.log('Payment Class constructor err: ', err);
-        });
+      });
+      if (paymentData) {
+        const payment = new Payment(dbTransaction, paymentId);
+        payment.PaymentType = paymentData.PaymentType;
+        payment.PaymentDate = paymentData.PaymentDate;
+        payment.Description = paymentData.Description;
+        payment.Currency = paymentData.Currency;
+        payment.Amount = paymentData.Amount;
+        payment.Status = paymentData.Status;
+        payment.ReceivedBy = paymentData.ReceivedBy;
+        payment.UpdatedAt = paymentData.UpdatedAt;
+        payment.UpdatedBy = paymentData.UpdatedBy;
+        payment.Remarks = paymentData.Remarks;
+        payment.AccSystemRefId = paymentData.AccSystemRefId;
+        payment.PostedToAccSystemYN = paymentData.PostedToAccSystemYN;
+        payment.PostedById = paymentData.PostedById;
+        payment.PostedDateTime = paymentData.PostedDateTime;
+        return payment;
+      } else {
+        const notFoundError = new RecordNotFoundError('No Record Found.');
+        throw notFoundError;
+      }
+    } catch (error) {
+      console.log('Payment Class constructor err: ', error);
     }
   }
 
-  // public get PaymentItems() {
-  //   if (this._PaymentItems === null) {
-  //     this._PaymentItems = new Array<PaymentItemModel>();
-  //     if (this.PaymentId !== 'New') {
-  //       this.paymentItemRepository
-  //         .findAll({
-  //           where: {
-  //             PaymentId: this.PaymentId,
-  //           },
-  //         })
-  //         .then((allPaymentItems) => {
-  //           this._PaymentItems = allPaymentItems;
-  //         });
-  //     }
-  //   }
-
-  //   return this._PaymentItems;
-  // }
-
   get PaymentItems(): Promise<PaymentItem[]> {
     return new Promise((resolve, reject) => {
       if (this.PaymentId !== 'New') {
@@ -196,7 +184,11 @@ export default class Payment extends AccountSystemEntity {
   }
 
   newPaymentPaidWith(paymentMethodTypeId: string) {
-    const paymentPaidWith = new PaymentPaidWith(this, paymentMethodTypeId);
+    const paymentPaidWith = new PaymentPaidWith(
+      this,
+      paymentMethodTypeId,
+      this._DbTransaction,
+    );
     this._PaymentPaidWith.push(paymentPaidWith);
     return paymentPaidWith;
   }

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

@@ -20,27 +20,38 @@ export default class PaymentMethodType extends ObjectBase {
     }
     if (methodTypeId) {
       this.MethodTypeId = methodTypeId;
-      PaymentMethodType._RepositoryBase
-        .findOne({
-          where: {
-            MethodTypeId: this.MethodTypeId,
-          },
-          transaction: this._DbTransaction,
-        })
-        .then((paymentMethodTypeData) => {
-          if (paymentMethodTypeData) {
-            this.Name = paymentMethodTypeData.Name;
-            this.AccountNo = paymentMethodTypeData.AccountNo;
-            this.ProcessingFeeRate = paymentMethodTypeData.ProcessingFeeRate;
-            this.ProcessingFeeAccountNo =
-              paymentMethodTypeData.ProcessingFeeAccountNo;
-          } else {
-            throw new RecordNotFoundError('No record found.');
-          }
-        })
-        .catch((err) => {
-          console.log('Payment method type constructor err: ', err);
-        });
+    }
+  }
+
+  static async initMethodType(
+    dbTransaction: any,
+    methodTypeId: string,
+  ): Promise<PaymentMethodType> {
+    try {
+      const paymentMethodTypeData = await this._RepositoryBase.findOne({
+        where: {
+          MethodTypeId: methodTypeId,
+        },
+        transaction: dbTransaction,
+      });
+      if (paymentMethodTypeData) {
+        const paymentMethodType = new PaymentMethodType(
+          dbTransaction,
+          methodTypeId,
+        );
+        paymentMethodType.Name = paymentMethodTypeData.Name;
+        paymentMethodType.AccountNo = paymentMethodTypeData.AccountNo;
+        paymentMethodType.ProcessingFeeRate =
+          paymentMethodTypeData.ProcessingFeeRate;
+        paymentMethodType.ProcessingFeeAccountNo =
+          paymentMethodTypeData.ProcessingFeeAccountNo;
+        return paymentMethodType;
+      } else {
+        const notFoundError = new RecordNotFoundError('No Record Found.');
+        throw notFoundError;
+      }
+    } catch (error) {
+      console.log('Payment method type constructor err: ', error);
     }
   }
 

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

@@ -22,6 +22,7 @@ export default class PaymentPaidWith extends ObjectBase {
   PaymentMediaId = '';
 
   private static _RepositoryBase = new PaymentPaidWithRepository();
+  private _DbTransaction: any;
 
   public get PaymentId() {
     return this._PaymentId;
@@ -52,9 +53,16 @@ export default class PaymentPaidWith extends ObjectBase {
     return 'finance_PaymentPaidWith';
   }
 
-  constructor(payment: Payment, paymentMethodTypeId: string) {
+  constructor(
+    payment: Payment,
+    paymentMethodTypeId: string,
+    dbTransaction?: any,
+  ) {
     super();
     this.PaymentId = payment.PaymentId;
     this.MethodTypeId = paymentMethodTypeId;
+    if (dbTransaction) {
+      this._DbTransaction = dbTransaction;
+    }
   }
 }