gemcap-be-common 1.2.59 → 1.2.60

package/db/loan-statement.db.ts

@@ -1,7 +1,50 @@
+import _ from 'lodash';
 import mongoose from 'mongoose';
+import dayjs from 'dayjs';
 
-import { LoanStatementTransactionModel } from '../models/LoanStatementTransaction.model';
+import { IStatementPeriod, LoanStatementTransactionModel } from '../models/LoanStatementTransaction.model';
 import { LoanTransaction } from '../models/LoanTransaction.model';
+import { getLoanProductById, getLoanProducts } from './loan-products.db';
+import { LoanProduct } from '../models/LoanProducts.model';
+import { BorrowerModel } from '../models/Borrower.model';
+import { getLastTransactionForDate } from './loan-transactions.db';
+import { getLedger } from './reports.db';
+
+export enum ELedgerReportType {
+  SHORT,
+  DETAILED,
+}
+
+export const ledgerHeadersMap = {
+  [ELedgerReportType.SHORT]: {
+    borrowerCode: 'borrower code',
+    type: 'type',
+    chargeCode: 'BS code',
+    PLCode: 'P&L code',
+    productCode: 'product code',
+    productName: 'product name',
+    info: 'memo/reference',
+    title: 'title',
+    amount: 'amount',
+    statementAmount: 'Statement amount',
+  },
+  [ELedgerReportType.DETAILED]: {
+    borrowerCode: 'borrower code',
+    date: 'date',
+    type: 'type',
+    chargeCode: 'BS code',
+    PLCode: 'P&L code',
+    productCode: 'product code',
+    productName: 'product name',
+    info: 'memo/reference',
+    amount: 'amount',
+    statementAmount: 'Statement amount',
+    title: 'title',
+    balance: 'balance',
+    floatedBalance: 'floated balance',
+    paymentDate: 'payment date',
+  },
+};
 
 export const getTotalTransactionAmountForCharge = async (chargeId: string, start: Date, end: Date) => {
   const results = await LoanStatementTransactionModel.aggregate([
@@ -48,7 +91,162 @@ export const getTotalForDate = async (productId: string, date: Date): Promise<nu
     },
   ]);
   if (totalAmount.length === 0) {
-  return 0;
-}
-return totalAmount[0].totalAmount;
-}
+    return 0;
+  }
+  return totalAmount[0].totalAmount;
+};
+
+export const getStatementBorrowersTransactions = async (start: string, end: string, selectedPeriod: string, selectedBorrowerIds: string[], ledgerType: ELedgerReportType) => {
+
+  const header = ledgerHeadersMap[ledgerType];
+
+  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, {
+      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 sortedTransactions = [];
+  for (const borrowerId of selectedBorrowerIds) {
+    console.log(borrowerId);
+    sortedTransactions.push(...allTransactions[borrowerId]);
+  }
+  return [{ transactions: [header, ...sortedTransactions] }];
+};
+
+export const getBorrowerWithPeriods = async (borrowerId: string, period: {
+  selectedPeriod: string,
+  selectedStart: Date,
+  selectedEnd: Date
+}, splitPeriods = false) => {
+  const borrower = await BorrowerModel.findById(borrowerId).lean();
+  let start: dayjs.Dayjs;
+  let end: dayjs.Dayjs;
+  switch (period.selectedPeriod) {
+    case 'SELECTED_PERIOD': {
+      start = dayjs(new Date(period.selectedStart)).startOf('day');
+      end = dayjs(new Date(period.selectedEnd)).endOf('day');
+      break;
+    }
+    case 'ENTIRE_LOAN': {
+      const products = await LoanProduct.find({ borrowerId: borrower._id.toString() }).lean();
+      const productPeriods = await Promise.all(products.map(async (product) => {
+        const periods = await getPeriods(period.selectedPeriod, product._id.toString());
+        const periodStart = periods[0].start.startOf('day');
+        const periodEnd = periods[periods.length - 1].end.endOf('day');
+        return { periodStart, periodEnd };
+      }));
+      const starts = productPeriods.map((p) => p.periodStart);
+      const ends = productPeriods.map((p) => p.periodEnd);
+      start = dayjs.min(starts);
+      end = dayjs.max(ends);
+      break;
+    }
+    default: {
+      const periods = await getPeriods(period.selectedPeriod, null);
+      start = periods[0].start.startOf('day');
+      end = periods[periods.length - 1].end.endOf('day');
+      break;
+    }
+  }
+
+  if (splitPeriods) {
+    const result = [];
+    let currentMonth = start.startOf('month');
+    while (currentMonth.isBefore(end) || currentMonth.isSame(end, 'month')) {
+      const startOfMonth = currentMonth.startOf('month');
+      const endOfMonth = currentMonth.endOf('month');
+      result.push({
+        _id: borrower._id.toString(),
+        code: borrower.code,
+        name: borrower.name,
+        period: {
+          selectedPeriod: period.selectedPeriod,
+          start: startOfMonth.utc().toDate().toISOString(),
+          end: endOfMonth.utc().toDate().toISOString(),
+        },
+      });
+      currentMonth = currentMonth.add(1, 'month');
+    }
+    return result;
+  } else {
+    return [{
+      _id: borrower._id.toString(),
+      code: borrower.code,
+      name: borrower.name,
+      period: {
+        selectedPeriod: period.selectedPeriod,
+        start: start.utc().toDate().toISOString(),
+        end: end.utc().toDate().toISOString(),
+      },
+    }];
+  }
+};
+
+export const getPeriods = async (selectedPeriod: string, productId: string): Promise<IStatementPeriod[]> => {
+  let start: dayjs.Dayjs;
+  let end: dayjs.Dayjs;
+  switch (selectedPeriod) {
+    case 'CURRENT_MONTH': {
+      start = dayjs().utcOffset(0).startOf('month');
+      end = dayjs().utcOffset(0).endOf('month');
+      return [{ start, end }];
+    }
+    case 'LAST_MONTH': {
+      start = dayjs().subtract(1, 'month').utcOffset(0).startOf('month');
+      end = dayjs().subtract(1, 'month').utcOffset(0).endOf('month');
+      return [{ start, end }];
+    }
+    case 'ENTIRE_LOAN': {
+      const product = await getLoanProductById(productId);
+      const lastTransaction = await getLastTransactionForDate(productId);
+      start = dayjs(product.startDate).tz('UTC');
+      let lastDate = dayjs(new Date()).endOf('month').toDate();
+      if (lastTransaction) {
+        if (dayjs(lastTransaction.date).tz('UTC').toDate() > dayjs(new Date()).endOf('month').toDate()) {
+          lastDate = lastTransaction.date;
+        }
+      }
+      end = dayjs(lastDate);
+      const finish = dayjs(lastDate);
+      const periods = [];
+      do {
+        end = start.endOf('month');
+        periods.push({ start, end });
+        start = end.add(1, 'day').startOf('month').utc();
+      } while (finish.toDate() > end.toDate());
+      return periods;
+    }
+  }
+  return [];
+};

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

@@ -0,0 +1,2 @@
+import { ILoanTransactionDoc } from '../models/LoanTransaction.model';
+export declare const getLastTransactionForDate: (productId: string, date?: Date, excludeAdjustments?: boolean) => Promise<ILoanTransactionDoc>;

package/db/loan-transactions.db.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLastTransactionForDate = void 0;
+const LoanTransaction_model_1 = require("../models/LoanTransaction.model");
+const mongoose_1 = __importDefault(require("mongoose"));
+const getLastTransactionForDate = async (productId, date = new Date(), excludeAdjustments = false) => {
+    const excludeFilter = excludeAdjustments
+        ? {
+            'transactionType': {
+                $nin: ['ADJUSTMENT'],
+            },
+        }
+        : {};
+    const lastTransaction = await LoanTransaction_model_1.LoanTransaction.aggregate([
+        {
+            $match: {
+                'productId': new mongoose_1.default.Types.ObjectId(productId),
+                'date': { $lte: date },
+                ...excludeFilter,
+            },
+        }, {
+            $sort: {
+                'date': -1,
+                'order': -1,
+                'createdAt': -1,
+            },
+        }, {
+            $limit: 1,
+        },
+    ]);
+    if (!lastTransaction.length) {
+        return null;
+    }
+    return lastTransaction[0];
+};
+exports.getLastTransactionForDate = getLastTransactionForDate;

package/db/loan-transactions.db.ts

@@ -0,0 +1,33 @@
+import { ILoanTransactionDoc, LoanTransaction } from '../models/LoanTransaction.model';
+import mongoose from 'mongoose';
+
+export const getLastTransactionForDate = async (productId: string, date: Date = new Date(), excludeAdjustments = false) => {
+  const excludeFilter = excludeAdjustments
+    ? {
+      'transactionType': {
+        $nin: ['ADJUSTMENT'],
+      },
+    }
+    : {};
+  const lastTransaction = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+    {
+      $match: {
+        'productId': new mongoose.Types.ObjectId(productId),
+        'date': { $lte: date },
+        ...excludeFilter,
+      },
+    }, {
+      $sort: {
+        'date': -1,
+        'order': -1,
+        'createdAt': -1,
+      },
+    }, {
+      $limit: 1,
+    },
+  ]);
+  if (!lastTransaction.length) {
+    return null;
+  }
+  return lastTransaction[0];
+};

package/db/reports.db.d.ts

@@ -0,0 +1,56 @@
+import { ELedgerReportType } from './loan-statement.db';
+export declare enum EChargeType {
+    INTEREST_FEE = "INTEREST",
+    ADMIN_FEE = "ADMIN FEE",
+    UNUSED_LINE_FEE = "UNUSED LINE FEE",
+    ANNUAL_LINE_FEE = "ANNUAL LINE FEE",
+    WIRE_FEE = "WIRE FEE",
+    RECOVERABLE = "RECOVERABLE",
+    OTHER = "OTHER",
+    DISBURSEMENT = "DISBURSEMENT",
+    PRINCIPAL = "PRINCIPAL",
+    COLLECTION = "COLLECTION",
+    ADJUSTMENT = "ADJUSTMENT",
+    EXPECTED_PRINCIPAL = "EXPECTED PRINCIPAL ACCRUED",
+    EXPECTED_PRINCIPAL_PAID = "EXPECTED PRINCIPAL PAID"
+}
+export interface ILedgerReportRow {
+    borrowerCode: string;
+    date: string;
+    type: string;
+    chargeCode: string;
+    PLCode: string;
+    productCode: string;
+    productName: string;
+    amount: number;
+    statementAmount: number;
+    title: string;
+    balance: number;
+    floatedBalance: number;
+    info: string;
+    paymentDate: string;
+}
+export interface ILedgerDataRow {
+    typeOrder: number;
+    order: number;
+    date: Date;
+    type: EChargeType;
+    amount: number;
+    statementAmount: number;
+    title: string;
+    chargeCode: string;
+    PLCode: string;
+    productCode: string;
+    productName: string;
+    balance: number;
+    floatedBalance: number;
+    createdAt: Date;
+    info: string;
+    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>[];
+}>;

package/db/reports.db.js

@@ -0,0 +1,295 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLedger = exports.EChargeType = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const LoanProducts_model_1 = require("../models/LoanProducts.model");
+const loan_statement_db_1 = require("./loan-statement.db");
+const mongoose_1 = __importDefault(require("mongoose"));
+const Borrower_model_1 = require("../models/Borrower.model");
+const LoanTransaction_model_1 = require("../models/LoanTransaction.model");
+const loan_types_enum_1 = require("../enums/loan-types.enum");
+const LoanStatementTransaction_model_1 = require("../models/LoanStatementTransaction.model");
+const date_helper_1 = require("../helpers/date.helper");
+const dayjs_1 = __importDefault(require("dayjs"));
+const loan_charges_db_1 = require("./loan-charges.db");
+const loan_products_db_1 = require("./loan-products.db");
+const loan_payments_db_1 = require("./loan-payments.db");
+const brokers_db_1 = require("./brokers.db");
+const TermLoan_model_1 = require("../models/TermLoan.model");
+const TermLoanCalculated_model_1 = require("../models/TermLoanCalculated.model");
+var EChargeType;
+(function (EChargeType) {
+    EChargeType["INTEREST_FEE"] = "INTEREST";
+    EChargeType["ADMIN_FEE"] = "ADMIN FEE";
+    EChargeType["UNUSED_LINE_FEE"] = "UNUSED LINE FEE";
+    EChargeType["ANNUAL_LINE_FEE"] = "ANNUAL LINE FEE";
+    EChargeType["WIRE_FEE"] = "WIRE FEE";
+    EChargeType["RECOVERABLE"] = "RECOVERABLE";
+    EChargeType["OTHER"] = "OTHER";
+    EChargeType["DISBURSEMENT"] = "DISBURSEMENT";
+    EChargeType["PRINCIPAL"] = "PRINCIPAL";
+    EChargeType["COLLECTION"] = "COLLECTION";
+    EChargeType["ADJUSTMENT"] = "ADJUSTMENT";
+    EChargeType["EXPECTED_PRINCIPAL"] = "EXPECTED PRINCIPAL ACCRUED";
+    EChargeType["EXPECTED_PRINCIPAL_PAID"] = "EXPECTED PRINCIPAL PAID";
+})(EChargeType || (exports.EChargeType = EChargeType = {}));
+const getLedger = async (productId, startDate, endDate, reportType, showFloatedBalance = true) => {
+    const product = await LoanProducts_model_1.LoanProduct.findById(productId).lean();
+    const emptyWorkBook = { [`${product.code} - ${product.name}`]: [['']] };
+    if (startDate === null || endDate === null) {
+        return emptyWorkBook;
+    }
+    const fullTransactions = await getLedgerData(productId, startDate, endDate);
+    const header = loan_statement_db_1.ledgerHeadersMap[reportType];
+    const headerKeys = 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 === loan_statement_db_1.ELedgerReportType.SHORT
+        ? mergeLedgerData(fullTransactions, groupKeys, sumKeys)
+        : fullTransactions;
+    const mappedArray = lodash_1.default.map([header, ...finalTransactions], (obj) => lodash_1.default.pick(obj, headerKeys));
+    const sheetName = `${product.code} - ${product.name}`;
+    return { [sheetName]: mappedArray };
+};
+exports.getLedger = getLedger;
+const getLedgerData = async (productId, startDate, endDate) => {
+    const addBrokers = true;
+    const product = await LoanProducts_model_1.LoanProduct.findById(productId).lean();
+    const borrower = await Borrower_model_1.BorrowerModel.findById(product.borrowerId).lean();
+    const transactions = await LoanTransaction_model_1.LoanTransaction.aggregate([
+        {
+            $match: {
+                $and: [
+                    { 'date': { $gte: startDate } },
+                    { 'date': { $lte: (0, dayjs_1.default)(endDate).endOf('day').toDate() } },
+                    { 'productId': new mongoose_1.default.Types.ObjectId(productId) },
+                ],
+            },
+        }, {
+            $lookup: {
+                from: 'loan_products',
+                localField: 'productId',
+                foreignField: '_id',
+                as: 'product',
+            },
+        }, {
+            $unwind: {
+                path: '$product',
+            },
+        }, {
+            $sort: {
+                'date': 1,
+                'order': 1,
+            },
+        },
+    ]);
+    const convertTypes = (transactionType) => {
+        if (product.type === loan_types_enum_1.ELoanTypes.TERM && transactionType === LoanTransaction_model_1.ELoanTransactionTypes.COLLECTION) {
+            return 'PRINCIPAL';
+        }
+        return transactionType;
+    };
+    const mappedTransactions = transactions.map((transaction) => {
+        return {
+            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 (0, loan_charges_db_1.getLoanChargeForProduct)(productId);
+    const chargesIds = loanCharges.map((charge) => charge._id);
+    const statementTransactions = await LoanStatementTransaction_model_1.LoanStatementTransactionModel.aggregate([
+        {
+            $match: {
+                $and: [
+                    { 'date': { $gte: startDate } },
+                    { 'date': { $lte: (0, dayjs_1.default)(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 statementTransactionsWithBalance = await Promise.all(statementTransactions.map(async (statement) => {
+        const balances = await (0, loan_products_db_1.getLoanProductBalance)(productId, statement.date);
+        return {
+            ...statement,
+            balance: balances.balance,
+            floatedBalance: balances.floatedBalance,
+        };
+    }));
+    const isParticipant = product.isParticipant;
+    const groupedMappedStatementTransactions = await Promise.all(statementTransactionsWithBalance.map(async (statement) => {
+        const transactions = [];
+        if (statement.amountPaid > 0) {
+            const payments = await (0, loan_payments_db_1.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: (0, dayjs_1.default)(payment.date).format(date_helper_1.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 = groupedMappedStatementTransactions
+        .reduce((acc, group) => [...acc, ...group], []);
+    const statementTransactionsWithBrokers = addBrokers
+        ? await (0, brokers_db_1.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 fullTransactions = sortedTransactions
+        .map((row) => ({
+        borrowerCode: borrower.code,
+        date: (0, date_helper_1.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 ? (0, date_helper_1.formatDate)(row.paymentDate) : '',
+    }));
+    const termLoan = await TermLoan_model_1.TermLoanModel.findOne({ productId, actual: true });
+    if (termLoan) {
+        const calculatedTermLoan = await TermLoanCalculated_model_1.TermLoanCalculatedModel.findOne({
+            termLoanId: termLoan._id.toString(),
+            relevantStatement: (0, dayjs_1.default)(endDate).format('YYYY-MM-DD'),
+        });
+        if (calculatedTermLoan) {
+            const expectedPayment = {
+                borrowerCode: borrower.code,
+                date: (0, date_helper_1.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,
+                paymentDate: null,
+            };
+            fullTransactions.unshift(expectedPayment);
+            if (calculatedTermLoan.payments && calculatedTermLoan.payments.length > 0) {
+                for (const payment of calculatedTermLoan.payments) {
+                    const paymentDoc = await LoanTransaction_model_1.LoanTransaction.findById(payment.paymentId).lean();
+                    if (paymentDoc) {
+                        const expectedPayment = {
+                            borrowerCode: borrower.code,
+                            date: (0, date_helper_1.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: (0, date_helper_1.formatDate)(paymentDoc.date),
+                        };
+                        fullTransactions.unshift(expectedPayment);
+                    }
+                }
+            }
+        }
+    }
+    return fullTransactions;
+};
+const mergeLedgerData = (transactions, groupKeys, sumKeys) => {
+    const groupedObjects = lodash_1.default.groupBy(transactions, (obj) => groupKeys.reduce((acc, key) => `${acc}${obj[key]}`, ''));
+    const mergedObjects = lodash_1.default.mapValues(groupedObjects, group => lodash_1.default.reduce(group, (result, obj) => {
+        sumKeys.forEach((key) => {
+            result[key] = new decimal_js_1.default(result[key] || 0).plus(obj[key] || 0).toNumber();
+        });
+        groupKeys.forEach((key) => {
+            result[key] = obj[key];
+        });
+        return result;
+    }, {}));
+    return lodash_1.default.values(mergedObjects);
+};