gemcap-be-common 1.3.97 → 1.3.99

package/services/loan-transactions.service.ts

@@ -5,7 +5,6 @@ import Decimal from 'decimal.js';
 
 import { IEmail } from '../interfaces/email.interface';
 import { calculateTimeZone } from '../helpers/date.helper';
-import { roundToXDigits } from '../helpers/numbers.helper';
 import { createFilteredObject } from '../helpers/common.helper';
 import { IPaginatorOptions } from '../interfaces/collaterals.interface';
 import { BBCDateModel } from '../models/BBCDate.model';
@@ -400,7 +399,7 @@ export class LoanTransactionsService {
     }
   }
 
-  async recalculateBalance(transactionId: string) {
+  async recalculateBalanceLegacy(transactionId: string) {
     const changedTransaction = await LoanTransaction.findById<ILoanTransactionDoc & {
       createdAt: Date
     }>(transactionId);
@@ -408,127 +407,240 @@ export class LoanTransactionsService {
       console.error(`no transactions with id ${transactionId}`);
       return;
     }
-    setTimeout(async () => {
-      await LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isBalanceActual: false });
-      const previousTransaction = await LoanTransaction.aggregate<ILoanTransactionDoc>([
-        {
-          $match: {
-            'productId': new mongoose.Types.ObjectId(changedTransaction.productId.toString()),
-            'date': { $lt: new Date(changedTransaction.date) },
-          },
-        }, {
-          $sort: {
-            'date': -1,
-            'order': -1,
-            'createdAt': -1,
-          },
-        }, {
-          $limit: 1,
-        },
-      ]);
-      let currentBalance = previousTransaction.length
-        ? previousTransaction[0].balance ?? 0
-        : 0;
-      const recalculatedTransactions = await LoanTransaction.aggregate<ILoanTransactionDoc>([
-        {
-          $match: {
-            'productId': new mongoose.Types.ObjectId(changedTransaction.productId.toString()),
-            'date': { $gte: new Date(changedTransaction.date) },
-          },
-        }, {
-          $sort: {
-            'date': 1,
-            'order': 1,
-            'createdAt': 1,
-          },
-        },
-      ]);
-      for (const transaction of recalculatedTransactions) {
-        currentBalance = new Decimal(currentBalance).add(transaction.amount).toNumber();
-        await LoanTransaction.findByIdAndUpdate(transaction._id, { balance: currentBalance });
+
+    const recalcBalance = async () => {
+      const session = await mongoose.startSession();
+      try {
+        await session.withTransaction(async () => {
+          await LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isBalanceActual: false });
+          const previousTransaction = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+            {
+              $match: {
+                'productId': new mongoose.Types.ObjectId(changedTransaction.productId.toString()),
+                'date': { $lt: new Date(changedTransaction.date) },
+              },
+            }, {
+              $sort: {
+                'date': -1,
+                'order': -1,
+                'createdAt': -1,
+              },
+            }, {
+              $limit: 1,
+            },
+          ]);
+          let currentBalance = previousTransaction.length
+            ? previousTransaction[0].balance ?? 0
+            : 0;
+          const recalculatedTransactions = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+            {
+              $match: {
+                'productId': new mongoose.Types.ObjectId(changedTransaction.productId.toString()),
+                'date': { $gte: new Date(changedTransaction.date) },
+              },
+            }, {
+              $sort: {
+                'date': 1,
+                'order': 1,
+                'createdAt': 1,
+              },
+            },
+          ]);
+          for (const transaction of recalculatedTransactions) {
+            currentBalance = new Decimal(currentBalance).add(transaction.amount).toNumber();
+            await LoanTransaction.findByIdAndUpdate(transaction._id, { balance: currentBalance });
+          }
+          await LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isBalanceActual: true });
+        });
+      } finally {
+        await session.endSession();
       }
-      await LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isBalanceActual: true });
-    });
-    setTimeout(async () => {
-      await LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isFloatedBalanceActual: false });
-      const previousEqualBalancesTransaction = await LoanTransaction.aggregate<ILoanTransactionDoc>([
-        {
-          $match: {
-            'productId': new mongoose.Types.ObjectId(changedTransaction.productId.toString()),
-            'date': { $lt: new Date(changedTransaction.date) },
-            $expr: { $eq: ['$balance', '$floatedBalance'] },
+    };
+
+    const recalcFloatedBalance = async () => {
+      const session = await mongoose.startSession();
+      try {
+        await session.withTransaction(async () => {
+          await LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isFloatedBalanceActual: false });
+          const previousEqualBalancesTransaction = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+            {
+              $match: {
+                'productId': new mongoose.Types.ObjectId(changedTransaction.productId.toString()),
+                'date': { $lt: new Date(changedTransaction.date) },
+                $expr: { $eq: ['$balance', '$floatedBalance'] },
+              },
+            }, {
+              $sort: {
+                'date': -1,
+                'order': -1,
+                'createdAt': -1,
+              },
+            }, {
+              $limit: 1,
+            },
+          ]);
+          let currentFloatedBalance = 0;
+          if (previousEqualBalancesTransaction.length) {
+            const previousTransaction = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+              {
+                $match: {
+                  'productId': new mongoose.Types.ObjectId(previousEqualBalancesTransaction[0].productId.toString()),
+                  'date': { $lt: new Date(previousEqualBalancesTransaction[0].date) },
+                },
+              }, {
+                $sort: {
+                  'date': -1,
+                  'order': -1,
+                  'createdAt': -1,
+                },
+              }, {
+                $limit: 1,
+              },
+            ]);
+            if (previousTransaction.length) {
+              currentFloatedBalance = previousTransaction[0].floatedBalance;
+            }
+          }
+          const initTransaction = previousEqualBalancesTransaction.length ? previousEqualBalancesTransaction[0] : changedTransaction;
+          const recalculatedTransactions = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+            {
+              $match: {
+                'productId': new mongoose.Types.ObjectId(initTransaction.productId.toString()),
+                'date': { $gte: new Date(initTransaction.date) },
+              },
+            }, {
+              $sort: {
+                'date': 1,
+                'order': 1,
+                'createdAt': 1,
+              },
+            },
+          ]);
+          for (const transaction of recalculatedTransactions) {
+            const totalPostponed = await getPostponedTransactions(transaction.date, transaction.productId.toString(), true);
+            switch (transaction.transactionType) {
+              case ELoanTransactionTypes.COLLECTION:
+                await this.cleanRecalculated(transaction._id.toString());
+                await this.createPostponedTransaction(transaction);
+                currentFloatedBalance = new Decimal(currentFloatedBalance).add(totalPostponed).toNumber();
+                break;
+              case ELoanTransactionTypes.DISBURSEMENT:
+                currentFloatedBalance = new Decimal(currentFloatedBalance).add(transaction.amount).add(totalPostponed).toNumber();
+                break;
+              case ELoanTransactionTypes.ADJUSTMENT:
+                currentFloatedBalance = new Decimal(currentFloatedBalance).add(transaction.amount).add(totalPostponed).toNumber();
+                break;
+            }
+            await LoanTransaction.findByIdAndUpdate(transaction._id, { floatedBalance: currentFloatedBalance });
+          }
+          await LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isFloatedBalanceActual: true });
+        });
+      } finally {
+        await session.endSession();
+      }
+    };
+
+    await recalcBalance();
+    await recalcFloatedBalance();
+  }
+
+  async recalculateBalance(transactionId: string) {
+    const startTransaction = await LoanTransaction.findById(transactionId).lean();
+    if (!startTransaction) {
+      console.error(`Transaction not found: ${transactionId}`);
+      return;
+    }
+
+    const session = await mongoose.startSession();
+    try {
+      await session.withTransaction(async () => {
+        // Получаем все транзакции, начиная с самой ранней, которую нужно пересчитать
+        const earliestTransaction = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+          {
+            $match: {
+              productId: startTransaction.productId,
+              date: { $lte: new Date(startTransaction.date) }
+            }
           },
-        }, {
-          $sort: {
-            'date': 1,
-            'order': 1,
-            'createdAt': 1,
+          { $sort: { date: 1, order: 1, createdAt: 1 } },
+          { $limit: 1 }
+        ]);
+
+        const fromDate = earliestTransaction.length
+          ? earliestTransaction[0].date
+          : startTransaction.date;
+
+        const allTransactions = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+          {
+            $match: {
+              productId: startTransaction.productId,
+              date: { $gte: fromDate }
+            }
           },
-        }, {
-          $limit: 1,
-        },
-      ]);
-      let currentFloatedBalance = 0;
-      if (previousEqualBalancesTransaction.length) {
-        const previousTransaction = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+          { $sort: { date: 1, order: 1, createdAt: 1 } }
+        ]);
+
+        let balance = 0;
+        let floatedBalance = 0;
+
+        // Найдём стартовые значения
+        const prevBeforeStart = await LoanTransaction.aggregate<ILoanTransactionDoc>([
           {
             $match: {
-              'productId': new mongoose.Types.ObjectId(previousEqualBalancesTransaction[0].productId.toString()),
-              'date': { $lt: new Date(previousEqualBalancesTransaction[0].date) },
-            },
-          }, {
-            $sort: {
-              'date': -1,
-              'order': -1,
-              'createdAt': -1,
-            },
-          }, {
-            $limit: 1,
+              productId: startTransaction.productId,
+              date: { $lt: fromDate }
+            }
           },
+          { $sort: { date: -1, order: -1, createdAt: -1 } },
+          { $limit: 1 }
         ]);
-        if (previousTransaction.length) {
-          currentFloatedBalance = previousTransaction[0].floatedBalance;
+
+        if (prevBeforeStart.length) {
+          balance = prevBeforeStart[0].balance || 0;
+          floatedBalance = prevBeforeStart[0].floatedBalance || 0;
         }
-      }
-      const initTransaction = previousEqualBalancesTransaction.length ? previousEqualBalancesTransaction[0] : changedTransaction;
-      const recalculatedTransactions = await LoanTransaction.aggregate<ILoanTransactionDoc>([
-        {
-          $match: {
-            'productId': new mongoose.Types.ObjectId(initTransaction.productId.toString()),
-            'date': { $gte: new Date(initTransaction.date) },
-          },
-        }, {
-          $sort: {
-            'date': 1,
-            'order': 1,
-            'createdAt': 1,
-          },
-        },
-      ]);
-      for (const transaction of recalculatedTransactions) {
-        const totalPostponed = await getPostponedTransactions(transaction.date, transaction.productId.toString(), true);
-        switch (transaction.transactionType) {
-          case ELoanTransactionTypes.COLLECTION:
-            await this.cleanRecalculated(transaction._id.toString());
-            await this.createPostponedTransaction(transaction);
-            currentFloatedBalance = roundToXDigits(currentFloatedBalance + totalPostponed);
-            break;
-          case ELoanTransactionTypes.DISBURSEMENT:
-            currentFloatedBalance = roundToXDigits(currentFloatedBalance + transaction.amount + totalPostponed);
-            break;
-          case ELoanTransactionTypes.ADJUSTMENT:
-            currentFloatedBalance = roundToXDigits(currentFloatedBalance + transaction.amount + totalPostponed);
-            break;
+
+        // Один проход для расчёта balance и floatedBalance
+        for (const tr of allTransactions) {
+          // Пересчёт обычного баланса
+          balance = new Decimal(balance).add(tr.amount).toNumber();
+
+          // Пересчёт floatedBalance
+          const totalPostponed = await getPostponedTransactions(tr.date, tr.productId.toString(), true);
+          switch (tr.transactionType) {
+            case ELoanTransactionTypes.COLLECTION:
+              await this.cleanRecalculated(tr._id.toString());
+              await this.createPostponedTransaction(tr);
+              floatedBalance = new Decimal(floatedBalance).add(totalPostponed).toNumber();
+              break;
+            case ELoanTransactionTypes.DISBURSEMENT:
+            case ELoanTransactionTypes.ADJUSTMENT:
+              floatedBalance = new Decimal(floatedBalance).add(tr.amount).add(totalPostponed).toNumber();
+              break;
+          }
+
+          await LoanTransaction.updateOne(
+            { _id: tr._id },
+            { balance, floatedBalance },
+            { session }
+          );
         }
-        await LoanTransaction.findByIdAndUpdate(transaction._id, { floatedBalance: currentFloatedBalance });
-      }
-      await LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isFloatedBalanceActual: true });
-    }, 1_000);
+
+        await LoanProduct.updateOne(
+          { _id: startTransaction.productId },
+          { isBalanceActual: true, isFloatedBalanceActual: true },
+          { session }
+        );
+      });
+    } finally {
+      await session.endSession();
+    }
   }
 
   async deleteLoanTransaction(transactionId: string, updateLoanPayment: boolean, userId = null) {
     const currentTransaction = await LoanTransaction.findById(transactionId).lean();
     if (!currentTransaction) {
+      console.error(`no transactions with id ${transactionId}`);
       return;
     }
     const nextTransaction = await LoanTransaction.aggregate<ILoanTransactionDoc>([