gemcap-be-common 1.4.102 → 1.4.104

package/microservice/event-map.d.ts

@@ -39,6 +39,7 @@ export declare const EventMap: {
     readonly recalc: {
         readonly UNLOCK_PRODUCT_BALANCE: "recalc#UNLOCK_PRODUCT_BALANCE";
         readonly PRODUCT_BALANCE: "recalc#PRODUCT_BALANCE";
+        readonly STATEMENT_STATUS: "recalc#STATEMENT_STATUS";
     };
     readonly auditors: {
         readonly NOTIFY_ONE_PROSPECT: "auditors#NOTIFY_ONE_PROSPECT";

package/microservice/event-map.js

@@ -42,6 +42,7 @@ exports.EventMap = {
     recalc: {
         UNLOCK_PRODUCT_BALANCE: 'recalc#UNLOCK_PRODUCT_BALANCE',
         PRODUCT_BALANCE: 'recalc#PRODUCT_BALANCE',
+        STATEMENT_STATUS: 'recalc#STATEMENT_STATUS',
     },
     auditors: {
         NOTIFY_ONE_PROSPECT: 'auditors#NOTIFY_ONE_PROSPECT',

package/microservice/event-map.ts

@@ -39,6 +39,7 @@ export const EventMap = {
   recalc: {
     UNLOCK_PRODUCT_BALANCE: 'recalc#UNLOCK_PRODUCT_BALANCE',
     PRODUCT_BALANCE: 'recalc#PRODUCT_BALANCE',
+    STATEMENT_STATUS: 'recalc#STATEMENT_STATUS',
   },
   auditors: {
     NOTIFY_ONE_PROSPECT: 'auditors#NOTIFY_ONE_PROSPECT',

package/package.json

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

package/services/bank-uploaded-transactions.service.d.ts

@@ -21,7 +21,7 @@ export declare class BankUploadedTransactionsService {
     resetAllocatedBankTransactions(date: Date): Promise<void>;
     createAllocatedBankTransactions(date: Date): Promise<void>;
     convertBankTransactions(startDate: Date, userId: string): Promise<void>;
-    recalculateProducts(productIds: string[]): void;
+    recalculateProducts(productIds: string[], productMap: Record<string, string>): Promise<void>;
     preSplitBankTransactions(transactionId: string, splitTransaction: ISplitTransaction[]): Promise<void>;
     deleteBankTransaction(transactionIds: string[]): Promise<void>;
     revertAllBankTransactions(startDate: Date, endDate: Date, userId: string): Promise<void>;

package/services/bank-uploaded-transactions.service.js

@@ -291,6 +291,7 @@ class BankUploadedTransactionsService {
                 [transaction._id.toString()]: [],
             };
         }, {});
+        const productMap = {};
         const productIds = new Set();
         await Promise.all(allocatedTransactions.map(async (transactionToConvert) => {
             const transaction = transactions.find((tr) => tr._id.toString() === transactionToConvert.uploadedBankTransactionId.toString());
@@ -323,6 +324,15 @@ class BankUploadedTransactionsService {
             const createdLoanTransaction = await loanTransactionsService.createLoanTransaction(normalizedTransaction);
             loanTransactionsMap[String(transaction._id)] = [...loanTransactionsMap[String(transaction._id)], new mongoose_1.default.Types.ObjectId(String(createdLoanTransaction._id))];
             productIds.add(String(foundCashAllocationProduct.productId));
+            if (!productMap[createdLoanTransaction.productId.toString()]) {
+                productMap[createdLoanTransaction.productId.toString()] = createdLoanTransaction.date.toISOString();
+            }
+            else {
+                const foundDate = new Date(productMap[createdLoanTransaction.productId.toString()]);
+                if (foundDate > createdLoanTransaction.date) {
+                    productMap[createdLoanTransaction.productId.toString()] = createdLoanTransaction.date.toISOString();
+                }
+            }
         }));
         await Promise.all(transactions.map(async (transaction) => {
             await transaction.updateOne({
@@ -330,17 +340,17 @@ class BankUploadedTransactionsService {
                 loanTransactionIds: loanTransactionsMap[String(transaction._id)],
             });
         }));
-        this.recalculateProducts(Array.from(productIds));
+        await this.recalculateProducts(Array.from(productIds), productMap);
     }
-    recalculateProducts(productIds) {
+    async recalculateProducts(productIds, productMap) {
         // TODO rework in something better
         setTimeout(async () => {
             await Promise.all(productIds.map(async (productId) => {
-                console.log({ productId });
                 const loanTransactionsService = this.getLoanTransactionsService();
                 await loanTransactionsService.recalculateProduct(productId);
             }));
         }, 2000);
+        await this.loanStatementStatusService.recalculateStatementQueued(productMap);
     }
     async preSplitBankTransactions(transactionId, splitTransaction) {
         const mappedSplitTransactions = splitTransaction.map((transaction) => {
@@ -360,10 +370,20 @@ class BankUploadedTransactionsService {
     async revertBankTransactions(transactionIds, userId) {
         const foundTransaction = await UploadedBankTransaction_model_1.UploadedBankTransaction.find({ _id: { $in: transactionIds }, isConverted: true });
         const productIds = new Set();
+        const productMap = {};
         await Promise.all(foundTransaction.map(async (transaction) => {
             try {
                 await Promise.all(transaction.loanTransactionIds.map(async (loanTransactionId) => {
                     const loanTransaction = await LoanTransaction_model_1.LoanTransaction.findById(loanTransactionId);
+                    if (!productMap[loanTransaction.productId.toString()]) {
+                        productMap[loanTransaction.productId.toString()] = loanTransaction.date.toISOString();
+                    }
+                    else {
+                        const foundDate = new Date(productMap[loanTransaction.productId.toString()]);
+                        if (foundDate > loanTransaction.date) {
+                            productMap[loanTransaction.productId.toString()] = loanTransaction.date.toISOString();
+                        }
+                    }
                     const loanTransactionsService = this.getLoanTransactionsService();
                     const isLocked = await loanTransactionsService.checkLockStatus(loanTransaction);
                     if (isLocked) {
@@ -379,12 +399,12 @@ class BankUploadedTransactionsService {
                 transaction.loanTransactionIds = [];
                 transaction.isConverted = false;
                 await transaction.save();
-                this.recalculateProducts(Array.from(productIds));
             }
             catch (error) {
                 console.log(error);
             }
         }));
+        await this.recalculateProducts(Array.from(productIds), productMap);
     }
     async getUniqueDates() {
         const uniqueDates = await UploadedBankTransaction_model_1.UploadedBankTransaction.aggregate([

package/services/bank-uploaded-transactions.service.ts

@@ -328,6 +328,7 @@ export class BankUploadedTransactionsService {
         [transaction._id.toString()]: [] as mongoose.Types.ObjectId[],
       };
     }, <{ [transactionId: string]: mongoose.Types.ObjectId[] }>{});
+    const productMap: Record<string, string> = {};
     const productIds = new Set<string>();
     await Promise.all(allocatedTransactions.map(async (transactionToConvert) => {
       const transaction = transactions.find((tr) => tr._id.toString() === transactionToConvert.uploadedBankTransactionId.toString());
@@ -361,6 +362,14 @@ export class BankUploadedTransactionsService {
       const createdLoanTransaction = await loanTransactionsService.createLoanTransaction(normalizedTransaction as Partial<ILoanTransactionWithId>);
       loanTransactionsMap[String(transaction._id)] = [...loanTransactionsMap[String(transaction._id)], new mongoose.Types.ObjectId(String(createdLoanTransaction._id))];
       productIds.add(String(foundCashAllocationProduct.productId));
+      if (!productMap[createdLoanTransaction.productId.toString()]) {
+        productMap[createdLoanTransaction.productId.toString()] = createdLoanTransaction.date.toISOString();
+      } else {
+        const foundDate = new Date(productMap[createdLoanTransaction.productId.toString()]);
+        if (foundDate > createdLoanTransaction.date) {
+          productMap[createdLoanTransaction.productId.toString()] = createdLoanTransaction.date.toISOString();
+        }
+      }
     }));
 
     await Promise.all(transactions.map(async (transaction) => {
@@ -369,18 +378,18 @@ export class BankUploadedTransactionsService {
         loanTransactionIds: loanTransactionsMap[String(transaction._id)],
       });
     }));
-    this.recalculateProducts(Array.from(productIds));
+    await this.recalculateProducts(Array.from(productIds), productMap);
   }
 
-  recalculateProducts(productIds: string[]) {
+  async recalculateProducts(productIds: string[], productMap: Record<string, string>) {
     // TODO rework in something better
     setTimeout(async () => {
       await Promise.all(productIds.map(async (productId) => {
-        console.log({ productId });
         const loanTransactionsService = this.getLoanTransactionsService();
         await loanTransactionsService.recalculateProduct(productId);
       }));
     }, 2_000);
+    await this.loanStatementStatusService.recalculateStatementQueued(productMap);
   }
 
   async preSplitBankTransactions(transactionId: string, splitTransaction: ISplitTransaction[]) {
@@ -404,10 +413,21 @@ export class BankUploadedTransactionsService {
   async revertBankTransactions(transactionIds: string[], userId: string) {
     const foundTransaction = await UploadedBankTransaction.find({ _id: { $in: transactionIds }, isConverted: true });
     const productIds = new Set<string>();
+    const productMap: Record<string, string> = {};
     await Promise.all(foundTransaction.map(async (transaction) => {
       try {
         await Promise.all(transaction.loanTransactionIds.map(async (loanTransactionId) => {
           const loanTransaction = await LoanTransaction.findById(loanTransactionId);
+
+          if (!productMap[loanTransaction.productId.toString()]) {
+            productMap[loanTransaction.productId.toString()] = loanTransaction.date.toISOString();
+          } else {
+            const foundDate = new Date(productMap[loanTransaction.productId.toString()]);
+            if (foundDate > loanTransaction.date) {
+              productMap[loanTransaction.productId.toString()] = loanTransaction.date.toISOString();
+            }
+          }
+
           const loanTransactionsService = this.getLoanTransactionsService();
           const isLocked = await loanTransactionsService.checkLockStatus(loanTransaction);
           if (isLocked) {
@@ -423,12 +443,11 @@ export class BankUploadedTransactionsService {
         transaction.loanTransactionIds = [];
         transaction.isConverted = false;
         await transaction.save();
-
-        this.recalculateProducts(Array.from(productIds));
       } catch (error) {
         console.log(error);
       }
     }));
+    await this.recalculateProducts(Array.from(productIds), productMap);
   }
 
   async getUniqueDates() {

package/services/loan-statement-status.service.d.ts

@@ -27,11 +27,13 @@ import { ISelectedMonth } from '../helpers/date.helper';
 import { IStatementPeriod } from './loan-statement.service';
 import { LoanChargesService } from './loan-charges.service';
 import { TermLoanService } from './term-loan.service';
+import { MainQueueService } from './main-queue.service';
 export type SelectablePeriod = 'LAST_MONTH' | 'CURRENT_MONTH' | 'ENTIRE_LOAN' | 'SELECTED_PERIOD';
 export declare class LoanStatementStatusService {
     private readonly getLoanChargesService;
     private readonly termLoanService;
-    constructor(getLoanChargesService: () => LoanChargesService, termLoanService: TermLoanService);
+    private readonly mainQueueService;
+    constructor(getLoanChargesService: () => LoanChargesService, termLoanService: TermLoanService, mainQueueService: MainQueueService);
     initStatementStatuses(): Promise<void>;
     getStatementDateFromStringPeriod(period: SelectablePeriod): ISelectedMonth;
     getStatementDateForDate(date: Date): ISelectedMonth;
@@ -205,4 +207,5 @@ export declare class LoanStatementStatusService {
         [K in SelectablePeriod | 'TERM_LOAN']?: boolean;
     }>;
     getBorrowerMonthStatus(borrowerId: string, statementDate: ISelectedMonth): Promise<boolean>;
+    recalculateStatementQueued(productMap: Record<string, string>): Promise<void>;
 }

package/services/loan-statement-status.service.js

@@ -7,12 +7,16 @@ exports.LoanStatementStatusService = void 0;
 const mongoose_1 = __importDefault(require("mongoose"));
 const dayjs_1 = __importDefault(require("dayjs"));
 const LoanStatementStatus_model_1 = require("../models/LoanStatementStatus.model");
+const event_map_1 = require("../microservice/event-map");
+const queue_map_1 = require("../microservice/queue-map");
 class LoanStatementStatusService {
     getLoanChargesService;
     termLoanService;
-    constructor(getLoanChargesService, termLoanService) {
+    mainQueueService;
+    constructor(getLoanChargesService, termLoanService, mainQueueService) {
         this.getLoanChargesService = getLoanChargesService;
         this.termLoanService = termLoanService;
+        this.mainQueueService = mainQueueService;
     }
     async initStatementStatuses() {
         const allStatuses = await LoanStatementStatus_model_1.LoanStatementStatusModel.find().lean();
@@ -77,7 +81,7 @@ class LoanStatementStatusService {
         }
     }
     async updateStatementStatus(productId, statementDate, actual) {
-        console.log('updateStatementStatus');
+        console.log('updateStatementStatus', { statementDate, actual });
         const statementStatus = await this.getCreateStatementStatus(productId, statementDate);
         if (statementStatus && !statementStatus.locked) {
             statementStatus.actual = actual;
@@ -160,5 +164,11 @@ class LoanStatementStatusService {
         }));
         return lastResults.reduce((acc, res) => res.actual && acc, true);
     }
+    async recalculateStatementQueued(productMap) {
+        this.mainQueueService.sendTaskToQueue({
+            data: { transactionIds: productMap },
+            pattern: event_map_1.EventMap.recalc.STATEMENT_STATUS,
+        }, queue_map_1.QueueMap.main).catch(console.error);
+    }
 }
 exports.LoanStatementStatusService = LoanStatementStatusService;

package/services/loan-statement-status.service.ts

@@ -10,6 +10,9 @@ import {
 import { IStatementPeriod } from './loan-statement.service';
 import { LoanChargesService } from './loan-charges.service';
 import { TermLoanService } from './term-loan.service';
+import { EventMap } from '../microservice/event-map';
+import { QueueMap } from '../microservice/queue-map';
+import { MainQueueService } from './main-queue.service';
 
 export type SelectablePeriod = 'LAST_MONTH' | 'CURRENT_MONTH' | 'ENTIRE_LOAN' | 'SELECTED_PERIOD';
 
@@ -17,6 +20,7 @@ export class LoanStatementStatusService {
   constructor(
     private readonly getLoanChargesService: () => LoanChargesService,
     private readonly termLoanService: TermLoanService,
+    private readonly mainQueueService: MainQueueService,
   ) {
   }
 
@@ -92,7 +96,7 @@ export class LoanStatementStatusService {
   }
 
   async updateStatementStatus(productId: string, statementDate: ISelectedMonth, actual: boolean) {
-    console.log('updateStatementStatus');
+    console.log('updateStatementStatus', { statementDate, actual });
     const statementStatus = await this.getCreateStatementStatus(productId, statementDate);
     if (statementStatus && !statementStatus.locked) {
       statementStatus.actual = actual;
@@ -178,4 +182,11 @@ export class LoanStatementStatusService {
     }));
     return lastResults.reduce((acc, res) => res.actual && acc, true);
   }
+
+  async recalculateStatementQueued(productMap: Record<string, string>) {
+    this.mainQueueService.sendTaskToQueue({
+      data: { transactionIds: productMap },
+      pattern: EventMap.recalc.STATEMENT_STATUS,
+    }, QueueMap.main).catch(console.error);
+  }
 }

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

@@ -155,7 +155,7 @@ export declare class LoanTransactionsService {
     getTransactionReport(transactionIds: string[], borrowerId: string, effectiveDate: Date): Promise<{
         transactionIdsToMark: any[];
         transactions: {
-            [x: string]: (string | number | string[] | Date)[];
+            [x: string]: (string | number | Date | string[])[];
         }[];
     }>;
     getBorrowerIdsForFile(transactionFileId: string): Promise<{