gemcap-be-common 1.2.140 → 1.3.0

package/services/loan-transactions.service.ts

@@ -0,0 +1,1042 @@
+import _ from 'lodash';
+import mongoose from 'mongoose';
+import dayjs from 'dayjs';
+import Decimal from 'decimal.js';
+
+import { IEmail } from '../interfaces/email.interface';
+import { calculateTimeZone } from '../helpers/date.helper';
+import { roundToXDigits } from '../helpers/numbers.helper';
+import { createFilteredObject } from '../helpers/common.helper';
+import { IPaginatorOptions } from '../interfaces/collaterals.interface';
+import { BBCDateModel } from '../models/BBCDate.model';
+import { ELoanTypes } from '../enums/loan-types.enum';
+import {
+  ELoanTransactionTypes,
+  ILoanTransaction,
+  ILoanTransactionDoc,
+  ILoanTransactionUpload,
+  ILoanTransactionView,
+  ILoanTransactionViewWithBank,
+  ILoanTransactionWithId,
+  LOAN_TRANSACTION_FIELDS,
+  LoanTransaction,
+} from '../models/LoanTransaction.model';
+import { ITEMS_PAGINATION } from '../db/collaterals.db';
+import {
+  IPostponedTransaction,
+  PostponedTransaction,
+} from '../models/PostponedTransactions.model';
+import { LoanProduct } from '../models/LoanProducts.model';
+import { ILoanProductDoc } from '../models/LoanProducts.model';
+import { BorrowerModel } from '../models/Borrower.model';
+import { BorrowerCompliance, IComplianceBorrowerDocument } from '../models/BorrowerCompliance.model';
+import {
+  ILoanStatementTransaction,
+  LOAN_STATEMENT_TRANSACTION_FIELDS,
+  LoanStatementTransactionModel,
+} from '../models/LoanStatementTransaction.model';
+import { ILoanPaymentWithId, LoanPaymentModel } from '../models/LoanPayment.model';
+import { fieldsToUnset, getPostponedTransactions } from '../db/loan-products.db';
+import { getLastTransactionForDate } from '../db/loan-transactions.db';
+
+import { IUploadOption, UploadsService } from './uploads.service';
+import { ILoanTransactionFileDoc, LoanTransactionFileModel } from '../models/LoanTransactionFile.model';
+import { AttachedFilesService } from './attached-files.service';
+import { BanksService } from './banks.service';
+import { BorrowerService } from './borrowers.service';
+import { CalendarService } from './calendar.service';
+import { LoanChargesService } from './loan-charges.service';
+import { LoanPaymentsService } from './loan-payments.service';
+import { LoanStatementService } from './loan-statement.service';
+import { LoanStatementStatusService } from './loan-statement-status.service';
+import { NodemailerService } from './nodemailer.service';
+import { TermLoanService } from './term-loan.service';
+import { LockService } from './lock.service';
+
+interface ILoanTransactionsServiceConfig {
+  portfolioEmail: string;
+}
+
+export interface ITransactionsFilter {
+  periodStart: Date;
+  periodEnd: Date;
+  borrowerId: string;
+  productId: string;
+  amount?: number;
+  reference?: string;
+}
+
+export class LoanTransactionsService {
+
+  private readonly config: ILoanTransactionsServiceConfig;
+
+  constructor(
+    config: ILoanTransactionsServiceConfig,
+    private readonly attachedFilesService: AttachedFilesService,
+    private readonly banksService: BanksService,
+    private readonly borrowerService: BorrowerService,
+    private readonly calendarService: CalendarService,
+    private readonly loanChargesService: LoanChargesService,
+    private readonly getLoanPaymentsService: () => LoanPaymentsService,
+    private readonly getLoanStatementService: () => LoanStatementService,
+    private readonly loanStatementStatusService: LoanStatementStatusService,
+    private readonly getNodemailerService: () => NodemailerService,
+    private readonly lockService: LockService,
+    private readonly termLoanService: TermLoanService,
+    private readonly uploadsService: UploadsService,
+  ) {
+  }
+
+  async getTransactionsById(transactionId: string) {
+    return LoanTransaction.findById(transactionId).lean();
+  }
+
+  async getLoanTransactions<T extends boolean>(transactionsFilter: ITransactionsFilter, paginatorOptions: IPaginatorOptions, withBanks: T, isReverse = false, isMinified = false) {
+    const borrowerProducts = await this.loanChargesService.getLoanProducts(transactionsFilter.borrowerId);
+    const productIds = borrowerProducts
+      .filter((product) => transactionsFilter.productId ? product._id.toString() === transactionsFilter.productId : true)
+      .map((product) => product._id);
+
+    const optionalFilters = [];
+    if (transactionsFilter.amount) {
+      optionalFilters.push({ 'amount': transactionsFilter.amount });
+    }
+    if (transactionsFilter.reference) {
+      optionalFilters.push({ 'reference': { $regex: transactionsFilter.reference, $options: 'i' } });
+    }
+    const bankLookup = !withBanks
+      ? []
+      : [
+        {
+          $lookup: {
+            from: 'banks',
+            localField: 'bankId',
+            foreignField: '_id',
+            as: 'bank',
+          },
+        }, {
+          $unwind: {
+            path: '$bank',
+            preserveNullAndEmptyArrays: true,
+          },
+        },
+      ];
+
+    const projectedFields = isMinified
+      ? [{ $project: { _id: 1, date: 1, amount: 1, reference: 1, balance: 1, transactionType: 1 } }]
+      : [];
+
+    return LoanTransaction.aggregate<T extends true ? ILoanTransactionViewWithBank : ILoanTransactionView>([
+      {
+        $match: {
+          $and: [
+            { 'date': { $gte: transactionsFilter.periodStart } },
+            { 'date': { $lte: transactionsFilter.periodEnd } },
+            { 'productId': { $in: productIds } },
+            ...optionalFilters,
+          ],
+        },
+      }, {
+        $sort: {
+          'date': isReverse ? -1 : 1,
+          'order': isReverse ? -1 : 1,
+          'createdAt': isReverse ? -1 : 1,
+        },
+      },
+      ...ITEMS_PAGINATION(paginatorOptions),
+      ...bankLookup,
+      {
+        $unset: fieldsToUnset,
+      },
+      ...projectedFields,
+    ]);
+  }
+
+  async getLoanTransactionsForFilter(periodStart: Date, periodEnd: Date, productId: string) {
+    return LoanTransaction.aggregate<ILoanTransactionView>([
+      {
+        $match: {
+          $and: [
+            { 'date': { $gte: periodStart } },
+            { 'date': { $lte: periodEnd } },
+            { 'productId': new mongoose.Types.ObjectId(productId) },
+          ],
+        },
+      }, {
+        $sort: {
+          'date': -1,
+          'order': -1,
+          'createdAt': -1,
+        },
+      }, {
+        $unset: fieldsToUnset,
+      },
+    ]);
+  }
+
+  async getLoanTransactionsForProduct(productId: string) {
+    return LoanTransaction.aggregate<ILoanTransactionView>([
+      {
+        $match: {
+          $and: [
+            { 'productId': new mongoose.Types.ObjectId(productId) },
+          ],
+        },
+      }, {
+        $sort: {
+          'date': -1,
+          'order': -1,
+          'createdAt': -1,
+        },
+      }, {
+        $unset: fieldsToUnset,
+      },
+    ]);
+  }
+
+  async getLoanTransactionFiles() {
+    const transactionFiles = await LoanTransactionFileModel.aggregate<ILoanTransactionFileDoc>([
+      {
+        $sort: {
+          'effectiveDate': -1,
+          'createdAt': 1,
+        },
+      }, {
+        $unset: [...fieldsToUnset.filter((field) => field !== 'createdAt')],
+      },
+    ]);
+    return await Promise.all(transactionFiles.map(async (file) => {
+      const effectiveDate = dayjs(file.effectiveDate).format('YYYY-MM-DD');
+      const attachedFiles = await this.attachedFilesService.getAttachedFilesByEffectiveDate(effectiveDate);
+      return { ...file, attachedFileIds: attachedFiles.map((attachedFile) => attachedFile._id.toString()) };
+    }));
+  }
+
+  async getDisbursementTransactions(productId: string, date: Date) {
+    return LoanTransaction.countDocuments(
+      {
+        date: date,
+        productId: new mongoose.Types.ObjectId(productId),
+        transactionType: ELoanTransactionTypes.DISBURSEMENT,
+        bankId: { $ne: null },
+      },
+    );
+  }
+
+  async getTotalLoanTransactions(transactionsFilter: ITransactionsFilter) {
+    const borrowerProducts = await this.loanChargesService.getLoanProducts(transactionsFilter.borrowerId);
+    const productIds = borrowerProducts
+      .filter((product) => transactionsFilter.productId ? product._id.toString() === transactionsFilter.productId : true)
+      .map((product) => product._id);
+    return LoanTransaction.countDocuments(
+      {
+        $and: [
+          { 'date': { $gte: transactionsFilter.periodStart } },
+          { 'date': { $lte: transactionsFilter.periodEnd } },
+          { 'productId': { $in: productIds } },
+        ],
+      },
+    );
+  }
+
+  async uploadLoanTransactions(uploadedItems: ILoanTransactionUpload[], uploadOption: IUploadOption, userId: string, shift = 0) {
+    const orderedItems = uploadedItems.map((item, index) => ({
+      ...item,
+      order: index + shift,
+    }));
+    const transactionsToRecalculate: { productId: string, date: Date, order: number, transactionId: string }[] = [];
+    const statementToSave: string[] = [];
+    await Promise.all(orderedItems.map(async (item) => {
+      const foundBank = await this.banksService.findBankByNumber(item.bankAccountNumber);
+
+      const productId = await this.loanChargesService.getLoanProductIdByCode(item.ledgerAccountCode);
+      if (productId) {
+        const itemToSave: Partial<ILoanTransaction> = {
+          ...(_.pick(item, LOAN_TRANSACTION_FIELDS)),
+          date: calculateTimeZone(item.date),
+          bankId: new mongoose.Types.ObjectId(String(foundBank._id)),
+          productId: new mongoose.Types.ObjectId(productId),
+          balance: 0,
+          floatedBalance: 0,
+          effectiveDate: await this.calculateEffectiveDate(item),
+          userId: new mongoose.Types.ObjectId(userId),
+        };
+        const newLoanTransaction = new LoanTransaction({
+          order: item.order,
+          ...itemToSave,
+        });
+        await newLoanTransaction.save();
+        transactionsToRecalculate.push({
+          productId: newLoanTransaction.productId.toString(),
+          date: newLoanTransaction.date,
+          transactionId: newLoanTransaction._id.toString(),
+          order: newLoanTransaction.order,
+        });
+      }
+
+      const chargeId = await this.loanChargesService.getLoanChargeIdByCode(item.ledgerAccountCode);
+      if (chargeId) {
+        const itemToSave: Partial<ILoanStatementTransaction> = {
+          ...(_.pick(item, LOAN_STATEMENT_TRANSACTION_FIELDS)),
+          date: calculateTimeZone(item.date),
+          chargeId: new mongoose.Types.ObjectId(chargeId),
+          memo: item.reference,
+          isSystem: false,
+          amountPaid: 0,
+        };
+        const loanStatementService = this.getLoanStatementService();
+        const lastOrder = await loanStatementService.getLastTransactionOrder(itemToSave);
+        itemToSave.order = lastOrder + 1;
+        const newLoanStatement = new LoanStatementTransactionModel(itemToSave);
+        await newLoanStatement.save();
+        statementToSave.push(newLoanStatement._id.toString());
+      }
+    }));
+
+    const newLoanTransactionFile = new LoanTransactionFileModel({
+      userUploaded: '',
+      transactionsId: transactionsToRecalculate.map((transaction) => new mongoose.Types.ObjectId(transaction.transactionId)),
+      statementIds: statementToSave.map((statement) => new mongoose.Types.ObjectId(statement)),
+      fileName: uploadOption.fileName,
+      sheetName: uploadOption.sheetName,
+      effectiveDate: uploadOption.effectiveDate,
+    });
+    await newLoanTransactionFile.save();
+
+    const earliestTransactionIds = new Map<string, { transactionId: string, date: Date }>();
+
+    transactionsToRecalculate.forEach((transaction) => {
+      const { productId, transactionId, date } = transaction;
+      if (earliestTransactionIds.has(productId)) {
+        if (date < earliestTransactionIds.get(productId).date) {
+          earliestTransactionIds.set(productId, { transactionId, date });
+        }
+      } else {
+        earliestTransactionIds.set(productId, { transactionId, date });
+      }
+    });
+
+    const earliestTransactionIdsList = Array
+      .from(earliestTransactionIds.values())
+      .map((entry) => entry.transactionId);
+
+    await Promise.all(earliestTransactionIdsList.map(async (transactionId) => {
+      setTimeout(async () => await this.recalculateBalance(transactionId));
+    }));
+  }
+
+  async normalizeLoanTransaction(transaction: ILoanTransactionDoc, userId: string) {
+    transaction.effectiveDate = await this.calculateEffectiveDate(transaction);
+    transaction.date = new Date(transaction.date);
+    switch (ELoanTransactionTypes[transaction.transactionType]) {
+      case ELoanTransactionTypes.DISBURSEMENT:
+        transaction.amount = new Decimal(transaction.amount).abs().toNumber();
+        break;
+      case ELoanTransactionTypes.COLLECTION:
+        transaction.amount = new Decimal(transaction.amount).abs().neg().toNumber();
+        break;
+    }
+    transaction.userId = new mongoose.Types.ObjectId(userId);
+    return transaction;
+  }
+
+  async createLoanTransaction(transaction: Partial<ILoanTransactionWithId>) {
+    const pureTransactions = createFilteredObject<ILoanTransactionView>(transaction, LOAN_TRANSACTION_FIELDS);
+    const product = await this.loanChargesService.getLoanProductById(pureTransactions.productId.toString());
+    if (product) {
+      const bank = await this.banksService.findBankByAccountCode(product.code);
+      if (bank) {
+        pureTransactions.bankId = bank._id;
+      }
+    }
+    pureTransactions.customerId = '';
+    return await this.saveLoanTransaction(pureTransactions);
+  }
+
+  async updateLoanTransaction(transaction: ILoanTransactionDoc) {
+    const pureTransactions = createFilteredObject<ILoanTransactionView>(transaction, LOAN_TRANSACTION_FIELDS);
+    await this.saveLoanTransaction(pureTransactions);
+  }
+
+  async saveLoanTransaction(transaction: Partial<ILoanTransactionWithId>): Promise<ILoanTransactionDoc> {
+    let startId: string;
+    let updatedTransaction: ILoanTransactionDoc;
+    if (!transaction._id) {
+      delete transaction._id;
+      const newTransaction = new LoanTransaction(transaction);
+      startId = newTransaction._id.toString();
+      updatedTransaction = await newTransaction.save();
+    } else {
+      startId = transaction._id.toString();
+      updatedTransaction = await LoanTransaction.findByIdAndUpdate(transaction._id, transaction, { new: true });
+    }
+    if (startId) {
+      await this.recalculateBalance(startId);
+    }
+    const statementDate = this.loanStatementStatusService.getStatementDateForDate(new Date(transaction.date));
+    await this.loanStatementStatusService.updateStatementStatus(transaction.productId.toString(), statementDate, false);
+    await this.termLoanService.setTermLoanExpected(transaction.productId.toString());
+    return updatedTransaction;
+  }
+
+  async recalculateProduct(productId: string) {
+    const firstTransactions = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+      {
+        '$match': {
+          'productId': new mongoose.Types.ObjectId(productId),
+        },
+      }, {
+        '$sort': {
+          'date': 1,
+        },
+      }, {
+        '$limit': 1,
+      },
+    ]);
+
+    if (firstTransactions.length > 0) {
+      await this.recalculateBalance(firstTransactions[0]._id.toString());
+    }
+  }
+
+  async recalculateBalance(transactionId: string) {
+    const changedTransaction = await LoanTransaction.findById<ILoanTransactionDoc & {
+      createdAt: Date
+    }>(transactionId);
+    if (!changedTransaction) {
+      console.error(`no transactions with id ${transactionId}`);
+      return;
+    }
+    setTimeout(async () => {
+      await LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isBalanceActual: false });
+      const previousTransaction = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+        {
+          $match: {
+            'productId': new mongoose.Types.ObjectId(changedTransaction.productId.toString()),
+            'date': { $lt: new Date(changedTransaction.date) },
+          },
+        }, {
+          $sort: {
+            'date': -1,
+            'order': -1,
+            'createdAt': -1,
+          },
+        }, {
+          $limit: 1,
+        },
+      ]);
+      let currentBalance = previousTransaction.length
+        ? previousTransaction[0].balance ?? 0
+        : 0;
+      const recalculatedTransactions = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+        {
+          $match: {
+            'productId': new mongoose.Types.ObjectId(changedTransaction.productId.toString()),
+            'date': { $gte: new Date(changedTransaction.date) },
+          },
+        }, {
+          $sort: {
+            'date': 1,
+            'order': 1,
+            'createdAt': 1,
+          },
+        },
+      ]);
+      for (const transaction of recalculatedTransactions) {
+        currentBalance = new Decimal(currentBalance).add(transaction.amount).toNumber();
+        await LoanTransaction.findByIdAndUpdate(transaction._id, { balance: currentBalance });
+      }
+      await LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isBalanceActual: true });
+    });
+    setTimeout(async () => {
+      await LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isFloatedBalanceActual: false });
+      const previousEqualBalancesTransaction = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+        {
+          $match: {
+            'productId': new mongoose.Types.ObjectId(changedTransaction.productId.toString()),
+            'date': { $lt: new Date(changedTransaction.date) },
+            $expr: { $eq: ['$balance', '$floatedBalance'] },
+          },
+        }, {
+          $sort: {
+            'date': 1,
+            'order': 1,
+            'createdAt': 1,
+          },
+        }, {
+          $limit: 1,
+        },
+      ]);
+      let currentFloatedBalance = 0;
+      if (previousEqualBalancesTransaction.length) {
+        const previousTransaction = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+          {
+            $match: {
+              'productId': new mongoose.Types.ObjectId(previousEqualBalancesTransaction[0].productId.toString()),
+              'date': { $lt: new Date(previousEqualBalancesTransaction[0].date) },
+            },
+          }, {
+            $sort: {
+              'date': -1,
+              'order': -1,
+              'createdAt': -1,
+            },
+          }, {
+            $limit: 1,
+          },
+        ]);
+        if (previousTransaction.length) {
+          currentFloatedBalance = previousTransaction[0].floatedBalance;
+        }
+      }
+      const initTransaction = previousEqualBalancesTransaction.length ? previousEqualBalancesTransaction[0] : changedTransaction;
+      const recalculatedTransactions = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+        {
+          $match: {
+            'productId': new mongoose.Types.ObjectId(initTransaction.productId.toString()),
+            'date': { $gte: new Date(initTransaction.date) },
+          },
+        }, {
+          $sort: {
+            'date': 1,
+            'order': 1,
+            'createdAt': 1,
+          },
+        },
+      ]);
+      for (const transaction of recalculatedTransactions) {
+        const totalPostponed = await getPostponedTransactions(transaction.date, transaction.productId.toString(), true);
+        switch (transaction.transactionType) {
+          case ELoanTransactionTypes.COLLECTION:
+            await this.cleanRecalculated(transaction._id.toString());
+            await this.createPostponedTransaction(transaction);
+            currentFloatedBalance = roundToXDigits(currentFloatedBalance + totalPostponed);
+            break;
+          case ELoanTransactionTypes.DISBURSEMENT:
+            currentFloatedBalance = roundToXDigits(currentFloatedBalance + transaction.amount + totalPostponed);
+            break;
+          case ELoanTransactionTypes.ADJUSTMENT:
+            currentFloatedBalance = roundToXDigits(currentFloatedBalance + transaction.amount + totalPostponed);
+            break;
+        }
+        await LoanTransaction.findByIdAndUpdate(transaction._id, { floatedBalance: currentFloatedBalance });
+      }
+      await LoanProduct.findByIdAndUpdate(changedTransaction.productId, { isFloatedBalanceActual: true });
+    }, 1_000);
+  }
+
+  async deleteLoanTransaction(transactionId: string, updateLoanPayment: boolean, userId = null) {
+    const currentTransaction = await LoanTransaction.findById(transactionId).lean();
+    if (!currentTransaction) {
+      return;
+    }
+    const nextTransaction = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+      {
+        $match: {
+          'productId': new mongoose.Types.ObjectId(currentTransaction.productId.toString()),
+          'date': { $gte: new Date(currentTransaction.date) },
+          '_id': { $ne: new mongoose.Types.ObjectId(transactionId) },
+        },
+      }, {
+        $sort: {
+          'date': 1,
+          'order': 1,
+          'createdAt': 1,
+        },
+      }, {
+        $limit: 1,
+      },
+    ]);
+    await LoanTransaction.findByIdAndDeleteWithUserId(transactionId, userId);
+    await PostponedTransaction.findOneAndDelete({ transactionId });
+    if (currentTransaction.loanPaymentId && updateLoanPayment) {
+      const payment = await LoanPaymentModel.findById(currentTransaction.loanPaymentId).lean();
+      if (payment) {
+        const loanPaymentsService = this.getLoanPaymentsService();
+        await loanPaymentsService.updateLoanPayment(payment as unknown as Partial<ILoanPaymentWithId>, userId);
+      }
+    }
+    if (nextTransaction.length) {
+      await this.recalculateBalance(nextTransaction[0]._id.toString());
+    }
+    const statementDate = this.loanStatementStatusService.getStatementDateForDate(new Date(currentTransaction.date));
+    await this.loanStatementStatusService.updateStatementStatus(currentTransaction.productId.toString(), statementDate, false);
+    await this.termLoanService.setTermLoanExpected(currentTransaction.productId.toString());
+  }
+
+  async createPostponedTransaction(transaction: ILoanTransactionDoc) {
+    const currentDay = dayjs(new Date(transaction.date)).format('YYYY-MM-DD');
+    const workingDate = await this.calendarService.getNextWorkingDay(currentDay);
+    const postponedTransaction: IPostponedTransaction = {
+      postponedToDate: workingDate,
+      transactionId: new mongoose.Types.ObjectId(String(transaction._id)),
+      productId: new mongoose.Types.ObjectId(String(transaction.productId)),
+    };
+    await PostponedTransaction.create(postponedTransaction);
+  }
+
+  async cleanRecalculated(transactionId: string) {
+    await PostponedTransaction.deleteMany({ transactionId });
+  }
+
+  async deleteLoanTransactionFile(transactionFileId: string, userId: string) {
+    const foundFile = await LoanTransactionFileModel.findById(transactionFileId).lean();
+    if (!foundFile) {
+      return null;
+    }
+    await Promise.all(foundFile.transactionsId.map(async (transactionId) => {
+      await this.deleteLoanTransaction(transactionId.toString(), true, userId);
+    }));
+    await Promise.all(foundFile.statementIds.map(async (statementId) => {
+      await LoanStatementTransactionModel.findByIdAndDelete(statementId);
+    }));
+    await LoanTransactionFileModel.findByIdAndDelete(transactionFileId);
+  }
+
+  async getFirstTransaction(productId: string, excludeAdjustments = false) {
+    const excludeFilter = excludeAdjustments
+      ? {
+        'transactionType': {
+          $nin: ['ADJUSTMENT'],
+        },
+      }
+      : {};
+    const lastTransaction = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+      {
+        $match: {
+          'productId': new mongoose.Types.ObjectId(productId),
+          ...excludeFilter,
+        },
+      }, {
+        $sort: {
+          'date': 1,
+          'order': 1,
+          'createdAt': 1,
+        },
+      }, {
+        $limit: 1,
+      },
+    ]);
+    if (!lastTransaction.length) {
+      return null;
+    }
+    return lastTransaction[0];
+  }
+
+  async getLastTransactionForDate(productId: string, date: Date = new Date(), excludeAdjustments = false) {
+    return getLastTransactionForDate(productId, date, excludeAdjustments);
+  }
+
+  async getLastDisbursementTransactionForDate(productId: string, startDate: Date, endDate: Date) {
+    return LoanTransaction.aggregate<ILoanTransactionDoc>([
+      {
+        $match: {
+          $and: [
+            { 'date': { $gte: startDate } },
+            { 'date': { $lte: endDate } },
+            { 'productId': new mongoose.Types.ObjectId(productId) },
+            { 'transactionType': { $ne: ELoanTransactionTypes.COLLECTION } },
+          ],
+        },
+      }, {
+        $sort: {
+          'date': -1,
+          'order': -1,
+          'createdAt': -1,
+        },
+      },
+    ]);
+  }
+
+  async getPaymentsForPeriod(productId: string, startDate: Date, endDate: Date) {
+    return LoanTransaction.aggregate<ILoanTransactionDoc>([
+      {
+        $match: {
+          $and: [
+            { 'date': { $gte: startDate } },
+            { 'date': { $lte: endDate } },
+            { 'productId': new mongoose.Types.ObjectId(productId) },
+            { 'transactionType': ELoanTransactionTypes.COLLECTION },
+          ],
+        },
+      }, {
+        $sort: {
+          'date': -1,
+          'order': -1,
+          'createdAt': -1,
+        },
+      },
+    ]);
+  }
+
+  async getLoanBalanceForBBCDateId(BBCDateId: string) {
+    const bbcDate = await BBCDateModel.findById(BBCDateId);
+    const loanProducts = await LoanProduct.aggregate<ILoanProductDoc>([
+      {
+        '$match': {
+          'borrowerId': new mongoose.Types.ObjectId(bbcDate.borrowerId),
+        },
+      },
+    ]);
+    const balances = {
+      [ELoanTypes.TERM]: 0,
+      [ELoanTypes.REVOLVER]: 0,
+    };
+    await Promise.all(loanProducts.map(async (product) => {
+      const lastTransaction = await this.getLastTransactionForDate(product._id.toString(), dayjs(bbcDate.bbcDate).utcOffset(0).endOf('day').toDate());
+      if (lastTransaction) {
+        balances[ELoanTypes[product.type]] = new Decimal(balances[ELoanTypes[product.type]]).add(lastTransaction.balance).toNumber();
+      }
+    }));
+    return balances;
+  }
+
+  async getLoanBalanceForBBCDateIdPerProduct(BBCDateId: string, productType?: ELoanTypes): Promise<{
+    [productId: string]: { balance: number, product: ILoanProductDoc }
+  }> {
+    const bbcDate = await BBCDateModel.findById(BBCDateId);
+    const productFilter = productType ? { 'type': productType } : {};
+    const loanProducts = await LoanProduct.aggregate<ILoanProductDoc>([
+      {
+        '$match': {
+          'borrowerId': new mongoose.Types.ObjectId(bbcDate.borrowerId),
+          ...productFilter,
+        },
+      },
+    ]);
+    const balances = {};
+    await Promise.all(loanProducts.map(async (product) => {
+      const lastTransaction = await this.getLastTransactionForDate(product._id.toString(), dayjs(bbcDate.bbcDate).utcOffset(0).endOf('day').toDate());
+      balances[product._id.toString()] = { balance: lastTransaction.balance, product };
+    }, {}));
+    return balances;
+  }
+
+  async getLoanBalanceForBorrowerId(borrowerId: string) {
+    const products = await this.loanChargesService.getLoanProducts(borrowerId);
+    const extraInfo = {
+      [ELoanTypes.REVOLVER]: {
+        balance: 0,
+        lastActivityDate: null,
+      },
+      [ELoanTypes.TERM]: {
+        balance: 0,
+        lastActivityDate: null,
+      },
+      accruedStatement: {
+        balance: 0,
+        lastActivityDate: null,
+      },
+      effectiveLoanBalance: {
+        balance: 0,
+        lastActivityDate: null,
+      },
+    };
+    if (products.length === 0) {
+      return extraInfo;
+    }
+    for (const product of products) {
+      try {
+        const lastTransaction = await this.getLastTransactionForDate(product._id.toString());
+        if (lastTransaction) {
+          extraInfo[product.type].balance = new Decimal(extraInfo[product.type].balance).add(lastTransaction.balance).toNumber();
+        }
+        const latRegularTransaction = await this.getLastTransactionForDate(product._id.toString(), new Date(), true);
+        if (latRegularTransaction) {
+          if (!extraInfo[product.type].lastActivityDate || latRegularTransaction.date > extraInfo[product.type].lastActivityDate) {
+            extraInfo[product.type].lastActivityDate = latRegularTransaction.date;
+          }
+        }
+      } catch (error) {
+        console.error('Error:', error);
+      }
+    }
+    const loanStatementService = this.getLoanStatementService();
+    extraInfo.accruedStatement.balance = await loanStatementService.calculateAccruedStatementForBorrower(borrowerId);
+    extraInfo.effectiveLoanBalance.balance = new Decimal(extraInfo[ELoanTypes.REVOLVER].balance).add(extraInfo.accruedStatement.balance).toNumber();
+    return extraInfo;
+  }
+
+  async getUnsentTransactionForDate(borrowerId: string, date: Date) {
+    const products = await this.loanChargesService.getBorrowersLoanProducts(borrowerId);
+    return LoanTransaction.aggregate<ILoanTransactionDoc>([
+      {
+        $match:
+          {
+            'productId': { $in: products.map((product) => product._id) },
+            'isSent': { $in: [false, null] },
+            'date': { $gte: date },
+          },
+      }, {
+        $lookup: {
+          from: 'loan_products',
+          localField: 'productId',
+          foreignField: '_id',
+          as: 'product',
+        },
+      }, {
+        $unwind: {
+          path: '$product',
+        },
+      },
+    ]);
+  }
+
+  async getTransactionReport(transactionIds: string[], borrowerId: string, effectiveDate: Date) {
+    const transactionIdsObjects = transactionIds.map((t) => new mongoose.Types.ObjectId(t));
+    const uploadedTransactions = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+      {
+        $match: {
+          '_id': {
+            $in: transactionIdsObjects,
+          },
+        },
+      }, {
+        $lookup: {
+          from: 'loan_products',
+          localField: 'productId',
+          foreignField: '_id',
+          as: 'product',
+        },
+      }, {
+        $unwind: {
+          path: '$product',
+        },
+      }, {
+        $match: {
+          'product.borrowerId': new mongoose.Types.ObjectId(borrowerId),
+        },
+      },
+    ]);
+
+    const products = await this.loanChargesService.getBorrowersLoanProducts(borrowerId);
+
+    const backDatedTransactions = await LoanTransaction.aggregate<ILoanTransactionDoc>([
+      {
+        $match:
+          {
+            '_id': { $nin: transactionIdsObjects },
+            'productId': { $in: products.map((product) => product._id) },
+            'isSent': { $in: [false, null] },
+            'date': { $lte: effectiveDate },
+          },
+      }, {
+        $lookup: {
+          from: 'loan_products',
+          localField: 'productId',
+          foreignField: '_id',
+          as: 'product',
+        },
+      }, {
+        $unwind: {
+          path: '$product',
+        },
+      },
+    ]);
+
+    const productGroups = products
+      .reduce((acc, product) => {
+        acc[product._id.toString()] = [];
+        return acc;
+      }, {});
+
+    const headerRow = [
+      'date',
+      'amount',
+      'reference',
+      'transaction type',
+    ];
+
+    const backDatedTransactionsTitle = [[''], ['Backdated transactions']];
+
+    const transactionIdsToMark = [...uploadedTransactions, ...backDatedTransactions].map((tr) => tr._id.toString());
+
+    const mappedTransactions: { [productId: string]: (string | number | Date)[] } = uploadedTransactions
+      .filter((t) => !!t)
+      .reduce((acc, t) => {
+        const reportRow = [
+          t.date,
+          t.amount,
+          t.reference,
+          t.transactionType,
+        ];
+        acc[t.productId.toString()] = [...acc[t.productId.toString()], reportRow];
+        return acc;
+      }, _.cloneDeep(productGroups));
+
+    const mappedBackDatedTransactions: { [productId: string]: (string | number | Date)[] } = backDatedTransactions
+      .filter((t) => !!t)
+      .reduce((acc, t) => {
+        const reportRow = [
+          t.date,
+          t.amount,
+          t.reference,
+          t.transactionType,
+        ];
+        acc[t.productId.toString()] = [...acc[t.productId.toString()], reportRow];
+        return acc;
+      }, _.cloneDeep(productGroups));
+
+    const transactions = products.map((product) => {
+      const uploaded = mappedTransactions[product._id.toString()];
+      const backdated = mappedBackDatedTransactions[product._id.toString()];
+      return {
+        [product.name]: [
+          headerRow,
+          ...uploaded,
+          ...backDatedTransactionsTitle,
+          headerRow,
+          ...backdated,
+        ],
+      };
+    });
+    return { transactionIdsToMark, transactions };
+  }
+
+  async getBorrowerIdsForFile(transactionFileId: string) {
+    const transactionFile = await LoanTransactionFileModel.findById(transactionFileId).lean();
+    if (!transactionFile) {
+      console.log('unknown file id', transactionFileId);
+      return;
+    }
+
+    const productIdsSet = new Set<string>();
+    await Promise.all(transactionFile.transactionsId.map(async (transactionId) => {
+      const transaction = await LoanTransaction.findById(transactionId);
+      if (transaction) {
+        productIdsSet.add(transaction.productId.toString());
+      }
+    }));
+    const productIds = Array.from(productIdsSet.values());
+
+    const borrowerIdsSet = new Map<string, boolean>();
+    await Promise.all(productIds.map(async (productId) => {
+      const product = await LoanProduct.findById(productId);
+      if (product) {
+        const foundBorrower: IComplianceBorrowerDocument = await BorrowerCompliance.findOne({ borrower: product.borrowerId.toString() });
+        const isActive = foundBorrower.isEmailingActive && foundBorrower.isDailyTransactionsEmailingActive;
+        borrowerIdsSet.set(product.borrowerId.toString(), isActive);
+      }
+    }));
+    return Object.fromEntries(borrowerIdsSet);
+  }
+
+  async getEmailBorrowers(transactionFileId: string) {
+    return await this.getBorrowerIdsForFile(transactionFileId);
+  }
+
+  async sendReport(transactionFileId: string, selectedBorrowerIds: string[]) {
+    const transactionFile = await LoanTransactionFileModel.findById(transactionFileId).lean();
+    if (!transactionFile) {
+      console.log('unknown file id', transactionFileId);
+      return;
+    }
+    const borrowerIds = await this.getBorrowerIdsForFile(transactionFileId);
+    const transactionIds = transactionFile.transactionsId.map((id) => id.toString());
+
+    await Promise.all(Object.entries(borrowerIds).map(async ([borrowerId, active]) => {
+      if (!selectedBorrowerIds.includes(borrowerId)) {
+        return;
+      }
+      if (!active) {
+        return;
+      }
+      const borrower = await BorrowerModel.findById(borrowerId).lean();
+      if (!borrower) {
+        console.log('unknown borrower', borrowerId);
+        return;
+      }
+      const foundBorrower: IComplianceBorrowerDocument = await BorrowerCompliance.findOne({ borrower: borrowerId });
+      if (!foundBorrower) {
+        return;
+      }
+      const addresses = [...foundBorrower.mainEmails, ...foundBorrower.financialEmails].reduce((acc, email) => email.isActive ? [...acc, email.email] : acc, <string[]>[]);
+      const title = `${borrower.code} ACTIVITY REPORT: ${dayjs(transactionFile.createdAt).format('MM-DD-YYYY')}`;
+      const fileName = title;
+      const subject = title;
+      let text = 'Attached is your daily activity report. Please log into the portal to view your account balance.';
+      const {
+        transactions,
+        transactionIdsToMark,
+      } = await this.getTransactionReport(transactionIds, borrowerId, new Date(transactionFile.effectiveDate));
+      const attachedFile = await this.uploadsService.convertDataToFile(transactions);
+      const attachment = { filename: `${fileName}.xlsx`, content: attachedFile };
+      const attachedPDFs = await this.attachedFilesService.getAttachedRealFilesByTransactionFileId(borrowerId, transactionFile.effectiveDate);
+      if (attachedPDFs.length > 0) {
+        text = text + ' Uploaded PDF files are available for downloading.';
+      }
+      const email: IEmail = { addresses: [...addresses, this.config.portfolioEmail], subject, text };
+      const nodemailerService = this.getNodemailerService();
+      await nodemailerService.sendLoanUploadReport(email, [attachment], borrowerId);
+      await Promise.all(transactionIdsToMark.map(async (id) => {
+        await this.switchTransactionSentStatus(id, true);
+      }));
+    }));
+  }
+
+  async sendAllReport(effectiveDate: Date) {
+    const borrowers = await this.borrowerService.getActiveBorrowers();
+    await Promise.all(borrowers.map(async (borrower) => {
+      if (!borrower.active) {
+        return;
+      }
+      const foundBorrower: IComplianceBorrowerDocument = await BorrowerCompliance.findOne({ borrower: borrower._id.toString() });
+      if (!foundBorrower) {
+        return;
+      }
+      const addresses = [...foundBorrower.mainEmails, ...foundBorrower.financialEmails].reduce((acc, email) => email.isActive ? [...acc, email.email] : acc, <string[]>[]);
+      const title = `${borrower.code} ACTIVITY REPORT: ${dayjs(effectiveDate).format('MM-DD-YYYY')}`;
+      const fileName = title;
+      const subject = title;
+      const dailyTransactions = await this.getUnsentTransactionForDate(borrower._id.toString(), effectiveDate);
+      const transactionIds = dailyTransactions.map((tr) => tr._id.toString());
+      const {
+        transactions,
+        transactionIdsToMark,
+      } = await this.getTransactionReport(transactionIds, borrower._id.toString(), effectiveDate);
+      if (transactions.length === 0 || transactionIdsToMark.length === 0) {
+        return;
+      }
+      const attachedFile = await this.uploadsService.convertDataToFile(transactions);
+      const attachment = { filename: `${fileName}.xlsx`, content: attachedFile };
+      const attachedPDFs = await this.attachedFilesService.getAttachedRealFilesByTransactionFileId(borrower._id.toString(), dayjs(effectiveDate).format('YYYY-MM-DD'));
+      let text = 'Attached is your daily activity report. Please log into the portal to view your account balance.';
+      if (attachedPDFs.length > 0) {
+        text = text + ' Uploaded PDF files are available for downloading.';
+      }
+      const email: IEmail = { addresses: [...addresses, this.config.portfolioEmail], subject, text };
+      const nodemailerService = this.getNodemailerService();
+      await nodemailerService.sendLoanUploadReport(email, [attachment], borrower._id.toString());
+      await Promise.all(transactionIdsToMark.map(async (id) => {
+        await this.switchTransactionSentStatus(id, true);
+      }));
+    }));
+  }
+
+  async calculateEffectiveDate(transaction: Partial<ILoanTransactionDoc>): Promise<Date> {
+    if (transaction.transactionType !== ELoanTransactionTypes.COLLECTION) {
+      return new Date(transaction.date);
+    }
+    const nextDate = await this.calendarService.getNextWorkingDay(dayjs(transaction.date).format('YYYY-MM-DD'));
+    return new Date(nextDate);
+  }
+
+  async switchTransactionSentStatus(transactionId: string, isSent?: boolean) {
+    if (isSent) {
+      await LoanTransaction.findByIdAndUpdate(transactionId, { isSent });
+    } else {
+      const transaction = await LoanTransaction.findById(transactionId).lean();
+      if (transaction) {
+        await LoanTransaction.findByIdAndUpdate(transactionId, { isSent: !transaction.isSent ?? false });
+      }
+    }
+  }
+
+  async checkLockStatus(transaction: ILoanTransactionDoc) {
+    const product = await this.loanChargesService.getLoanProductById(transaction.productId.toString());
+    if (product) {
+      return await this.lockService.isDateLocked(new Date(transaction.date), product.borrowerId.toString());
+    }
+    return false;
+  };
+}