gemcap-be-common 1.2.62 → 1.2.64

package/db/loan-statement.db.d.ts

@@ -1,3 +1,4 @@
+import _ from 'lodash';
 import { IStatementPeriod } from '../models/LoanStatementTransaction.model';
 export declare enum ELedgerReportType {
     SHORT = 0,
@@ -36,7 +37,18 @@ export declare const ledgerHeadersMap: {
 export declare const getTotalTransactionAmountForCharge: (chargeId: string, start: Date, end: Date) => Promise<any>;
 export declare const getTotalForDate: (productId: string, date: Date) => Promise<number>;
 export declare const getStatementBorrowersTransactions: (start: string, end: string, selectedPeriod: string, selectedBorrowerIds: string[], ledgerType: ELedgerReportType) => Promise<{
-    transactions: any[];
+    transactions: ({
+        borrowerCode: string;
+        type: string;
+        chargeCode: string;
+        PLCode: string;
+        productCode: string;
+        productName: string;
+        info: string;
+        title: string;
+        amount: string;
+        statementAmount: string;
+    } | _.Omit<import("./reports.db").ILedgerReportRow, "balance" | "floatedBalance">)[];
 }[]>;
 export declare const getBorrowerWithPeriods: (borrowerId: string, period: {
     selectedPeriod: string;

package/db/loan-statement.db.js

@@ -105,39 +105,35 @@ const getStatementBorrowersTransactions = async (start, end, selectedPeriod, sel
     if (!selectedBorrowerIds) {
         return [{ transactions: [header] }];
     }
-    const allTransactions = {};
-    await Promise.all(selectedBorrowerIds.map(async (borrowerId) => {
-        const products = await (0, loan_products_db_1.getLoanProducts)(borrowerId);
-        const periodFull = await (0, exports.getBorrowerWithPeriods)(borrowerId, {
+    const periodFull = selectedPeriod === 'ENTIRE_LOAN'
+        ? [{
+                period: {
+                    selectedPeriod: selectedPeriod,
+                    start: (0, dayjs_1.default)(start).utc().toDate().toISOString(),
+                    end: (0, dayjs_1.default)(end).utc().toDate().toISOString(),
+                },
+            }]
+        : await (0, exports.getBorrowerWithPeriods)(selectedBorrowerIds[0], {
             selectedStart: new Date(start),
             selectedEnd: new Date(end),
             selectedPeriod,
         });
-        const someMappedResults = products.reduce((acc, product) => {
-            return [
-                ...acc,
-                ...periodFull.map((periodDesc) => ({
-                    productStart: periodDesc.period.start,
-                    productEnd: periodDesc.period.end,
-                    productId: product._id.toString(),
-                })),
-            ];
-        }, []);
-        await Promise.all(someMappedResults.map(async (productDesc) => {
-            const borrowerTransactions = await (0, reports_db_1.getLedger)(productDesc.productId, new Date(productDesc.productStart), new Date(productDesc.productEnd), ledgerType, true);
-            Object.values(borrowerTransactions).forEach((transactions) => {
-                const [_header, ...onlyData] = transactions;
-                const mappedData = lodash_1.default.map(onlyData, (obj) => lodash_1.default.omit(obj, ['balance', 'floatedBalance']));
-                allTransactions[borrowerId] = mappedData;
-            });
-        }));
+    const allProductIds = [];
+    await Promise.all(selectedBorrowerIds.map(async (borrowerId) => {
+        const borrowerProducts = await (0, loan_products_db_1.getLoanProducts)(borrowerId);
+        allProductIds.push(borrowerProducts.map((product) => product._id.toString()));
     }));
-    const sortedTransactions = [];
-    for (const borrowerId of selectedBorrowerIds) {
-        console.log(borrowerId);
-        sortedTransactions.push(...allTransactions[borrowerId]);
-    }
-    return [{ transactions: [header, ...sortedTransactions] }];
+    const products = await LoanProducts_model_1.LoanProduct.find({ borrowerId: { $in: selectedBorrowerIds.map((id) => new mongoose_1.default.Types.ObjectId(id)) } }).lean();
+    const productIds = products.map((product) => product._id.toString());
+    const ledgerData = await (0, reports_db_1.getLedger)({
+        productIds,
+        startDate: new Date((0, dayjs_1.default)(periodFull[0].period.start).utc().toDate().toISOString()),
+        endDate: new Date((0, dayjs_1.default)(periodFull[0].period.end).utc().toDate().toISOString()),
+        reportType: ledgerType,
+    }, { showBalances: false, showFloatedBalance: false });
+    const transactions = Object.values(ledgerData).reduce((acc, ledgerTransaction) => [...acc, ...ledgerTransaction], []);
+    const transactionsWithoutBalance = lodash_1.default.map(transactions, (obj) => lodash_1.default.omit(obj, ['balance', 'floatedBalance']));
+    return [{ transactions: [header, ...transactionsWithoutBalance] }];
 };
 exports.getStatementBorrowersTransactions = getStatementBorrowersTransactions;
 const getBorrowerWithPeriods = async (borrowerId, period, splitPeriods = false) => {

package/db/loan-statement.db.ts

@@ -103,45 +103,39 @@ export const getStatementBorrowersTransactions = async (start: string, end: stri
   if (!selectedBorrowerIds) {
     return [{ transactions: [header] }];
   }
-  const allTransactions: { [borrowerId: string]: unknown[] } = {};
-  await Promise.all(selectedBorrowerIds.map(async (borrowerId) => {
-    const products = await getLoanProducts(borrowerId);
-    const periodFull = await getBorrowerWithPeriods(borrowerId, {
+
+  const periodFull = selectedPeriod === 'ENTIRE_LOAN'
+    ? [{
+      period: {
+        selectedPeriod: selectedPeriod,
+        start: dayjs(start).utc().toDate().toISOString(),
+        end: dayjs(end).utc().toDate().toISOString(),
+      },
+    }]
+    : await getBorrowerWithPeriods(selectedBorrowerIds[0], {
       selectedStart: new Date(start),
       selectedEnd: new Date(end),
       selectedPeriod,
     });
-    const someMappedResults = products.reduce((acc, product) => {
-      return [
-        ...acc,
-        ...periodFull.map((periodDesc) => ({
-          productStart: periodDesc.period.start,
-          productEnd: periodDesc.period.end,
-          productId: product._id.toString(),
-        })),
-      ];
-    }, []);
-    await Promise.all(someMappedResults.map(async (productDesc) => {
-      const borrowerTransactions = await getLedger(
-        productDesc.productId,
-        new Date(productDesc.productStart),
-        new Date(productDesc.productEnd),
-        ledgerType,
-        true,
-      );
-      Object.values(borrowerTransactions).forEach((transactions) => {
-        const [_header, ...onlyData] = transactions;
-        const mappedData = _.map(onlyData, (obj) => _.omit(obj, ['balance', 'floatedBalance']));
-        allTransactions[borrowerId] = mappedData;
-      });
-    }));
+
+  const allProductIds = [];
+  await Promise.all(selectedBorrowerIds.map(async (borrowerId) => {
+    const borrowerProducts = await getLoanProducts(borrowerId);
+    allProductIds.push(borrowerProducts.map((product) => product._id.toString()));
   }));
-  const sortedTransactions = [];
-  for (const borrowerId of selectedBorrowerIds) {
-    console.log(borrowerId);
-    sortedTransactions.push(...allTransactions[borrowerId]);
-  }
-  return [{ transactions: [header, ...sortedTransactions] }];
+
+  const products = await LoanProduct.find({ borrowerId: { $in: selectedBorrowerIds.map((id) => new mongoose.Types.ObjectId(id)) } }).lean();
+  const productIds = products.map((product) => product._id.toString());
+  const ledgerData = await getLedger({
+      productIds,
+      startDate: new Date(dayjs(periodFull[0].period.start).utc().toDate().toISOString()),
+      endDate: new Date(dayjs(periodFull[0].period.end).utc().toDate().toISOString()),
+      reportType: ledgerType,
+    }, { showBalances: false, showFloatedBalance: false },
+  );
+  const transactions = Object.values(ledgerData).reduce((acc, ledgerTransaction) => [...acc, ...ledgerTransaction], []);
+  const transactionsWithoutBalance = _.map(transactions, (obj) => _.omit(obj, ['balance', 'floatedBalance']));
+  return [{ transactions: [header, ...transactionsWithoutBalance] }];
 };
 
 export const getBorrowerWithPeriods = async (borrowerId: string, period: {

package/db/microservice-tasks.db.d.ts

@@ -1,6 +1,31 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import mongoose from 'mongoose';
 import { EMicroserviceTask } from '../enums/microservice-task.enum';
 import { IMicroserviceTaskDoc } from '../models/MicroserviceTask.model';
-export declare const createMicroserviceTasks: (cmd: EMicroserviceTask, params: any, executeAt?: Date) => Promise<void>;
+export declare const createMicroserviceTasks: (cmd: EMicroserviceTask, params: any, executeAt?: Date, userId?: mongoose.Types.ObjectId) => Promise<void>;
 export declare const findFirstTask: () => Promise<IMicroserviceTaskDoc>;
 export declare const getAllTasks: () => Promise<IMicroserviceTaskDoc[]>;
 export declare const deleteTask: (taskId: string) => Promise<void>;

package/db/microservice-tasks.db.js

@@ -3,14 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteTask = exports.getAllTasks = exports.findFirstTask = exports.createMicroserviceTasks = void 0;
 const MicroserviceTask_model_1 = require("../models/MicroserviceTask.model");
 const microservice_task_statuses_enum_1 = require("../enums/microservice-task-statuses.enum");
-const createMicroserviceTasks = async (cmd, params, executeAt = new Date()) => {
+const createMicroserviceTasks = async (cmd, params, executeAt = new Date(), userId) => {
     const tasks = await MicroserviceTask_model_1.MicroserviceTaskModel.find({ cmd, params, status: microservice_task_statuses_enum_1.EMicroserviceTaskStatuses.SCHEDULED });
     if (!tasks.length) {
         const newTask = await MicroserviceTask_model_1.MicroserviceTaskModel.create({
+            userId,
             cmd,
             params,
             status: microservice_task_statuses_enum_1.EMicroserviceTaskStatuses.SCHEDULED,
-            executeAt
+            executeAt,
         });
         await newTask.save();
     }
@@ -24,16 +25,16 @@ const findFirstTask = async () => {
                 'status': microservice_task_statuses_enum_1.EMicroserviceTaskStatuses.SCHEDULED,
                 $or: [
                     { 'executeAt': { $exists: false } },
-                    { 'executeAt': { $lte: currentDate } }
-                ]
-            }
+                    { 'executeAt': { $lte: currentDate } },
+                ],
+            },
         }, {
             $sort: {
-                'createdAt': 1
-            }
+                'createdAt': 1,
+            },
         }, {
-            $limit: 1
-        }
+            $limit: 1,
+        },
     ]);
     if (lastTasks.length) {
         return lastTasks[0];

package/db/microservice-tasks.db.ts

@@ -1,19 +1,22 @@
+import mongoose from 'mongoose';
+
 import { EMicroserviceTask } from '../enums/microservice-task.enum';
 import { IMicroserviceTaskDoc, MicroserviceTaskModel } from '../models/MicroserviceTask.model';
 import { EMicroserviceTaskStatuses } from '../enums/microservice-task-statuses.enum';
 
-export const createMicroserviceTasks = async (cmd: EMicroserviceTask, params: any, executeAt: Date = new Date()): Promise<void> => {
+export const createMicroserviceTasks = async (cmd: EMicroserviceTask, params: any, executeAt: Date = new Date(), userId?: mongoose.Types.ObjectId): Promise<void> => {
   const tasks = await MicroserviceTaskModel.find({ cmd, params, status: EMicroserviceTaskStatuses.SCHEDULED });
   if (!tasks.length) {
     const newTask = await MicroserviceTaskModel.create({
+      userId,
       cmd,
       params,
       status: EMicroserviceTaskStatuses.SCHEDULED,
-      executeAt
+      executeAt,
     });
     await newTask.save();
   }
-}
+};
 
 export const findFirstTask = async (): Promise<IMicroserviceTaskDoc> => {
   const currentDate = new Date();
@@ -23,30 +26,30 @@ export const findFirstTask = async (): Promise<IMicroserviceTaskDoc> => {
         'status': EMicroserviceTaskStatuses.SCHEDULED,
         $or: [
           { 'executeAt': { $exists: false } },
-          { 'executeAt': { $lte: currentDate } }
-        ]
-      }
+          { 'executeAt': { $lte: currentDate } },
+        ],
+      },
     }, {
       $sort: {
-        'createdAt': 1
-      }
+        'createdAt': 1,
+      },
     }, {
-      $limit: 1
-    }
+      $limit: 1,
+    },
   ]);
   if (lastTasks.length) {
     return lastTasks[0];
   }
   return null;
-}
+};
 
 export const getAllTasks = async (): Promise<IMicroserviceTaskDoc[]> => {
   return MicroserviceTaskModel
     .find({})
     .sort({ 'createdAt': 1 });
-}
+};
 
 export const deleteTask = async (taskId: string): Promise<void> => {
   await MicroserviceTaskModel
     .findByIdAndDelete(taskId);
-}
+};

package/db/reports.db.d.ts

@@ -1,4 +1,31 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import { ILoanProductDoc } from '../models/LoanProducts.model';
 import { ELedgerReportType } from './loan-statement.db';
+import mongoose from 'mongoose';
+import { ILoanTransactionDoc } from '../models/LoanTransaction.model';
 export declare enum EChargeType {
     INTEREST_FEE = "INTEREST",
     ADMIN_FEE = "ADMIN FEE",
@@ -49,8 +76,21 @@ export interface ILedgerDataRow {
     paymentDate: Date;
     isBrokerFee?: boolean;
 }
-export declare const getLedger: (productId: string, startDate: Date, endDate: Date, reportType: ELedgerReportType, showFloatedBalance?: boolean) => Promise<{
-    [x: string]: string[][];
-} | {
-    [x: string]: Pick<any, string>[];
+export type LedgerTransactions = {
+    transactions: ILoanTransactionDoc[];
+    product: ILoanProductDoc;
+    productId: mongoose.Types.ObjectId;
+};
+export type ReportLedgerParams = {
+    productIds: string[];
+    startDate: Date;
+    endDate: Date;
+    reportType: ELedgerReportType;
+};
+export type ReportLedgerOptions = {
+    showFloatedBalance: boolean;
+    showBalances: boolean;
+};
+export declare const getLedger: (params: ReportLedgerParams, options?: ReportLedgerOptions) => Promise<{
+    [productId: string]: ILedgerReportRow[];
 }>;