gemcap-be-common 1.2.63 → 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/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[];
 }>;