gemcap-be-common 1.3.100 → 1.3.102

package/package.json

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

package/repositories/calendar.repository.d.ts

@@ -0,0 +1,3 @@
+export declare class CalendarRepository {
+    getNextWorkingDay(date: string): Promise<string>;
+}

package/repositories/calendar.repository.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarRepository = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const CalandarDay_model_1 = __importDefault(require("../models/CalandarDay.model"));
+class CalendarRepository {
+    async getNextWorkingDay(date) {
+        let nextDay = (0, dayjs_1.default)(new Date(date));
+        let isWorking = false;
+        do {
+            nextDay = nextDay.add(1, 'day');
+            const calendarDay = await CalandarDay_model_1.default.findOne({ date: nextDay.format('YYYY-MM-DD') }).lean();
+            if (!calendarDay) {
+                console.error(`no data in calendar for ${nextDay.format('YYYY-MM-DD')}`);
+            }
+            isWorking = calendarDay ? calendarDay.workingDay : true;
+        } while (isWorking === false);
+        return nextDay.format('YYYY-MM-DD');
+    }
+}
+exports.CalendarRepository = CalendarRepository;

package/repositories/calendar.repository.ts

@@ -0,0 +1,19 @@
+import dayjs from 'dayjs';
+
+import CalendarDay from '../models/CalandarDay.model';
+
+export class CalendarRepository {
+  async getNextWorkingDay(date: string) {
+    let nextDay = dayjs(new Date(date));
+    let isWorking = false;
+    do {
+      nextDay = nextDay.add(1, 'day');
+      const calendarDay = await CalendarDay.findOne({ date: nextDay.format('YYYY-MM-DD') }).lean();
+      if (!calendarDay) {
+        console.error(`no data in calendar for ${nextDay.format('YYYY-MM-DD')}`);
+      }
+      isWorking = calendarDay ? calendarDay.workingDay : true;
+    } while (isWorking === false);
+    return nextDay.format('YYYY-MM-DD');
+  }
+}

package/repositories/postponed-transactions.repository.d.ts

@@ -0,0 +1,5 @@
+import { IPostponedTransaction } from '../models/PostponedTransactions.model';
+export declare class PostponedTransactionsRepository {
+    cleanRecalculated(transactionId: string): Promise<void>;
+    createPostponedTransaction(postponedTransaction: IPostponedTransaction): Promise<void>;
+}

package/repositories/postponed-transactions.repository.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostponedTransactionsRepository = void 0;
+const PostponedTransactions_model_1 = require("../models/PostponedTransactions.model");
+class PostponedTransactionsRepository {
+    async cleanRecalculated(transactionId) {
+        await PostponedTransactions_model_1.PostponedTransaction.deleteMany({ transactionId });
+    }
+    async createPostponedTransaction(postponedTransaction) {
+        await PostponedTransactions_model_1.PostponedTransaction.create(postponedTransaction);
+    }
+}
+exports.PostponedTransactionsRepository = PostponedTransactionsRepository;

package/repositories/postponed-transactions.repository.ts

@@ -0,0 +1,11 @@
+import { IPostponedTransaction, PostponedTransaction } from '../models/PostponedTransactions.model';
+
+export class PostponedTransactionsRepository {
+  async cleanRecalculated(transactionId: string) {
+    await PostponedTransaction.deleteMany({ transactionId });
+  }
+
+  async createPostponedTransaction(postponedTransaction: IPostponedTransaction) {
+    await PostponedTransaction.create(postponedTransaction);
+  }
+}

package/services/calendar.service.d.ts

@@ -23,6 +23,7 @@
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose" />
 /// <reference types="mongoose/types/inferschematype" />
+import { CalendarRepository } from '../repositories/calendar.repository';
 interface IWorkingDaysApi {
     working_day: number;
     work_hours: number;
@@ -40,6 +41,8 @@ interface IWorkingDaysApi {
     type: number;
 }
 export declare class CalendarService {
+    private readonly calendarRepository;
+    constructor(calendarRepository: CalendarRepository);
     fulfillCalendar(): Promise<void>;
     createDate(date: string, dateProp: IWorkingDaysApi): Promise<void>;
     isWorkingDay(date: string): Promise<boolean>;

package/services/calendar.service.js

@@ -8,6 +8,10 @@ const axios_1 = __importDefault(require("axios"));
 const dayjs_1 = __importDefault(require("dayjs"));
 const CalandarDay_model_1 = __importDefault(require("../models/CalandarDay.model"));
 class CalendarService {
+    calendarRepository;
+    constructor(calendarRepository) {
+        this.calendarRepository = calendarRepository;
+    }
     async fulfillCalendar() {
         const getDays = () => {
             const days = [];
@@ -76,17 +80,7 @@ class CalendarService {
         return !isNextDayWorking;
     }
     async getNextWorkingDay(date) {
-        let nextDay = (0, dayjs_1.default)(new Date(date));
-        let isWorking = false;
-        do {
-            nextDay = nextDay.add(1, 'day');
-            const calendarDay = await CalandarDay_model_1.default.findOne({ date: nextDay.format('YYYY-MM-DD') }).lean();
-            if (!calendarDay) {
-                console.error(`no data in calendar for ${nextDay.format('YYYY-MM-DD')}`);
-            }
-            isWorking = calendarDay ? calendarDay.workingDay : true;
-        } while (isWorking === false);
-        return nextDay.format('YYYY-MM-DD');
+        return this.calendarRepository.getNextWorkingDay(date);
     }
     async getLastWorkingDay(date) {
         let previous = (0, dayjs_1.default)(new Date(date));

package/services/calendar.service.ts

@@ -2,6 +2,7 @@ import axios from 'axios';
 import dayjs from 'dayjs';
 
 import CalendarDay, { ICalendarDay } from '../models/CalandarDay.model';
+import { CalendarRepository } from '../repositories/calendar.repository';
 
 interface IWorkingDaysApi {
   working_day: number;
@@ -21,6 +22,12 @@ interface IWorkingDaysApi {
 }
 
 export class CalendarService {
+
+  constructor(
+    private readonly calendarRepository: CalendarRepository,
+  ) {
+  }
+
   async fulfillCalendar() {
 
     const getDays = () => {
@@ -95,17 +102,7 @@ export class CalendarService {
   }
 
   async getNextWorkingDay(date: string) {
-    let nextDay = dayjs(new Date(date));
-    let isWorking = false;
-    do {
-      nextDay = nextDay.add(1, 'day');
-      const calendarDay = await CalendarDay.findOne({ date: nextDay.format('YYYY-MM-DD') }).lean();
-      if (!calendarDay) {
-        console.error(`no data in calendar for ${nextDay.format('YYYY-MM-DD')}`);
-      }
-      isWorking = calendarDay ? calendarDay.workingDay : true;
-    } while (isWorking === false);
-    return nextDay.format('YYYY-MM-DD');
+    return this.calendarRepository.getNextWorkingDay(date);
   }
 
   async getLastWorkingDay(date: string) {

package/services/loan-transactions.service.d.ts

@@ -39,6 +39,7 @@ import { LoanStatementStatusService } from './loan-statement-status.service';
 import { NodemailerService } from './nodemailer.service';
 import { TermLoanService } from './term-loan.service';
 import { LockService } from './lock.service';
+import { PostponedTransactionsService } from './postponed-transactions.service';
 interface ILoanTransactionsServiceConfig {
     portfolioEmail: string;
 }
@@ -63,8 +64,9 @@ export declare class LoanTransactionsService {
     private readonly lockService;
     private readonly termLoanService;
     private readonly uploadsService;
+    private readonly postponedTransactionsService;
     private readonly config;
-    constructor(config: ILoanTransactionsServiceConfig, attachedFilesService: AttachedFilesService, banksService: BanksService, borrowersDB: BorrowersDB, calendarService: CalendarService, loanChargesService: LoanChargesService, getLoanPaymentsService: () => LoanPaymentsService, getLoanStatementService: () => LoanStatementService, loanStatementStatusService: LoanStatementStatusService, getNodemailerService: () => NodemailerService, lockService: LockService, termLoanService: TermLoanService, uploadsService: UploadsService);
+    constructor(config: ILoanTransactionsServiceConfig, attachedFilesService: AttachedFilesService, banksService: BanksService, borrowersDB: BorrowersDB, calendarService: CalendarService, loanChargesService: LoanChargesService, getLoanPaymentsService: () => LoanPaymentsService, getLoanStatementService: () => LoanStatementService, loanStatementStatusService: LoanStatementStatusService, getNodemailerService: () => NodemailerService, lockService: LockService, termLoanService: TermLoanService, uploadsService: UploadsService, postponedTransactionsService: PostponedTransactionsService);
     getTransactionsById(transactionId: string): Promise<mongoose.FlattenMaps<ILoanTransaction> & {
         _id: mongoose.Types.ObjectId;
     }>;
@@ -113,8 +115,6 @@ export declare class LoanTransactionsService {
     recalculateBalanceLegacy(transactionId: string): Promise<void>;
     recalculateBalance(transactionId: string): Promise<void>;
     deleteLoanTransaction(transactionId: string, updateLoanPayment: boolean, userId?: any): Promise<void>;
-    createPostponedTransaction(transaction: ILoanTransactionDoc): Promise<void>;
-    cleanRecalculated(transactionId: string): Promise<void>;
     deleteLoanTransactionFile(transactionFileId: string, userId: string): Promise<any>;
     getFirstTransaction(productId: string, excludeAdjustments?: boolean): Promise<ILoanTransactionDoc>;
     getLastTransactionForDate(productId: string, date?: Date, excludeAdjustments?: boolean): Promise<ILoanTransactionDoc>;

package/services/loan-transactions.service.js

@@ -36,8 +36,9 @@ class LoanTransactionsService {
     lockService;
     termLoanService;
     uploadsService;
+    postponedTransactionsService;
     config;
-    constructor(config, attachedFilesService, banksService, borrowersDB, calendarService, loanChargesService, getLoanPaymentsService, getLoanStatementService, loanStatementStatusService, getNodemailerService, lockService, termLoanService, uploadsService) {
+    constructor(config, attachedFilesService, banksService, borrowersDB, calendarService, loanChargesService, getLoanPaymentsService, getLoanStatementService, loanStatementStatusService, getNodemailerService, lockService, termLoanService, uploadsService, postponedTransactionsService) {
         this.attachedFilesService = attachedFilesService;
         this.banksService = banksService;
         this.borrowersDB = borrowersDB;
@@ -50,6 +51,7 @@ class LoanTransactionsService {
         this.lockService = lockService;
         this.termLoanService = termLoanService;
         this.uploadsService = uploadsService;
+        this.postponedTransactionsService = postponedTransactionsService;
         this.config = config;
     }
     async getTransactionsById(transactionId) {
@@ -313,11 +315,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) {
@@ -345,136 +347,120 @@ class LoanTransactionsService {
             return;
         }
         const recalcBalance = async () => {
-            const session = await mongoose_1.default.startSession();
-            try {
-                await session.withTransaction(async () => {
-                    await LoanProducts_model_1.LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isBalanceActual: false });
-                    const previousTransaction = await LoanTransaction_model_1.LoanTransaction.aggregate([
-                        {
-                            $match: {
-                                'productId': new mongoose_1.default.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_model_1.LoanTransaction.aggregate([
-                        {
-                            $match: {
-                                'productId': new mongoose_1.default.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_js_1.default(currentBalance).add(transaction.amount).toNumber();
-                        await LoanTransaction_model_1.LoanTransaction.findByIdAndUpdate(transaction._id, { balance: currentBalance });
-                    }
-                    await LoanProducts_model_1.LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isBalanceActual: true });
-                });
-            }
-            finally {
-                await session.endSession();
+            await LoanProducts_model_1.LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isBalanceActual: false });
+            const previousTransaction = await LoanTransaction_model_1.LoanTransaction.aggregate([
+                {
+                    $match: {
+                        'productId': new mongoose_1.default.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_model_1.LoanTransaction.aggregate([
+                {
+                    $match: {
+                        'productId': new mongoose_1.default.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_js_1.default(currentBalance).add(transaction.amount).toNumber();
+                await LoanTransaction_model_1.LoanTransaction.findByIdAndUpdate(transaction._id, { balance: currentBalance });
             }
+            await LoanProducts_model_1.LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isBalanceActual: true });
         };
         const recalcFloatedBalance = async () => {
-            const session = await mongoose_1.default.startSession();
-            try {
-                await session.withTransaction(async () => {
-                    await LoanProducts_model_1.LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isFloatedBalanceActual: false });
-                    const previousEqualBalancesTransaction = await LoanTransaction_model_1.LoanTransaction.aggregate([
-                        {
-                            $match: {
-                                'productId': new mongoose_1.default.Types.ObjectId(changedTransaction.productId.toString()),
-                                'date': { $lt: new Date(changedTransaction.date) },
-                                $expr: { $eq: ['$balance', '$floatedBalance'] },
-                            },
-                        }, {
-                            $sort: {
-                                'date': -1,
-                                'order': -1,
-                                'createdAt': -1,
-                            },
-                        }, {
-                            $limit: 1,
+            await LoanProducts_model_1.LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isFloatedBalanceActual: false });
+            const previousEqualBalancesTransaction = await LoanTransaction_model_1.LoanTransaction.aggregate([
+                {
+                    $match: {
+                        'productId': new mongoose_1.default.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_model_1.LoanTransaction.aggregate([
+                    {
+                        $match: {
+                            'productId': new mongoose_1.default.Types.ObjectId(previousEqualBalancesTransaction[0].productId.toString()),
+                            'date': { $lt: new Date(previousEqualBalancesTransaction[0].date) },
                         },
-                    ]);
-                    let currentFloatedBalance = 0;
-                    if (previousEqualBalancesTransaction.length) {
-                        const previousTransaction = await LoanTransaction_model_1.LoanTransaction.aggregate([
-                            {
-                                $match: {
-                                    'productId': new mongoose_1.default.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_model_1.LoanTransaction.aggregate([
-                        {
-                            $match: {
-                                'productId': new mongoose_1.default.Types.ObjectId(initTransaction.productId.toString()),
-                                'date': { $gte: new Date(initTransaction.date) },
-                            },
-                        }, {
-                            $sort: {
-                                'date': 1,
-                                'order': 1,
-                                'createdAt': 1,
-                            },
+                    }, {
+                        $sort: {
+                            'date': -1,
+                            'order': -1,
+                            'createdAt': -1,
                         },
-                    ]);
-                    for (const transaction of recalculatedTransactions) {
-                        const totalPostponed = await (0, loan_products_db_1.getPostponedTransactions)(transaction.date, transaction.productId.toString(), true);
-                        switch (transaction.transactionType) {
-                            case LoanTransaction_model_1.ELoanTransactionTypes.COLLECTION:
-                                await this.cleanRecalculated(transaction._id.toString());
-                                await this.createPostponedTransaction(transaction);
-                                currentFloatedBalance = new decimal_js_1.default(currentFloatedBalance).add(totalPostponed).toNumber();
-                                break;
-                            case LoanTransaction_model_1.ELoanTransactionTypes.DISBURSEMENT:
-                                currentFloatedBalance = new decimal_js_1.default(currentFloatedBalance).add(transaction.amount).add(totalPostponed).toNumber();
-                                break;
-                            case LoanTransaction_model_1.ELoanTransactionTypes.ADJUSTMENT:
-                                currentFloatedBalance = new decimal_js_1.default(currentFloatedBalance).add(transaction.amount).add(totalPostponed).toNumber();
-                                break;
-                        }
-                        await LoanTransaction_model_1.LoanTransaction.findByIdAndUpdate(transaction._id, { floatedBalance: currentFloatedBalance });
-                    }
-                    await LoanProducts_model_1.LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isFloatedBalanceActual: true });
-                });
+                    }, {
+                        $limit: 1,
+                    },
+                ]);
+                if (previousTransaction.length) {
+                    currentFloatedBalance = previousTransaction[0].floatedBalance;
+                }
             }
-            finally {
-                await session.endSession();
+            const initTransaction = previousEqualBalancesTransaction.length ? previousEqualBalancesTransaction[0] : changedTransaction;
+            const recalculatedTransactions = await LoanTransaction_model_1.LoanTransaction.aggregate([
+                {
+                    $match: {
+                        'productId': new mongoose_1.default.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 (0, loan_products_db_1.getPostponedTransactions)(transaction.date, transaction.productId.toString(), true);
+                switch (transaction.transactionType) {
+                    case LoanTransaction_model_1.ELoanTransactionTypes.COLLECTION:
+                        await this.postponedTransactionsService.cleanRecalculated(transaction._id.toString());
+                        await this.postponedTransactionsService.createPostponedTransaction(transaction);
+                        currentFloatedBalance = new decimal_js_1.default(currentFloatedBalance).add(totalPostponed).toNumber();
+                        break;
+                    case LoanTransaction_model_1.ELoanTransactionTypes.DISBURSEMENT:
+                        currentFloatedBalance = new decimal_js_1.default(currentFloatedBalance).add(transaction.amount).add(totalPostponed).toNumber();
+                        break;
+                    case LoanTransaction_model_1.ELoanTransactionTypes.ADJUSTMENT:
+                        currentFloatedBalance = new decimal_js_1.default(currentFloatedBalance).add(transaction.amount).add(totalPostponed).toNumber();
+                        break;
+                }
+                await LoanTransaction_model_1.LoanTransaction.findByIdAndUpdate(transaction._id, { floatedBalance: currentFloatedBalance });
             }
+            await LoanProducts_model_1.LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isFloatedBalanceActual: true });
         };
         await recalcBalance();
         await recalcFloatedBalance();
@@ -485,16 +471,15 @@ class LoanTransactionsService {
             console.error(`Transaction not found: ${transactionId}`);
             return;
         }
-        // Получаем все транзакции, начиная с самой ранней, которую нужно пересчитать
         const earliestTransaction = await LoanTransaction_model_1.LoanTransaction.aggregate([
             {
                 $match: {
                     productId: startTransaction.productId,
-                    date: { $lte: new Date(startTransaction.date) }
-                }
+                    date: { $lte: new Date(startTransaction.date) },
+                },
             },
             { $sort: { date: 1, order: 1, createdAt: 1 } },
-            { $limit: 1 }
+            { $limit: 1 },
         ]);
         const fromDate = earliestTransaction.length
             ? earliestTransaction[0].date
@@ -503,10 +488,10 @@ class LoanTransactionsService {
             {
                 $match: {
                     productId: startTransaction.productId,
-                    date: { $gte: fromDate }
-                }
+                    date: { $gte: fromDate },
+                },
             },
-            { $sort: { date: 1, order: 1, createdAt: 1 } }
+            { $sort: { date: 1, order: 1, createdAt: 1 } },
         ]);
         let balance = 0;
         let floatedBalance = 0;
@@ -514,11 +499,11 @@ class LoanTransactionsService {
             {
                 $match: {
                     productId: startTransaction.productId,
-                    date: { $lt: fromDate }
-                }
+                    date: { $lt: fromDate },
+                },
             },
             { $sort: { date: -1, order: -1, createdAt: -1 } },
-            { $limit: 1 }
+            { $limit: 1 },
         ]);
         if (prevBeforeStart.length) {
             balance = prevBeforeStart[0].balance || 0;
@@ -531,8 +516,8 @@ class LoanTransactionsService {
             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);
+                    await this.postponedTransactionsService.cleanRecalculated(tr._id.toString());
+                    await this.postponedTransactionsService.createPostponedTransaction(tr);
                     floatedBalance = new decimal_js_1.default(floatedBalance).add(totalPostponed).toNumber();
                     break;
                 case LoanTransaction_model_1.ELoanTransactionTypes.DISBURSEMENT:
@@ -577,24 +562,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());
-    }
-    async createPostponedTransaction(transaction) {
-        const currentDay = (0, dayjs_1.default)(new Date(transaction.date)).format('YYYY-MM-DD');
-        const workingDate = await this.calendarService.getNextWorkingDay(currentDay);
-        const postponedTransaction = {
-            postponedToDate: workingDate,
-            transactionId: new mongoose_1.default.Types.ObjectId(String(transaction._id)),
-            productId: new mongoose_1.default.Types.ObjectId(String(transaction.productId)),
-        };
-        await PostponedTransactions_model_1.PostponedTransaction.create(postponedTransaction);
-    }
-    async cleanRecalculated(transactionId) {
-        await PostponedTransactions_model_1.PostponedTransaction.deleteMany({ transactionId });
+        this.loanStatementStatusService.updateStatementStatus(currentTransaction.productId.toString(), statementDate, false).catch(console.error);
+        this.termLoanService.setTermLoanExpected(currentTransaction.productId.toString()).catch(console.error);
     }
     async deleteLoanTransactionFile(transactionFileId, userId) {
         const foundFile = await LoanTransactionFile_model_1.LoanTransactionFileModel.findById(transactionFileId).lean();