gemcap-be-common 1.2.59 → 1.2.60

package/db/reports.db.ts

@@ -0,0 +1,354 @@
+import _ from 'lodash';
+import Decimal from 'decimal.js';
+
+import { ILoanProductDoc, LoanProduct } from '../models/LoanProducts.model';
+import { ELedgerReportType, ledgerHeadersMap } from './loan-statement.db';
+import mongoose from 'mongoose';
+import { BorrowerModel } from '../models/Borrower.model';
+import {
+  ELoanTransactionTypes,
+  ILoanTransactionDocWithProduct,
+  LoanTransaction,
+} from '../models/LoanTransaction.model';
+import { ELoanTypes } from '../enums/loan-types.enum';
+import {
+  ILoanStatementTransactionDocWithCharge,
+  LoanStatementTransactionModel,
+} from '../models/LoanStatementTransaction.model';
+import { defaultDateFormat, formatDate } from '../helpers/date.helper';
+import dayjs from 'dayjs';
+import { getLoanChargeForProduct } from './loan-charges.db';
+import { getLoanProductBalance } from './loan-products.db';
+import { getPaymentForTransaction } from './loan-payments.db';
+import { enrichWithBrokers } from './brokers.db';
+import { TermLoanModel } from '../models/TermLoan.model';
+import { TermLoanCalculatedModel } from '../models/TermLoanCalculated.model';
+
+export 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 const getLedger = async (productId: string, startDate: Date, endDate: Date, reportType: ELedgerReportType, showFloatedBalance = true) => {
+  const product: ILoanProductDoc = await 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 = 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 === 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 };
+};
+
+const getLedgerData = async (productId: string, startDate: Date, endDate: Date): Promise<ILedgerReportRow[]> => {
+  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>([
+    {
+      $match: {
+        $and: [
+          { 'date': { $gte: startDate } },
+          { 'date': { $lte: dayjs(endDate).endOf('day').toDate() } },
+          { 'productId': new mongoose.Types.ObjectId(productId) },
+        ],
+      },
+    }, {
+      $lookup: {
+        from: 'loan_products',
+        localField: 'productId',
+        foreignField: '_id',
+        as: 'product',
+      },
+    }, {
+      $unwind: {
+        path: '$product',
+      },
+    }, {
+      $sort: {
+        'date': 1,
+        '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',
+      },
+    }, {
+      $sort: {
+        'date': 1,
+        'createdAt': 1,
+        'order': 1,
+      },
+    },
+  ]);
+
+  const statementTransactionsWithBalance = await Promise.all(statementTransactions.map(async (statement) => {
+    const balances = await 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 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 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 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,
+        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);
+          }
+        }
+      }
+    }
+  }
+  return fullTransactions;
+};
+
+const mergeLedgerData = (transactions: ILedgerReportRow[], groupKeys: string[], sumKeys: string[]) => {
+  const groupedObjects = _.groupBy(
+    transactions,
+    (obj) => groupKeys.reduce((acc, key) => `${acc}${obj[key]}`, ''),
+  );
+
+  const mergedObjects = _.mapValues(groupedObjects, group =>
+    _.reduce(group, (result: any, obj) => {
+      sumKeys.forEach((key) => {
+        result[key] = new Decimal(result[key] || 0).plus(obj[key] || 0).toNumber();
+      });
+      groupKeys.forEach((key) => {
+        result[key] = obj[key];
+      });
+      return result;
+    }, {}),
+  );
+
+  return _.values(mergedObjects);
+};

package/models/Borrower.model.d.ts

@@ -0,0 +1,46 @@
+/// <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, { Document } from 'mongoose';
+interface ISchemaItem {
+    column: string;
+    databaseTitle: string;
+}
+interface IMapSchema {
+    data: ISchemaItem[];
+    name: string;
+    type: string;
+}
+export interface IBorrower {
+    code: string;
+    name: string;
+    title: string;
+    active: boolean;
+    accrualStatus: boolean;
+    schemas: IMapSchema[];
+}
+export interface IBorrowerDocument extends IBorrower, Document {
+}
+export declare const BorrowerModel: mongoose.Model<IBorrowerDocument>;
+export {};

package/models/Borrower.model.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BorrowerModel = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const _models_1 = require("./_models");
+const mongooseLeanId = require('gemcap-be-common/plugins/id.plugin');
+const BorrowerSchema = new mongoose_1.default.Schema({
+    code: {
+        type: String,
+        trim: true,
+        required: true,
+    },
+    name: {
+        type: String,
+        trim: true,
+        required: true,
+    },
+    title: {
+        type: String,
+        trim: true,
+        required: true,
+    },
+    active: {
+        type: Boolean,
+        default: true,
+    },
+    accrualStatus: {
+        type: Boolean,
+        default: false,
+    },
+    schemas: {
+        required: false,
+        type: [
+            {
+                name: {
+                    type: String,
+                    trim: true,
+                    required: true,
+                },
+                type: {
+                    type: String,
+                    trim: true,
+                    required: true,
+                },
+                data: [
+                    {
+                        column: {
+                            type: String,
+                            trim: true,
+                            required: true,
+                        },
+                        databaseTitle: {
+                            type: String,
+                            trim: true,
+                            required: true,
+                        },
+                    },
+                ],
+            },
+        ],
+        default: [],
+    },
+    __v: { type: Number, select: false },
+}, { timestamps: true });
+BorrowerSchema.pre(/^(save)/, async function () {
+});
+BorrowerSchema.pre(/^(updateOne|updateMany|findOneAndUpdate)/, async function () {
+});
+BorrowerSchema.pre(/^(findOneAndDelete|deleteOne|deleteMany)/, async function () {
+});
+BorrowerSchema.plugin(mongooseLeanId);
+exports.BorrowerModel = mongoose_1.default.model(_models_1.MODEL_NAMES.borrowers, BorrowerSchema);

package/models/Borrower.model.ts

@@ -0,0 +1,103 @@
+import mongoose, { Document } from 'mongoose';
+import { MODEL_NAMES } from './_models';
+
+const mongooseLeanId = require('gemcap-be-common/plugins/id.plugin');
+
+interface ISchemaItem {
+  column: string;
+  databaseTitle: string;
+}
+
+interface IMapSchema {
+  data: ISchemaItem[];
+  name: string;
+  type: string;
+}
+
+export interface IBorrower {
+  code: string;
+  name: string;
+  title: string;
+  active: boolean;
+  accrualStatus: boolean;
+  schemas: IMapSchema[];
+}
+
+export interface IBorrowerDocument extends IBorrower, Document {
+}
+
+const BorrowerSchema = new mongoose.Schema(
+  {
+    code: {
+      type: String,
+      trim: true,
+      required: true,
+    },
+    name: {
+      type: String,
+      trim: true,
+      required: true,
+    },
+    title: {
+      type: String,
+      trim: true,
+      required: true,
+    },
+    active: {
+      type: Boolean,
+      default: true,
+    },
+    accrualStatus: {
+      type: Boolean,
+      default: false,
+    },
+    schemas: {
+      required: false,
+      type: [
+        {
+          name: {
+            type: String,
+            trim: true,
+            required: true,
+          },
+          type: {
+            type: String,
+            trim: true,
+            required: true,
+          },
+          data: [
+            {
+              column: {
+                type: String,
+                trim: true,
+                required: true,
+              },
+              databaseTitle: {
+                type: String,
+                trim: true,
+                required: true,
+              },
+            },
+          ],
+        },
+      ],
+      default: [],
+    },
+    __v: { type: Number, select: false },
+  },
+  { timestamps: true },
+);
+
+BorrowerSchema.pre(/^(save)/, async function() {
+
+});
+
+BorrowerSchema.pre(/^(updateOne|updateMany|findOneAndUpdate)/, async function() {
+});
+
+BorrowerSchema.pre(/^(findOneAndDelete|deleteOne|deleteMany)/, async function() {
+});
+
+BorrowerSchema.plugin(mongooseLeanId);
+
+export const BorrowerModel: mongoose.Model<IBorrowerDocument> = mongoose.model<IBorrowerDocument>(MODEL_NAMES.borrowers, BorrowerSchema);

package/models/LoanPayment.model.d.ts

@@ -0,0 +1,66 @@
+/// <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, { Document } from 'mongoose';
+export declare const LOAN_PAYMENT_FIELDS: string[];
+export interface ICombinedPayment {
+    borrowerId: string;
+    date: Date;
+    payment: number;
+    addToRevolver: boolean;
+    products: {
+        productId: string;
+        payableSum: number;
+        settlementCode: string;
+        paymentOrder: string[];
+    }[];
+    linkedProducts: {
+        productId: string;
+        payableSum: number;
+        settlementCode: string;
+    }[];
+}
+export interface ILoanPayment {
+    date: Date;
+    productId: mongoose.Types.ObjectId;
+    amount: number;
+    paid: {
+        _id?: mongoose.Types.ObjectId;
+        statementId: mongoose.Types.ObjectId;
+        amount: number;
+    }[];
+    loanTransactions: {
+        _id?: mongoose.Types.ObjectId;
+        transactionId: mongoose.Types.ObjectId;
+        amount: number;
+    }[];
+    settlementCode?: string;
+    paymentOrder?: string[];
+}
+export interface ILoanPaymentWithId extends ILoanPayment {
+    _id: mongoose.Types.ObjectId;
+}
+export interface ILoanPaymentDoc extends ILoanPayment, Document {
+}
+export declare const LoanPaymentModel: mongoose.Model<ILoanPaymentDoc>;