gemcap-be-common 1.2.140 → 1.3.0

package/services/loan-payments.service.ts

@@ -0,0 +1,541 @@
+import mongoose from 'mongoose';
+import dayjs from 'dayjs';
+import Decimal from 'decimal.js';
+import Joi from 'joi';
+import { RedisClientType } from 'redis';
+
+import { createFilteredObject } from '../helpers/common.helper';
+import { IPaginatorOptions } from '../interfaces/collaterals.interface';
+import { ELoanChargeType } from '../enums/loan-charge-type.enum';
+import { ELoanTypes } from '../enums/loan-types.enum';
+import {
+  ILoanStatementTransactionDoc,
+  ILoanStatementTransactionWithId,
+  LoanStatementTransactionModel,
+} from '../models/LoanStatementTransaction.model';
+import { ITEMS_PAGINATION } from '../db/collaterals.db';
+import {
+  ELoanTransactionTypes,
+  ILoanTransaction,
+  LoanTransaction,
+} from '../models/LoanTransaction.model';
+import { LoanProduct } from '../models/LoanProducts.model';
+import { BorrowerModel } from '../models/Borrower.model';
+import { UserModel } from '../models/User.model';
+import {
+  ICombinedPayment,
+  ILoanPaymentDoc,
+  ILoanPaymentWithId,
+  LOAN_PAYMENT_FIELDS,
+  LoanPaymentModel,
+} from '../models/LoanPayment.model';
+
+import { BorrowerService } from './borrowers.service';
+import { LoanStatementBalanceService } from './loan-statement-balance.service';
+import { LoanProductsService } from './loan-products.service';
+import { LoanChargesService } from './loan-charges.service';
+import { FinancialComplianceService } from './financial-compliance.service';
+import { LoanStatementService } from './loan-statement.service';
+import { LoanStatementStatusService } from './loan-statement-status.service';
+import { LoanTransactionsService } from './loan-transactions.service';
+import { TermLoanService } from './term-loan.service';
+import { LockService } from './lock.service';
+
+export const paymentOrder = [
+  ELoanChargeType.RECOVERABLE,
+  ELoanChargeType.INTEREST_FEE,
+  ELoanChargeType.ADMIN_FEE,
+  ELoanChargeType.UNUSED_LINE_FEE,
+  ELoanChargeType.WIRE_FEE,
+  ELoanChargeType.OTHER,
+  ELoanChargeType.ANNUAL_LINE_FEE,
+];
+
+const CALCULATION_VAR = 'BULK_PAYMENT';
+
+export class LoanPaymentsService {
+  constructor(
+    private readonly redisClient: RedisClientType,
+    private readonly borrowerService: BorrowerService,
+    private readonly financialComplianceService: FinancialComplianceService,
+    private readonly loanChargesService: LoanChargesService,
+    private readonly loanProductsService: LoanProductsService,
+    private readonly loanStatementBalanceService: LoanStatementBalanceService,
+    private readonly getLoanStatementService: () => LoanStatementService,
+    private readonly loanStatementStatusService: LoanStatementStatusService,
+    private readonly loanTransactionsService: LoanTransactionsService,
+    private readonly lockService: LockService,
+    private readonly termLoanService: TermLoanService,
+  ) {
+  }
+
+  async getLoanPayment(paymentId: string) {
+    return LoanPaymentModel.findById(paymentId).lean();
+  }
+
+  async getLoanPayments(filter: { productIds: string[], start: Date, end: Date }, paginatorOptions: IPaginatorOptions) {
+    return LoanPaymentModel.aggregate<ILoanPaymentDoc>([
+      {
+        $match: {
+          $and: [
+            { 'productId': { $in: filter.productIds.map((id) => new mongoose.Types.ObjectId(id)) } },
+            { 'date': { $gte: filter.start } },
+            { 'date': { $lte: dayjs(filter.end).utcOffset(0).endOf('day').toDate() } },
+          ],
+        },
+      }, {
+        $sort: {
+          'date': 1,
+        },
+      },
+      ...ITEMS_PAGINATION(paginatorOptions),
+    ]);
+  }
+
+  async getTotalLoanPaymentsForProduct(filter: { productIds: string[], start: Date, end: Date }) {
+    return LoanPaymentModel.countDocuments(
+      {
+        $and: [
+          { 'productId': { $in: filter.productIds } },
+          { 'date': { $gte: filter.start } },
+          { 'date': { $lte: filter.end } },
+        ],
+      },
+    );
+  }
+
+  async saveLoanPayment(payment: Partial<ILoanPaymentWithId>, userId: string) {
+    if (!payment._id) {
+      delete payment._id;
+      const newPayment = new LoanPaymentModel(payment);
+      await newPayment.save();
+      await this.calculatePaymentProportions(newPayment as Partial<ILoanPaymentWithId>, newPayment.productId.toString(), userId);
+    } else {
+      await LoanPaymentModel.findByIdAndUpdate(payment._id, payment);
+      await this.calculatePaymentProportions(payment, payment.productId.toString(), userId);
+    }
+  }
+
+  async createLoanPayment(payment: Partial<ILoanPaymentWithId>, userId: string) {
+    const purePayment = createFilteredObject<ILoanPaymentWithId>(payment, LOAN_PAYMENT_FIELDS);
+    await this.saveLoanPayment(purePayment, userId);
+  }
+
+  async updateLoanPayment(payment: Partial<ILoanPaymentWithId>, userId: string) {
+    const foundPayment = await LoanPaymentModel.findById(payment._id).lean();
+    if (!foundPayment) {
+      return;
+    }
+    await this.loanStatementBalanceService.cleanDecreasePayment(foundPayment as unknown as ILoanPaymentWithId, userId);
+    const purePayment = createFilteredObject<ILoanPaymentWithId>(payment, LOAN_PAYMENT_FIELDS);
+    await this.saveLoanPayment(purePayment, userId);
+  }
+
+  async recalculateAfterPayment(productId: string, userId: string) {
+    console.log('started recalculating product', productId);
+    await this.recalculateProduct(productId, userId);
+    await this.loanTransactionsService.recalculateProduct(productId);
+  }
+
+  async deleteLoanPayment(paymentId: string, userId: string) {
+    const foundPayment = await LoanPaymentModel.findById(paymentId).lean();
+    if (!foundPayment) {
+      return;
+    }
+    await this.loanStatementBalanceService.cleanDecreasePayment(foundPayment as unknown as ILoanPaymentWithId, userId);
+    await LoanPaymentModel.findByIdAndDelete(paymentId);
+    const statementDate = this.loanStatementStatusService.getStatementDateForDate(new Date(foundPayment.date));
+    await this.loanStatementStatusService.updateStatementStatus(foundPayment.productId.toString(), statementDate, false);
+    await this.termLoanService.setTermLoanExpected(foundPayment.productId.toString());
+  }
+
+  private async calculatePaymentProportions(payment: Partial<ILoanPaymentWithId>, productId: string, userId: string) {
+    const product = await LoanProduct.findById(productId).lean();
+    const settlementCode = payment.settlementCode;
+    const borrower = await BorrowerModel.findById(product.borrowerId).lean();
+
+    const loanCharges = await this.loanChargesService.getLoanChargeForProduct(productId);
+    const chargesIds = loanCharges.map((charge) => charge._id);
+
+    const productPaymentOrder = !payment.paymentOrder || payment.paymentOrder.length === 0
+      ? paymentOrder
+      : payment.paymentOrder.map((p) => loanCharges.find((charge) => charge._id.toString() === p).chargeType);
+
+    const paymentOrderQuery = productPaymentOrder.map((charge, index) => {
+      return {
+        case: {
+          $eq: ['$charge.chargeType', charge],
+        },
+        then: index,
+      };
+    });
+
+    const unpaidStatements = await LoanStatementTransactionModel.aggregate([
+      {
+        $match: {
+          'chargeId': { '$in': chargesIds },
+          'date': { $lte: dayjs(new Date(payment.date)).utcOffset(0).startOf('month').subtract(1, 'second').toDate() },
+          $expr: { $lt: ['$amountPaid', '$amount'] },
+        },
+      }, {
+        $lookup:
+          {
+            from: 'loan_charges',
+            localField: 'chargeId',
+            foreignField: '_id',
+            as: 'charge',
+          },
+      }, {
+        $unwind:
+          {
+            path: '$charge',
+          },
+      }, {
+        $addFields:
+          {
+            customSortValue: {
+              $switch: {
+                branches: paymentOrderQuery,
+                default: paymentOrder.length,
+              },
+            },
+          },
+      }, {
+        $sort:
+          {
+            customSortValue: 1,
+            date: 1,
+            order: 1,
+          },
+      },
+    ]);
+    let availableAmount = payment.amount;
+    const paidArray = [];
+    let firstPaidStatement: any = null;
+    for (const statement of unpaidStatements) {
+      const foundStatement = await LoanStatementTransactionModel.findById(statement._id);
+      if (!foundStatement) {
+        return;
+      }
+      const prefPaidAmount = new Decimal(statement.amount).sub(foundStatement.amountPaid).toNumber();
+      const amountPaid = prefPaidAmount > availableAmount ? availableAmount : prefPaidAmount;
+      availableAmount = new Decimal(availableAmount).sub(amountPaid).toNumber();
+      paidArray.push({ statementId: statement._id, amount: amountPaid });
+      await LoanStatementTransactionModel.findByIdAndUpdate(statement._id, {
+        amountPaid: new Decimal(foundStatement.amountPaid).add(amountPaid).toNumber(),
+        settlementCode,
+      });
+      if (!firstPaidStatement ||
+        (statement.date.getTime() < firstPaidStatement.date.getTime()) ||
+        (firstPaidStatement.date.getTime() === statement.date.getTime() && firstPaidStatement.order > statement.order)
+      ) {
+        firstPaidStatement = statement;
+      }
+      if (availableAmount === 0) {
+        break;
+      }
+    }
+    const loanTransactions = [];
+
+    if (availableAmount > 0) {
+      const transaction: Partial<ILoanTransaction> = {
+        amount: -availableAmount,
+        date: payment.date,
+        description: `${borrower.code} - STATEMENT PAID`,
+        effectiveDate: null,
+        loanPaymentId: payment._id,
+        order: 0,
+        productId: new mongoose.Types.ObjectId(productId),
+        reference: `${borrower.code} - STATEMENT PAID`,
+        transactionType: ELoanTransactionTypes.COLLECTION,
+        userId: new mongoose.Types.ObjectId(userId),
+      };
+      transaction.effectiveDate = await this.loanTransactionsService.calculateEffectiveDate(transaction);
+      const newTransaction = await this.loanTransactionsService.createLoanTransaction(transaction);
+      loanTransactions.push({ transactionId: newTransaction._id, amount: newTransaction.amount });
+    }
+    await LoanPaymentModel.findByIdAndUpdate(payment._id, { paid: paidArray, loanTransactions }, { new: true });
+    if (firstPaidStatement) {
+      await this.loanStatementBalanceService.calculateProductBalance(productId, firstPaidStatement.date);
+    }
+    await this.updateComplianceBorrowerAmountReceived(borrower._id.toString());
+    const statementDate = this.loanStatementStatusService.getStatementDateForDate(new Date(payment.date));
+    await this.loanStatementStatusService.updateStatementStatus(productId, statementDate, false);
+    await this.termLoanService.setTermLoanExpected(productId, true);
+  }
+
+  async updateComplianceBorrowerAmountReceived(borrowerId: string) {
+    const allProducts = await this.loanChargesService.getLoanProducts(borrowerId);
+    const productIds = allProducts.map((p) => p._id.toString());
+    const startDate = dayjs().startOf('month').toDate();
+    const endDate = dayjs().endOf('month').toDate();
+    const payments = await this.getPaymentsForPeriod(productIds, startDate, endDate);
+    const totalPayments = payments.reduce((acc, p) => new Decimal(acc).add(p.amount ?? 0).toNumber(), 0);
+    const complianceBorrower = await this.financialComplianceService.getFinancialComplianceBorrower(borrowerId);
+    if (!complianceBorrower) {
+      return;
+    }
+    await this.financialComplianceService.updateBorrower(complianceBorrower._id.toString(), {
+      ...complianceBorrower,
+      amountReceived: totalPayments,
+    });
+  }
+
+  async recalculateProduct(productId: string, userId: string) {
+    const loanCharges = await this.loanChargesService.getLoanChargeForProduct(productId);
+    const chargesIds = loanCharges.map((charge) => charge._id);
+    await LoanStatementTransactionModel.updateMany({ 'chargeId': { $in: chargesIds } }, { amountPaid: 0 });
+
+    const firstStatements = await LoanStatementTransactionModel.aggregate<ILoanStatementTransactionDoc>([
+      {
+        $match: {
+          'chargeId': { $in: chargesIds },
+        },
+      }, {
+        $sort: {
+          'date': 1,
+          'order': 1,
+        },
+      }, {
+        $limit: 1,
+      },
+    ]);
+
+    if (firstStatements.length > 0) {
+      const loanStatementService = this.getLoanStatementService();
+      await loanStatementService.updateStatementTransaction(firstStatements[0] as Partial<ILoanStatementTransactionWithId>);
+    }
+
+    const payments = await LoanPaymentModel.aggregate<ILoanPaymentDoc>([
+      {
+        $match: { 'productId': new mongoose.Types.ObjectId(productId) },
+      },
+      {
+        $sort: {
+          'date': 1,
+          'createdAt': 1,
+        },
+      },
+    ]);
+    for (const [index, payment] of payments.entries()) {
+      try {
+        console.log(`updating payment ${index + 1}/${payments.length}`, dayjs(payment.date).format('DD-MM-YYYY'), payment.amount);
+        for (const loanTransaction of payment.loanTransactions) {
+          await LoanTransaction.findByIdAndDelete(loanTransaction.transactionId);
+        }
+        await LoanPaymentModel.findByIdAndUpdate(payment._id, { paid: [], loanTransactions: [] });
+        await this.updateLoanPayment(payment as Partial<ILoanPaymentWithId>, userId);
+      } catch (e) {
+        console.error({ productId, payments });
+        console.error(e);
+      }
+    }
+  }
+
+  async getPaymentsForPeriod(productIds: string[], startDate: Date, endDate: Date) {
+    return LoanPaymentModel.aggregate<ILoanPaymentDoc>([
+      {
+        $match: {
+          $and: [
+            { 'productId': { $in: productIds.map((id) => new mongoose.Types.ObjectId(id)) } },
+            { 'date': { $gte: startDate } },
+            { 'date': { $lte: endDate } },
+          ],
+        },
+      }, {
+        $sort: {
+          'date': 1,
+          'createdAt': 1,
+        },
+      },
+    ]);
+  }
+
+  async proceedCombinedPayment(combinedPayment: ICombinedPayment, userId: string) {
+    try {
+      if (combinedPayment.addToRevolver) {
+        const isLockedRes = await Promise.all([...combinedPayment.products, ...combinedPayment.linkedProducts].map(async (productGroup) => {
+          const product = await LoanProduct.findById(productGroup.productId).lean();
+          if (product) {
+            return await this.lockService.isDateLocked(new Date(combinedPayment.date), product.borrowerId.toString());
+          }
+          return false;
+        }));
+        if (isLockedRes.some((isLocked) => !!isLocked)) {
+          return { success: false, message: 'Period is signed and locked' };
+        }
+      }
+
+      const loanStatementService = this.getLoanStatementService();
+      const data = await loanStatementService.getBorrowerComplianceData(combinedPayment.borrowerId, new Date());
+      let totalSumToCover = combinedPayment.payment;
+      const products = await this.loanChargesService.getLoanProducts(combinedPayment.borrowerId);
+      const revolverProduct = products.find((product) => product.type === ELoanTypes.REVOLVER);
+
+      for (const p of combinedPayment.products) {
+        await this.loanProductsService.savePaymentOrder(p.productId, p.paymentOrder);
+        const desiredProductSum = data.productTotals[p.productId];
+        const product = await LoanProduct.findById(p.productId).lean();
+        const sumForProduct = desiredProductSum > totalSumToCover ? totalSumToCover : desiredProductSum;
+        if (sumForProduct > 0) {
+          const newPayment: Partial<ILoanPaymentWithId> = {
+            _id: null,
+            productId: new mongoose.Types.ObjectId(p.productId),
+            amount: sumForProduct,
+            date: new Date(combinedPayment.date),
+            settlementCode: p.settlementCode,
+            paymentOrder: p.paymentOrder,
+          };
+          await this.createLoanPayment(newPayment, userId);
+
+          if (combinedPayment.addToRevolver && revolverProduct) {
+            const newTransactions: Partial<ILoanTransaction> = {
+              amount: sumForProduct,
+              bankId: null,
+              date: combinedPayment.date,
+              description: `${product.type} STATEMENT ADDED TO LOAN`,
+              effectiveDate: null,
+              productId: revolverProduct._id,
+              reference: `${product.type} STATEMENT ADDED TO LOAN`,
+              transactionType: ELoanTransactionTypes.DISBURSEMENT,
+              userId: new mongoose.Types.ObjectId(userId),
+            };
+            newTransactions.effectiveDate = await this.loanTransactionsService.calculateEffectiveDate(newTransactions);
+            await this.loanTransactionsService.createLoanTransaction(newTransactions);
+          }
+        }
+        totalSumToCover = new Decimal(totalSumToCover).sub(sumForProduct).toNumber();
+      }
+
+      if (totalSumToCover > 0 && revolverProduct && !combinedPayment.addToRevolver) {
+        const newTransactions: Partial<ILoanTransaction> = {
+          amount: -totalSumToCover,
+          bankId: null,
+          date: combinedPayment.date,
+          description: `OVERPAYMENT OF STATEMENT`,
+          effectiveDate: null,
+          productId: revolverProduct._id,
+          reference: `OVERPAYMENT OF STATEMENT`,
+          transactionType: ELoanTransactionTypes.COLLECTION,
+          userId: new mongoose.Types.ObjectId(userId),
+        };
+        newTransactions.effectiveDate = await this.loanTransactionsService.calculateEffectiveDate(newTransactions);
+        await this.loanTransactionsService.createLoanTransaction(newTransactions);
+      }
+
+      await Promise.all(combinedPayment.linkedProducts.map(async (p) => {
+        const newTransactions: Partial<ILoanTransaction> = {
+          amount: -p.payableSum,
+          bankId: null,
+          date: combinedPayment.date,
+          description: `EXTRA PAYMENT`,
+          effectiveDate: null,
+          productId: new mongoose.Types.ObjectId(p.productId),
+          reference: `EXTRA PAYMENT REF`,
+          transactionType: ELoanTransactionTypes.COLLECTION,
+          userId: new mongoose.Types.ObjectId(userId),
+        };
+        newTransactions.effectiveDate = await this.loanTransactionsService.calculateEffectiveDate(newTransactions);
+        await this.loanTransactionsService.createLoanTransaction(newTransactions);
+      }));
+
+      return { success: true, message: null };
+    } catch (e) {
+      console.error(e);
+    }
+  }
+
+  async getExpectedPayments(userId: string) {
+    const user = await UserModel.findById(userId).lean();
+    if (!user) {
+      return [];
+    }
+    const borrowers = await this.borrowerService.getAllowedBorrowers(user);
+    const isCalculated = await this.redisClient.get(CALCULATION_VAR);
+    const borrowersData = await Promise.all(borrowers
+      .filter((borrower) => borrower.active)
+      .map(async (borrower) => {
+        const loanStatementService = this.getLoanStatementService();
+        const dueAmounts = await loanStatementService.getBorrowerProductTotals(borrower._id.toString());
+        return {
+          borrowerId: borrower.id,
+          borrowerTitle: borrower.name,
+          totalDue: dueAmounts.total,
+          productTotals: dueAmounts.productTotals,
+        };
+      }),
+    );
+    return { borrowers: borrowersData, isCalculated: !!isCalculated };
+  }
+
+  async payExpectedPayments(userId: string, borrowerIds: string[]) {
+
+    const arrayOfStringsSchema = Joi.array().items(Joi.string()).required();
+    const { error } = arrayOfStringsSchema.validate(borrowerIds, { abortEarly: false });
+    if (error) {
+      return { message: 'Incorrect list of borrowers IDs' };
+    }
+
+    const addToRevolver = true;
+
+    await this.redisClient.set(CALCULATION_VAR, 1);
+    const user = await UserModel.findById(userId).lean();
+    if (!user) {
+      return { message: 'Cannot find user with this id' };
+    }
+    const borrowers = await this.borrowerService.getAllowedBorrowers(user);
+    const paymentPromises = borrowers.map(async (borrower) => {
+      if (borrowerIds.includes(borrower._id.toString())) {
+        try {
+          const loanStatementService = this.getLoanStatementService();
+          const dueAmounts = await loanStatementService.getBorrowerProductTotals(borrower._id.toString());
+          if (dueAmounts.total === 0) {
+            console.log('no payment for this borrower');
+            return;
+          }
+          const products = await Promise.all(
+            Object.entries(dueAmounts.productTotals).map(async ([productId, amount]) => {
+              const product = await LoanProduct.findById(productId);
+              if (product) {
+                return {
+                  productId: productId,
+                  payableSum: amount,
+                  settlementCode: addToRevolver ? product.code : product.settlementCode,
+                  paymentOrder: null,
+                };
+              }
+            }),
+          );
+
+          const combinedPayment: ICombinedPayment = {
+            addToRevolver,
+            borrowerId: borrower._id.toString(),
+            date: new Date(),
+            linkedProducts: [],
+            payment: dueAmounts.total,
+            products: products.filter((product) => !!product),
+          };
+
+          await this.proceedCombinedPayment(combinedPayment, userId);
+          console.log(`Success on payment ${borrower.title}`);
+        } catch (err) {
+          console.error(`Error on payment ${borrower.title}:`, err);
+        }
+      }
+    });
+
+    const processPayments = async (paymentPromises: Promise<void>[]) => {
+      try {
+        await Promise.allSettled(paymentPromises);
+        console.log('All payments processed.');
+        await this.redisClient.del(CALCULATION_VAR);
+      } catch (err) {
+        console.error('Error during payment processing:', err);
+      }
+    };
+
+    processPayments(paymentPromises).catch(console.error);
+
+    return { message: 'Payments are being processed in the background.' };
+  }
+}

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

@@ -0,0 +1,12 @@
+import { ILoanProductView } from '../models/LoanProducts.model';
+import { LoanChargesService } from './loan-charges.service';
+export declare class LoanProductsService {
+    private readonly loanChargesService;
+    constructor(loanChargesService: LoanChargesService);
+    getLinkedLoanProducts(codes: string[]): Promise<{
+        [code: string]: string;
+    }>;
+    getProductsWithBalances(products: ILoanProductView[], showFloatedBalance: boolean): Promise<ILoanProductView[]>;
+    getProductPaymentOrder(productId: string): Promise<any[]>;
+    savePaymentOrder(productId: string, paymentOrder: string[]): Promise<void>;
+}

package/services/loan-products.service.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoanProductsService = void 0;
+const LoanProducts_model_1 = require("../models/LoanProducts.model");
+const LoanCharges_model_1 = require("../models/LoanCharges.model");
+const loan_payments_service_1 = require("./loan-payments.service");
+class LoanProductsService {
+    loanChargesService;
+    constructor(loanChargesService) {
+        this.loanChargesService = loanChargesService;
+    }
+    async getLinkedLoanProducts(codes) {
+        const loanProducts = await LoanProducts_model_1.LoanProduct
+            .find({ isParticipant: true, masterCode: { $in: codes } })
+            .sort({ code: 1 })
+            .lean();
+        return loanProducts.reduce((acc, loanProduct) => ({ ...acc, [loanProduct.code]: loanProduct._id.toString() }), {});
+    }
+    async getProductsWithBalances(products, showFloatedBalance) {
+        await Promise.all(products.map(async (product, index) => {
+            const balances = await this.loanChargesService.getLoanProductBalance(product._id.toString());
+            products[index].balance = balances.balance;
+            products[index].floatedBalance = showFloatedBalance ? balances.floatedBalance : 0;
+        }));
+        return products;
+    }
+    async getProductPaymentOrder(productId) {
+        const product = await LoanProducts_model_1.LoanProduct.findById(productId).lean();
+        const charges = await LoanCharges_model_1.LoanCharge.find({ productId }).lean();
+        if (product.isDefaultPaymentOrder) {
+            const chargeOrders = charges.map((charge) => {
+                const foundIndex = loan_payments_service_1.paymentOrder.findIndex((order) => order === charge.chargeType);
+                return { chargeId: charge._id.toString(), order: foundIndex };
+            });
+            const sortedChargeOrders = chargeOrders.sort((a, b) => a.order - b.order);
+            return sortedChargeOrders.map((item) => item.chargeId);
+        }
+        const sortedCharges = charges.sort((a, b) => {
+            return (a.paymentOrder ?? 0) - (b.paymentOrder ?? 0);
+        });
+        return sortedCharges.map((charge) => charge._id.toString());
+    }
+    async savePaymentOrder(productId, paymentOrder) {
+        if (paymentOrder === null || paymentOrder.length === 0) {
+            await LoanProducts_model_1.LoanProduct.findByIdAndUpdate(productId, { isDefaultPaymentOrder: true });
+        }
+        else {
+            await LoanProducts_model_1.LoanProduct.findByIdAndUpdate(productId, { isDefaultPaymentOrder: false });
+            await Promise.all(paymentOrder.map(async (chargeId, index) => {
+                await LoanCharges_model_1.LoanCharge.findByIdAndUpdate(chargeId, { paymentOrder: index });
+            }));
+        }
+    }
+}
+exports.LoanProductsService = LoanProductsService;

package/services/loan-products.service.ts

@@ -0,0 +1,58 @@
+import { ILoanProductView, ILoanProductViewWithBalances, LoanProduct } from '../models/LoanProducts.model';
+import { LoanCharge } from '../models/LoanCharges.model';
+
+import { paymentOrder } from './loan-payments.service';
+import { LoanChargesService } from './loan-charges.service';
+
+export class LoanProductsService {
+
+  constructor(
+    private readonly loanChargesService: LoanChargesService,
+  ) {
+  }
+
+  async getLinkedLoanProducts(codes: string[]): Promise<{ [code: string]: string }> {
+    const loanProducts = await LoanProduct
+      .find({ isParticipant: true, masterCode: { $in: codes } })
+      .sort({ code: 1 })
+      .lean();
+    return loanProducts.reduce((acc, loanProduct) => ({ ...acc, [loanProduct.code]: loanProduct._id.toString() }), {});
+  }
+
+  async getProductsWithBalances(products: ILoanProductView[], showFloatedBalance: boolean) {
+    await Promise.all(products.map(async (product, index) => {
+      const balances = await this.loanChargesService.getLoanProductBalance(product._id.toString());
+      (<ILoanProductViewWithBalances>products[index]).balance = balances.balance;
+      (<ILoanProductViewWithBalances>products[index]).floatedBalance = showFloatedBalance ? balances.floatedBalance : 0;
+    }));
+    return products;
+  }
+
+  async getProductPaymentOrder(productId: string) {
+    const product = await LoanProduct.findById(productId).lean();
+    const charges = await LoanCharge.find({ productId }).lean();
+    if (product.isDefaultPaymentOrder) {
+      const chargeOrders = charges.map((charge) => {
+        const foundIndex = paymentOrder.findIndex((order) => order === charge.chargeType);
+        return { chargeId: charge._id.toString(), order: foundIndex };
+      });
+      const sortedChargeOrders = chargeOrders.sort((a, b) => a.order - b.order);
+      return sortedChargeOrders.map((item) => item.chargeId);
+    }
+    const sortedCharges = charges.sort((a, b) => {
+      return (a.paymentOrder ?? 0) - (b.paymentOrder ?? 0);
+    });
+    return sortedCharges.map((charge) => charge._id.toString());
+  }
+
+  async savePaymentOrder(productId: string, paymentOrder: string[]) {
+    if (paymentOrder === null || paymentOrder.length === 0) {
+      await LoanProduct.findByIdAndUpdate(productId, { isDefaultPaymentOrder: true });
+    } else {
+      await LoanProduct.findByIdAndUpdate(productId, { isDefaultPaymentOrder: false });
+      await Promise.all(paymentOrder.map(async (chargeId, index) => {
+        await LoanCharge.findByIdAndUpdate(chargeId, { paymentOrder: index });
+      }));
+    }
+  }
+}

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

@@ -0,0 +1,16 @@
+import { ILoanPaymentWithId } from '../models/LoanPayment.model';
+import { ILoanStatementTransactionDoc } from '../models/LoanStatementTransaction.model';
+import { LoanChargesService } from './loan-charges.service';
+import { LoanStatementService } from './loan-statement.service';
+import { LoanTransactionsService } from './loan-transactions.service';
+export declare class LoanStatementBalanceService {
+    private readonly loanChargesService;
+    private readonly getLoanStatementService;
+    private readonly loanTransactionsService;
+    constructor(loanChargesService: LoanChargesService, getLoanStatementService: () => LoanStatementService, loanTransactionsService: LoanTransactionsService);
+    cleanDecreasePayment(payment: ILoanPaymentWithId, userId: string): Promise<void>;
+    calculateProductBalance(productId: string, startDate: Date): Promise<void>;
+    updateBalance(loanStatementTransaction: ILoanStatementTransactionDoc): Promise<void>;
+    getLastStatementTransactionForDate(productId: string, startDate: Date): Promise<ILoanStatementTransactionDoc>;
+    getNextAdminTransactionForDate(productId: string, date: Date): Promise<number>;
+}