gemcap-be-common 1.3.99 → 1.3.101

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gemcap-be-common",
-  "version": "1.3.99",
+  "version": "1.3.101",
   "description": "",
   "main": "index.js",
   "scripts": {

package/services/loan-transactions.service.js

@@ -313,11 +313,11 @@ class LoanTransactionsService {
             updatedTransaction = await LoanTransaction_model_1.LoanTransaction.findByIdAndUpdate(transaction._id, transaction, { new: true });
         }
         if (startId) {
-            await this.recalculateBalance(startId);
+            this.recalculateBalance(startId).catch(console.error);
         }
         const statementDate = this.loanStatementStatusService.getStatementDateForDate(new Date(transaction.date));
-        await this.loanStatementStatusService.updateStatementStatus(transaction.productId.toString(), statementDate, false);
-        await this.termLoanService.setTermLoanExpected(transaction.productId.toString());
+        this.loanStatementStatusService.updateStatementStatus(transaction.productId.toString(), statementDate, false).catch(console.error);
+        this.termLoanService.setTermLoanExpected(transaction.productId.toString()).catch(console.error);
         return updatedTransaction;
     }
     async recalculateProduct(productId) {
@@ -485,74 +485,64 @@ class LoanTransactionsService {
             console.error(`Transaction not found: ${transactionId}`);
             return;
         }
-        const session = await mongoose_1.default.startSession();
-        try {
-            await session.withTransaction(async () => {
-                // Получаем все транзакции, начиная с самой ранней, которую нужно пересчитать
-                const earliestTransaction = await LoanTransaction_model_1.LoanTransaction.aggregate([
-                    {
-                        $match: {
-                            productId: startTransaction.productId,
-                            date: { $lte: new Date(startTransaction.date) }
-                        }
-                    },
-                    { $sort: { date: 1, order: 1, createdAt: 1 } },
-                    { $limit: 1 }
-                ]);
-                const fromDate = earliestTransaction.length
-                    ? earliestTransaction[0].date
-                    : startTransaction.date;
-                const allTransactions = await LoanTransaction_model_1.LoanTransaction.aggregate([
-                    {
-                        $match: {
-                            productId: startTransaction.productId,
-                            date: { $gte: fromDate }
-                        }
-                    },
-                    { $sort: { date: 1, order: 1, createdAt: 1 } }
-                ]);
-                let balance = 0;
-                let floatedBalance = 0;
-                // Найдём стартовые значения
-                const prevBeforeStart = await LoanTransaction_model_1.LoanTransaction.aggregate([
-                    {
-                        $match: {
-                            productId: startTransaction.productId,
-                            date: { $lt: fromDate }
-                        }
-                    },
-                    { $sort: { date: -1, order: -1, createdAt: -1 } },
-                    { $limit: 1 }
-                ]);
-                if (prevBeforeStart.length) {
-                    balance = prevBeforeStart[0].balance || 0;
-                    floatedBalance = prevBeforeStart[0].floatedBalance || 0;
-                }
-                // Один проход для расчёта balance и floatedBalance
-                for (const tr of allTransactions) {
-                    // Пересчёт обычного баланса
-                    balance = new decimal_js_1.default(balance).add(tr.amount).toNumber();
-                    // Пересчёт floatedBalance
-                    const totalPostponed = await (0, loan_products_db_1.getPostponedTransactions)(tr.date, tr.productId.toString(), true);
-                    switch (tr.transactionType) {
-                        case LoanTransaction_model_1.ELoanTransactionTypes.COLLECTION:
-                            await this.cleanRecalculated(tr._id.toString());
-                            await this.createPostponedTransaction(tr);
-                            floatedBalance = new decimal_js_1.default(floatedBalance).add(totalPostponed).toNumber();
-                            break;
-                        case LoanTransaction_model_1.ELoanTransactionTypes.DISBURSEMENT:
-                        case LoanTransaction_model_1.ELoanTransactionTypes.ADJUSTMENT:
-                            floatedBalance = new decimal_js_1.default(floatedBalance).add(tr.amount).add(totalPostponed).toNumber();
-                            break;
-                    }
-                    await LoanTransaction_model_1.LoanTransaction.updateOne({ _id: tr._id }, { balance, floatedBalance }, { session });
-                }
-                await LoanProducts_model_1.LoanProduct.updateOne({ _id: startTransaction.productId }, { isBalanceActual: true, isFloatedBalanceActual: true }, { session });
-            });
+        // Получаем все транзакции, начиная с самой ранней, которую нужно пересчитать
+        const earliestTransaction = await LoanTransaction_model_1.LoanTransaction.aggregate([
+            {
+                $match: {
+                    productId: startTransaction.productId,
+                    date: { $lte: new Date(startTransaction.date) },
+                },
+            },
+            { $sort: { date: 1, order: 1, createdAt: 1 } },
+            { $limit: 1 },
+        ]);
+        const fromDate = earliestTransaction.length
+            ? earliestTransaction[0].date
+            : startTransaction.date;
+        const allTransactions = await LoanTransaction_model_1.LoanTransaction.aggregate([
+            {
+                $match: {
+                    productId: startTransaction.productId,
+                    date: { $gte: fromDate },
+                },
+            },
+            { $sort: { date: 1, order: 1, createdAt: 1 } },
+        ]);
+        let balance = 0;
+        let floatedBalance = 0;
+        const prevBeforeStart = await LoanTransaction_model_1.LoanTransaction.aggregate([
+            {
+                $match: {
+                    productId: startTransaction.productId,
+                    date: { $lt: fromDate },
+                },
+            },
+            { $sort: { date: -1, order: -1, createdAt: -1 } },
+            { $limit: 1 },
+        ]);
+        if (prevBeforeStart.length) {
+            balance = prevBeforeStart[0].balance || 0;
+            floatedBalance = prevBeforeStart[0].floatedBalance || 0;
         }
-        finally {
-            await session.endSession();
+        for (const tr of allTransactions) {
+            // regular balance recalculation
+            balance = new decimal_js_1.default(balance).add(tr.amount).toNumber();
+            // floatedBalance recalculation
+            const totalPostponed = await (0, loan_products_db_1.getPostponedTransactions)(tr.date, tr.productId.toString(), true);
+            switch (tr.transactionType) {
+                case LoanTransaction_model_1.ELoanTransactionTypes.COLLECTION:
+                    await this.cleanRecalculated(tr._id.toString());
+                    await this.createPostponedTransaction(tr);
+                    floatedBalance = new decimal_js_1.default(floatedBalance).add(totalPostponed).toNumber();
+                    break;
+                case LoanTransaction_model_1.ELoanTransactionTypes.DISBURSEMENT:
+                case LoanTransaction_model_1.ELoanTransactionTypes.ADJUSTMENT:
+                    floatedBalance = new decimal_js_1.default(floatedBalance).add(tr.amount).add(totalPostponed).toNumber();
+                    break;
+            }
+            await LoanTransaction_model_1.LoanTransaction.updateOne({ _id: tr._id }, { balance, floatedBalance });
         }
+        await LoanProducts_model_1.LoanProduct.updateOne({ _id: startTransaction.productId }, { isBalanceActual: true, isFloatedBalanceActual: true });
     }
     async deleteLoanTransaction(transactionId, updateLoanPayment, userId = null) {
         const currentTransaction = await LoanTransaction_model_1.LoanTransaction.findById(transactionId).lean();
@@ -587,11 +577,11 @@ class LoanTransactionsService {
             }
         }
         if (nextTransaction.length) {
-            await this.recalculateBalance(nextTransaction[0]._id.toString());
+            this.recalculateBalance(nextTransaction[0]._id.toString()).catch(console.error);
         }
         const statementDate = this.loanStatementStatusService.getStatementDateForDate(new Date(currentTransaction.date));
-        await this.loanStatementStatusService.updateStatementStatus(currentTransaction.productId.toString(), statementDate, false);
-        await this.termLoanService.setTermLoanExpected(currentTransaction.productId.toString());
+        this.loanStatementStatusService.updateStatementStatus(currentTransaction.productId.toString(), statementDate, false).catch(console.error);
+        this.termLoanService.setTermLoanExpected(currentTransaction.productId.toString()).catch(console.error);
     }
     async createPostponedTransaction(transaction) {
         const currentDay = (0, dayjs_1.default)(new Date(transaction.date)).format('YYYY-MM-DD');

package/services/loan-transactions.service.ts

@@ -371,11 +371,11 @@ export class LoanTransactionsService {
       updatedTransaction = await LoanTransaction.findByIdAndUpdate(transaction._id, transaction, { new: true });
     }
     if (startId) {
-      await this.recalculateBalance(startId);
+      this.recalculateBalance(startId).catch(console.error);
     }
     const statementDate = this.loanStatementStatusService.getStatementDateForDate(new Date(transaction.date));
-    await this.loanStatementStatusService.updateStatementStatus(transaction.productId.toString(), statementDate, false);
-    await this.termLoanService.setTermLoanExpected(transaction.productId.toString());
+    this.loanStatementStatusService.updateStatementStatus(transaction.productId.toString(), statementDate, false).catch(console.error);
+    this.termLoanService.setTermLoanExpected(transaction.productId.toString()).catch(console.error);
     return updatedTransaction;
   }
 
@@ -551,90 +551,79 @@ export class LoanTransactionsService {
       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 } },
-          { $limit: 1 }
-        ]);
-
-        const fromDate = earliestTransaction.length
-          ? earliestTransaction[0].date
-          : startTransaction.date;
+// Получаем все транзакции, начиная с самой ранней, которую нужно пересчитать
+    const earliestTransaction = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+      {
+        $match: {
+          productId: startTransaction.productId,
+          date: { $lte: new Date(startTransaction.date) },
+        },
+      },
+      { $sort: { date: 1, order: 1, createdAt: 1 } },
+      { $limit: 1 },
+    ]);
 
-        const allTransactions = await LoanTransaction.aggregate<ILoanTransactionDoc>([
-          {
-            $match: {
-              productId: startTransaction.productId,
-              date: { $gte: fromDate }
-            }
-          },
-          { $sort: { date: 1, order: 1, createdAt: 1 } }
-        ]);
+    const fromDate = earliestTransaction.length
+      ? earliestTransaction[0].date
+      : startTransaction.date;
 
-        let balance = 0;
-        let floatedBalance = 0;
+    const allTransactions = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+      {
+        $match: {
+          productId: startTransaction.productId,
+          date: { $gte: fromDate },
+        },
+      },
+      { $sort: { date: 1, order: 1, createdAt: 1 } },
+    ]);
 
-        // Найдём стартовые значения
-        const prevBeforeStart = await LoanTransaction.aggregate<ILoanTransactionDoc>([
-          {
-            $match: {
-              productId: startTransaction.productId,
-              date: { $lt: fromDate }
-            }
-          },
-          { $sort: { date: -1, order: -1, createdAt: -1 } },
-          { $limit: 1 }
-        ]);
+    let balance = 0;
+    let floatedBalance = 0;
 
-        if (prevBeforeStart.length) {
-          balance = prevBeforeStart[0].balance || 0;
-          floatedBalance = prevBeforeStart[0].floatedBalance || 0;
-        }
+    const prevBeforeStart = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+      {
+        $match: {
+          productId: startTransaction.productId,
+          date: { $lt: fromDate },
+        },
+      },
+      { $sort: { date: -1, order: -1, createdAt: -1 } },
+      { $limit: 1 },
+    ]);
 
-        // Один проход для расчёта 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;
-          }
+    if (prevBeforeStart.length) {
+      balance = prevBeforeStart[0].balance || 0;
+      floatedBalance = prevBeforeStart[0].floatedBalance || 0;
+    }
 
-          await LoanTransaction.updateOne(
-            { _id: tr._id },
-            { balance, floatedBalance },
-            { session }
-          );
-        }
+    for (const tr of allTransactions) {
+      // regular balance recalculation
+      balance = new Decimal(balance).add(tr.amount).toNumber();
+
+      // floatedBalance recalculation
+      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 LoanProduct.updateOne(
-          { _id: startTransaction.productId },
-          { isBalanceActual: true, isFloatedBalanceActual: true },
-          { session }
-        );
-      });
-    } finally {
-      await session.endSession();
+      await LoanTransaction.updateOne(
+        { _id: tr._id },
+        { balance, floatedBalance },
+      );
     }
+
+    await LoanProduct.updateOne(
+      { _id: startTransaction.productId },
+      { isBalanceActual: true, isFloatedBalanceActual: true },
+    );
   }
 
   async deleteLoanTransaction(transactionId: string, updateLoanPayment: boolean, userId = null) {
@@ -670,11 +659,11 @@ export class LoanTransactionsService {
       }
     }
     if (nextTransaction.length) {
-      await this.recalculateBalance(nextTransaction[0]._id.toString());
+      this.recalculateBalance(nextTransaction[0]._id.toString()).catch(console.error);
     }
     const statementDate = this.loanStatementStatusService.getStatementDateForDate(new Date(currentTransaction.date));
-    await this.loanStatementStatusService.updateStatementStatus(currentTransaction.productId.toString(), statementDate, false);
-    await this.termLoanService.setTermLoanExpected(currentTransaction.productId.toString());
+    this.loanStatementStatusService.updateStatementStatus(currentTransaction.productId.toString(), statementDate, false).catch(console.error);
+    this.termLoanService.setTermLoanExpected(currentTransaction.productId.toString()).catch(console.error);
   }
 
   async createPostponedTransaction(transaction: ILoanTransactionDoc) {