gemcap-be-common 1.2.63 → 1.2.65

package/db/reports.db.ts

@@ -7,7 +7,7 @@ import mongoose from 'mongoose';
 import { BorrowerModel } from '../models/Borrower.model';
 import {
   ELoanTransactionTypes,
-  ILoanTransactionDocWithProduct,
+  ILoanTransactionDoc,
   LoanTransaction,
 } from '../models/LoanTransaction.model';
 import { ELoanTypes } from '../enums/loan-types.enum';
@@ -77,42 +77,87 @@ export interface ILedgerDataRow {
   isBrokerFee?: boolean;
 }
 
-export const getLedger = async (productId: string, startDate: Date, endDate: Date, reportType: ELedgerReportType, showFloatedBalance = true) => {
-  const product: ILoanProductDoc = await LoanProduct.findById(productId).lean();
+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,
+}
+
+const defaultReportLedgerOptions: ReportLedgerOptions = {
+  showBalances: true,
+  showFloatedBalance: true,
+};
 
-  const emptyWorkBook = { [`${product.code} - ${product.name}`]: [['']] };
-  if (startDate === null || endDate === null) {
-    return emptyWorkBook;
-  }
-  const fullTransactions = await getLedgerData(productId, startDate, endDate);
+export const getLedger = async (params: ReportLedgerParams, options = defaultReportLedgerOptions): Promise<{
+  [productId: string]: ILedgerReportRow  []
+}> => {
+  const { productIds, reportType } = params;
+  const fullTransactions = await getLedgerData(params, options);
+  const products = await LoanProduct
+    .find({ _id: { $in: productIds.map((id) => new mongoose.Types.ObjectId(id)) } })
+    .sort({ code: 1 })
+    .lean();
 
   const header = ledgerHeadersMap[reportType];
-  const headerKeys = showFloatedBalance
+  const headerKeys = options.showFloatedBalance
     ? Object.keys(header).filter((key) => key !== 'floatedBalance')
     : Object.keys(header);
 
   const sumKeys = ['amount', 'statementAmount'];
   const groupKeys = headerKeys.filter((key) => !sumKeys.includes(key));
-  const finalTransactions = reportType === ELedgerReportType.SHORT
-    ? mergeLedgerData(fullTransactions, groupKeys, sumKeys)
-    : fullTransactions;
 
-  const mappedArray = _.map([header, ...finalTransactions], (obj) => _.pick(obj, headerKeys));
-  const sheetName = `${product.code} - ${product.name}`;
-  return { [sheetName]: mappedArray };
+  return products.reduce((acc, product) => {
+    const transactions = fullTransactions[product._id.toString()];
+    const finalTransactions = reportType === ELedgerReportType.SHORT
+      ? mergeLedgerData(transactions, groupKeys, sumKeys)
+      : transactions;
+    const sheetName = `${product.code} - ${product.name}`;
+    return {
+      ...acc,
+      [sheetName]: _.map(finalTransactions, (obj) => _.pick(obj, headerKeys)) as ILedgerReportRow[],
+    };
+  }, {});
 };
 
-const getLedgerData = async (productId: string, startDate: Date, endDate: Date): Promise<ILedgerReportRow[]> => {
+const getLedgerData = async (params: ReportLedgerParams, options = defaultReportLedgerOptions): Promise<{
+  [productId: string]: ILedgerReportRow[]
+}> => {
+  const { productIds, startDate, endDate } = params;
+
   const addBrokers = true;
-  const product: ILoanProductDoc = await LoanProduct.findById(productId).lean();
-  const borrower = await BorrowerModel.findById(product.borrowerId).lean();
-  const transactions = await LoanTransaction.aggregate<ILoanTransactionDocWithProduct>([
+  const products = await LoanProduct.find({ _id: { $in: productIds.map((id) => new mongoose.Types.ObjectId(id)) } }).lean();
+  const borrowers = await BorrowerModel.find({ _id: { $in: products.map((product) => product.borrowerId) } }).lean();
+  const borrowerMap = borrowers.reduce((acc, borrower) => (
+    { ...acc, [borrower._id.toString()]: borrower.code }
+  ), {});
+  const borrowerCodesMap = products.reduce((acc, product): { [productId: string]: string } => ({
+    ...acc,
+    [product._id.toString()]: borrowerMap[product.borrowerId.toString()],
+  }), {});
+
+  const groupedTransactions = await LoanTransaction.aggregate<LedgerTransactions>([
     {
       $match: {
         $and: [
           { 'date': { $gte: startDate } },
           { 'date': { $lte: dayjs(endDate).endOf('day').toDate() } },
-          { 'productId': new mongoose.Types.ObjectId(productId) },
+          {
+            productId: {
+              $in: products.map((product) => product._id),
+            },
+          },
         ],
       },
     }, {
@@ -132,207 +177,240 @@ const getLedgerData = async (productId: string, startDate: Date, endDate: Date):
         'order': 1,
       },
     },
-  ]);
-  const convertTypes = (transactionType: ELoanTransactionTypes) => {
-    if (product.type === ELoanTypes.TERM && transactionType === ELoanTransactionTypes.COLLECTION) {
-      return 'PRINCIPAL';
-    }
-    return transactionType;
-  };
-  const mappedTransactions = transactions.map((transaction) => {
-    return <ILedgerDataRow>{
-      typeOrder: 0,
-      order: transaction.order,
-      date: transaction.date,
-      type: convertTypes(transaction.transactionType),
-      amount: transaction.amount,
-      statementAmount: null,
-      title: convertTypes(transaction.transactionType),
-      balance: transaction.balance,
-      floatedBalance: transaction.floatedBalance,
-      chargeCode: transaction.product.code,
-      PLCode: null,
-      productCode: transaction.product.code,
-      productName: transaction.product.name,
-      createdAt: transaction['createdAt'],
-      info: transaction.reference,
-      paymentDate: null,
-    };
-  });
-
-  const loanCharges = await getLoanChargeForProduct(productId);
-  const chargesIds = loanCharges.map((charge) => charge._id);
-  const statementTransactions = await LoanStatementTransactionModel.aggregate<ILoanStatementTransactionDocWithCharge>([
     {
-      $match: {
-        $and: [
-          { 'date': { $gte: startDate } },
-          { 'date': { $lte: dayjs(endDate).endOf('day').toDate() } },
-          { 'chargeId': { '$in': chargesIds } },
-        ],
-      },
-    }, {
-      $lookup: {
-        from: 'loan_charges',
-        localField: 'chargeId',
-        foreignField: '_id',
-        as: 'charge',
-      },
-    }, {
-      $unwind: {
-        path: '$charge',
+      $group: {
+        _id: '$productId',
+        transactions: { $push: '$$ROOT' },
+        product: { $first: '$product' },
       },
-    }, {
-      $sort: {
-        'date': 1,
-        'createdAt': 1,
-        'order': 1,
+    },
+    {
+      $project: {
+        _id: 0,
+        productId: '$_id',
+        product: 1,
+        transactions: 1,
       },
     },
   ]);
 
-  const statementTransactionsWithBalance = await Promise.all(statementTransactions.map(async (statement) => {
-    const balances = await getLoanProductBalance(productId, statement.date);
+  const convertTypes = (transactionType: ELoanTransactionTypes, product: ILoanProductDoc): EChargeType => {
+    if (product.type === ELoanTypes.TERM && transactionType === ELoanTransactionTypes.COLLECTION) {
+      return EChargeType.PRINCIPAL;
+    }
+    return EChargeType[transactionType];
+  };
+
+  const mappedGroups: {
+    [productId: string]: { transactions: ILedgerDataRow[], product: ILoanProductDoc }
+  } = groupedTransactions.reduce((acc, group) => {
     return {
-      ...statement,
-      balance: balances.balance,
-      floatedBalance: balances.floatedBalance,
+      ...acc,
+      [group.productId.toString()]: {
+        product: group.product,
+        transactions: group.transactions.map((transaction): ILedgerDataRow => {
+          return {
+            typeOrder: 0,
+            order: transaction.order,
+            date: transaction.date,
+            type: convertTypes(transaction.transactionType, group.product),
+            amount: transaction.amount,
+            statementAmount: null,
+            title: convertTypes(transaction.transactionType, group.product),
+            balance: transaction.balance,
+            floatedBalance: transaction.floatedBalance,
+            chargeCode: group.product.code,
+            PLCode: null,
+            productCode: group.product.code,
+            productName: group.product.name,
+            createdAt: transaction['createdAt'],
+            info: transaction.reference,
+            paymentDate: null,
+          };
+        }),
+      },
     };
-  }));
+  }, {});
 
-  const isParticipant = product.isParticipant;
-  const groupedMappedStatementTransactions = await Promise.all(statementTransactionsWithBalance.map(async (statement) => {
+  const allData = {};
+  await Promise.all(Object.entries(mappedGroups).map(async ([productId, group]) => {
+    const loanCharges = await getLoanChargeForProduct(productId);
+    const chargesIds = loanCharges.map((charge) => charge._id);
+    const statementTransactions = await LoanStatementTransactionModel.aggregate<ILoanStatementTransactionDocWithCharge>([
+      {
+        $match: {
+          $and: [
+            { 'date': { $gte: startDate } },
+            { 'date': { $lte: dayjs(endDate).endOf('day').toDate() } },
+            { 'chargeId': { '$in': chargesIds } },
+          ],
+        },
+      }, {
+        $lookup: {
+          from: 'loan_charges',
+          localField: 'chargeId',
+          foreignField: '_id',
+          as: 'charge',
+        },
+      }, {
+        $unwind: {
+          path: '$charge',
+        },
+      }, {
+        $sort: {
+          'date': 1,
+          'createdAt': 1,
+          'order': 1,
+        },
+      },
+    ]);
 
-    const transactions = [];
+    const statementTransactionsWithBalance = options.showBalances
+      ? await Promise.all(statementTransactions.map(async (statement) => {
+        const balances = await getLoanProductBalance(productId, statement.date);
+        return {
+          ...statement,
+          balance: balances.balance,
+          floatedBalance: balances.floatedBalance,
+        };
+      }))
+      : statementTransactions.slice();
 
-    if (statement.amountPaid > 0) {
-      const payments = await getPaymentForTransaction(productId, statement._id.toString());
-      for (const payment of payments) {
-        transactions.push({
-          typeOrder: 1,
-          order: statement.order,
-          date: statement.date,
-          type: statement.charge.chargeType,
-          amount: null,
-          statementAmount: isParticipant ? statement.amountPaid : -statement.amountPaid,
-          title: `${statement.charge.name} PAID`,
-          chargeCode: statement.charge.code,
-          PLCode: statement.charge.PLCode,
-          productCode: product.code,
-          productName: product.name,
-          balance: statement.balance,
-          floatedBalance: statement.floatedBalance,
-          createdAt: statement['createdAt'],
-          info: statement.memo,
-          paymentDate: dayjs(payment.date).format(defaultDateFormat),
-        });
-      }
-    }
-    return [...transactions, {
-      typeOrder: 1,
-      order: statement.order,
-      date: statement.date,
-      type: statement.charge.chargeType,
-      amount: null,
-      statementAmount: isParticipant ? -statement.amount : statement.amount,
-      title: `${statement.charge.name} ACCRUED`,
-      chargeCode: statement.charge.code,
-      PLCode: statement.charge.PLCode,
-      productCode: product.code,
-      productName: product.name,
-      balance: statement.balance,
-      floatedBalance: statement.floatedBalance,
-      createdAt: statement['createdAt'],
-      info: statement.memo,
-      paymentDate: null,
-    }];
-  }));
-  const mappedStatementTransactions: ILedgerDataRow[] = groupedMappedStatementTransactions
-    .reduce((acc, group) => [...acc, ...group], []);
-  const statementTransactionsWithBrokers = addBrokers
-    ? await enrichWithBrokers(mappedStatementTransactions, product)
-    : mappedStatementTransactions;
-  const sortedTransactions = [...statementTransactionsWithBrokers, ...mappedTransactions]
-    .sort((a, b) => {
-      if (a.date.valueOf() !== b.date.valueOf()) {
-        return b.date.valueOf() - a.date.valueOf();
-      }
-      if (a.typeOrder !== b.typeOrder) {
-        return b.typeOrder - a.typeOrder;
-      }
-      return b.createdAt.valueOf() - a.createdAt.valueOf();
-    });
+    const isParticipant = group.product.isParticipant;
+    const groupedMappedStatementTransactions = await Promise.all(statementTransactionsWithBalance.map(async (statement) => {
 
-  const fullTransactions = sortedTransactions
-    .map((row): ILedgerReportRow => ({
-      borrowerCode: borrower.code,
-      date: formatDate(row.date),
-      type: !!row.isBrokerFee ? `${EChargeType[row.type]} BROKER` : EChargeType[row.type],
-      chargeCode: row.chargeCode,
-      PLCode: row.PLCode,
-      productCode: row.productCode,
-      productName: row.productName,
-      amount: row.amount,
-      statementAmount: row.statementAmount,
-      title: row.title,
-      balance: row.balance,
-      floatedBalance: row.floatedBalance,
-      info: row.info,
-      paymentDate: row.paymentDate ? formatDate(row.paymentDate) : '',
-    }));
+      const transactions = [];
 
-  const termLoan = await TermLoanModel.findOne({ productId, actual: true });
-  if (termLoan) {
-    const calculatedTermLoan = await TermLoanCalculatedModel.findOne({
-      termLoanId: termLoan._id.toString(),
-      relevantStatement: dayjs(endDate).format('YYYY-MM-DD'),
-    });
-    if (calculatedTermLoan) {
-      const expectedPayment = <ILedgerReportRow>{
-        borrowerCode: borrower.code,
-        date: formatDate(endDate),
-        type: EChargeType.EXPECTED_PRINCIPAL,
-        chargeCode: null,
-        PLCode: null,
-        productCode: product.code,
-        amount: isParticipant ? -calculatedTermLoan.monthlyPrincipal : calculatedTermLoan.monthlyPrincipal,
-        statementAmount: null,
-        title: EChargeType.EXPECTED_PRINCIPAL,
-        balance: null,
-        floatedBalance: null,
-        info: EChargeType.EXPECTED_PRINCIPAL,
+      if (statement.amountPaid > 0) {
+        const payments = await getPaymentForTransaction(productId, statement._id.toString());
+        for (const payment of payments) {
+          transactions.push({
+            typeOrder: 1,
+            order: statement.order,
+            date: statement.date,
+            type: statement.charge.chargeType,
+            amount: null,
+            statementAmount: isParticipant ? statement.amountPaid : -statement.amountPaid,
+            title: `${statement.charge.name} PAID`,
+            chargeCode: statement.charge.code,
+            PLCode: statement.charge.PLCode,
+            productCode: group.product.code,
+            productName: group.product.name,
+            balance: statement.balance,
+            floatedBalance: statement.floatedBalance,
+            createdAt: statement['createdAt'],
+            info: statement.memo,
+            paymentDate: dayjs(payment.date).format(defaultDateFormat),
+          });
+        }
+      }
+      return [...transactions, {
+        typeOrder: 1,
+        order: statement.order,
+        date: statement.date,
+        type: statement.charge.chargeType,
+        amount: null,
+        statementAmount: isParticipant ? -statement.amount : statement.amount,
+        title: `${statement.charge.name} ACCRUED`,
+        chargeCode: statement.charge.code,
+        PLCode: statement.charge.PLCode,
+        productCode: group.product.code,
+        productName: group.product.name,
+        balance: statement.balance,
+        floatedBalance: statement.floatedBalance,
+        createdAt: statement['createdAt'],
+        info: statement.memo,
         paymentDate: null,
-      };
-      fullTransactions.unshift(expectedPayment);
-      if (calculatedTermLoan.payments && calculatedTermLoan.payments.length > 0) {
-        for (const payment of calculatedTermLoan.payments) {
-          const paymentDoc = await LoanTransaction.findById(payment.paymentId).lean();
-          if (paymentDoc) {
-            const expectedPayment = <ILedgerReportRow>{
-              borrowerCode: borrower.code,
-              date: formatDate(endDate),
-              type: EChargeType.EXPECTED_PRINCIPAL_PAID,
-              chargeCode: null,
-              PLCode: null,
-              productCode: product.code,
-              amount: isParticipant ? -payment.amount : payment.amount,
-              statementAmount: null,
-              title: EChargeType.EXPECTED_PRINCIPAL_PAID,
-              balance: null,
-              floatedBalance: null,
-              info: EChargeType.EXPECTED_PRINCIPAL_PAID,
-              paymentDate: formatDate(paymentDoc.date),
-            };
-            fullTransactions.unshift(expectedPayment);
+      }];
+    }));
+    const mappedStatementTransactions: ILedgerDataRow[] = groupedMappedStatementTransactions
+      .reduce((acc, group) => [...acc, ...group], []);
+    const statementTransactionsWithBrokers = addBrokers
+      ? await enrichWithBrokers(mappedStatementTransactions, group.product)
+      : mappedStatementTransactions;
+    const sortedTransactions = [...statementTransactionsWithBrokers, ...group.transactions]
+      .sort((a, b) => {
+        if (a.date.valueOf() !== b.date.valueOf()) {
+          return b.date.valueOf() - a.date.valueOf();
+        }
+        if (a.typeOrder !== b.typeOrder) {
+          return b.typeOrder - a.typeOrder;
+        }
+        return b.createdAt.valueOf() - a.createdAt.valueOf();
+      });
+
+    const fullTransactions = sortedTransactions
+      .map((row): ILedgerReportRow => ({
+        borrowerCode: borrowerCodesMap[productId],
+        date: formatDate(row.date),
+        type: row.isBrokerFee ? `${EChargeType[row.type]} BROKER` : EChargeType[row.type],
+        chargeCode: row.chargeCode,
+        PLCode: row.PLCode,
+        productCode: row.productCode,
+        productName: row.productName,
+        amount: row.amount,
+        statementAmount: row.statementAmount,
+        title: row.title,
+        balance: row.balance,
+        floatedBalance: row.floatedBalance,
+        info: row.info,
+        paymentDate: row.paymentDate ? formatDate(row.paymentDate) : '',
+      }));
+
+    const termLoan = await TermLoanModel.findOne({ productId, actual: true });
+    if (termLoan) {
+      const calculatedTermLoan = await TermLoanCalculatedModel.findOne({
+        termLoanId: termLoan._id.toString(),
+        relevantStatement: dayjs(endDate).format('YYYY-MM-DD'),
+      });
+      if (calculatedTermLoan) {
+        const expectedPayment = <ILedgerReportRow>{
+          borrowerCode: borrowerCodesMap[productId],
+          date: formatDate(endDate),
+          type: EChargeType.EXPECTED_PRINCIPAL,
+          chargeCode: null,
+          PLCode: null,
+          productCode: group.product.code,
+          amount: isParticipant ? -calculatedTermLoan.monthlyPrincipal : calculatedTermLoan.monthlyPrincipal,
+          statementAmount: null,
+          title: EChargeType.EXPECTED_PRINCIPAL,
+          balance: null,
+          floatedBalance: null,
+          info: EChargeType.EXPECTED_PRINCIPAL,
+          paymentDate: null,
+        };
+        fullTransactions.unshift(expectedPayment);
+        if (calculatedTermLoan.payments && calculatedTermLoan.payments.length > 0) {
+          for (const payment of calculatedTermLoan.payments) {
+            const paymentDoc = await LoanTransaction.findById(payment.paymentId).lean();
+            if (paymentDoc) {
+              const expectedPayment = <ILedgerReportRow>{
+                borrowerCode: borrowerCodesMap[productId],
+                date: formatDate(endDate),
+                type: EChargeType.EXPECTED_PRINCIPAL_PAID,
+                chargeCode: null,
+                PLCode: null,
+                productCode: group.product.code,
+                amount: isParticipant ? -payment.amount : payment.amount,
+                statementAmount: null,
+                title: EChargeType.EXPECTED_PRINCIPAL_PAID,
+                balance: null,
+                floatedBalance: null,
+                info: EChargeType.EXPECTED_PRINCIPAL_PAID,
+                paymentDate: formatDate(paymentDoc.date),
+              };
+              fullTransactions.unshift(expectedPayment);
+            }
           }
         }
       }
     }
-  }
-  return fullTransactions;
+    allData[productId] = fullTransactions;
+  }));
+  return allData;
 };
 
-const mergeLedgerData = (transactions: ILedgerReportRow[], groupKeys: string[], sumKeys: string[]) => {
+const mergeLedgerData = (transactions: ILedgerReportRow[], groupKeys: string[], sumKeys: string[]): ILedgerReportRow[] => {
   const groupedObjects = _.groupBy(
     transactions,
     (obj) => groupKeys.reduce((acc, key) => `${acc}${obj[key]}`, ''),

package/enums/microservice-task.enum.d.ts

@@ -3,5 +3,6 @@ export declare enum EMicroserviceTask {
     ENABLE_PLAID_NOTIFICATION = "enable_plaid_notification",
     QUERY = "query",
     YIELD = "yield",
-    REPORT = "report"
+    REPORT = "report",
+    POST_UPLOAD = "post_upload"
 }

package/enums/microservice-task.enum.js

@@ -8,4 +8,5 @@ var EMicroserviceTask;
     EMicroserviceTask["QUERY"] = "query";
     EMicroserviceTask["YIELD"] = "yield";
     EMicroserviceTask["REPORT"] = "report";
+    EMicroserviceTask["POST_UPLOAD"] = "post_upload";
 })(EMicroserviceTask || (exports.EMicroserviceTask = EMicroserviceTask = {}));

package/enums/microservice-task.enum.ts

@@ -4,4 +4,5 @@ export enum EMicroserviceTask {
   QUERY = 'query',
   YIELD = 'yield',
   REPORT = 'report',
+  POST_UPLOAD = 'post_upload',
 }

package/package.json

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