gemcap-be-common 1.2.140 → 1.3.0

package/services/loan-statement-status.service.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoanStatementStatusService = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const dayjs_1 = __importDefault(require("dayjs"));
+const LoanStatementStatus_model_1 = require("../models/LoanStatementStatus.model");
+class LoanStatementStatusService {
+    getLoanChargesService;
+    termLoanService;
+    constructor(getLoanChargesService, termLoanService) {
+        this.getLoanChargesService = getLoanChargesService;
+        this.termLoanService = termLoanService;
+    }
+    async initStatementStatuses() {
+        const allStatuses = await LoanStatementStatus_model_1.LoanStatementStatusModel.find().lean();
+        if (allStatuses.length === 0) {
+            const loanChargesService = this.getLoanChargesService();
+            const loanProducts = await loanChargesService.getAllLoanProducts();
+            const endDate = (0, dayjs_1.default)().utcOffset(0).startOf('month');
+            for (const product of loanProducts) {
+                let currentDate = (0, dayjs_1.default)(product.startDate).utcOffset(0).startOf('month');
+                while (currentDate.diff(endDate, 'month') <= 0) {
+                    const statementDate = this.getStatementDateForDate(currentDate.toDate());
+                    await this.getCreateStatementStatus(product._id.toString(), statementDate);
+                    currentDate = currentDate.add(1, 'month');
+                }
+            }
+        }
+    }
+    getStatementDateFromStringPeriod(period) {
+        let startOf = null;
+        switch (period) {
+            case 'CURRENT_MONTH':
+                startOf = (0, dayjs_1.default)().utcOffset(0).startOf('month');
+                break;
+            case 'LAST_MONTH':
+                startOf = (0, dayjs_1.default)().utcOffset(0).startOf('month').subtract(1, 'second').startOf('month');
+                break;
+        }
+        if (!startOf) {
+            return startOf;
+        }
+        return { year: startOf.year(), month: startOf.month() + 1 };
+    }
+    getStatementDateForDate(date) {
+        const startOf = (0, dayjs_1.default)(date).utcOffset(0).startOf('month');
+        return { year: startOf.year(), month: startOf.month() + 1 };
+    }
+    getStatementDateFromPeriod(period) {
+        return { year: period.start.year(), month: period.start.month() + 1 };
+    }
+    getDateFromStatementDate(statementDate) {
+        return (0, dayjs_1.default)().utcOffset(0).set('year', statementDate.year).set('month', statementDate.month - 1).startOf('month').toDate();
+    }
+    getPeriodsFromStatementDate(statementDate) {
+        if (statementDate.month < 1 || statementDate.month > 12) {
+            throw new Error('Invalid month number. Month should be between 1 and 12.');
+        }
+        const startOfMonth = (0, dayjs_1.default)()
+            .set('year', statementDate.year)
+            .set('month', statementDate.month - 1)
+            .utcOffset(0)
+            .startOf('month');
+        const endOfMonth = startOfMonth.endOf('month');
+        return [{ start: startOfMonth, end: endOfMonth }];
+    }
+    async toggleStatementLock(productId, statementDate) {
+        const statementStatus = await this.getCreateStatementStatus(productId, statementDate);
+        if (statementStatus) {
+            statementStatus.locked = !statementStatus.locked;
+            await statementStatus.save();
+        }
+    }
+    async updateStatementStatus(productId, statementDate, actual) {
+        const statementStatus = await this.getCreateStatementStatus(productId, statementDate);
+        if (statementStatus && !statementStatus.locked) {
+            statementStatus.actual = actual;
+            if (actual) {
+                statementStatus.lastCalculated = new Date();
+            }
+            await statementStatus.save();
+        }
+    }
+    async getAllStatementsStatus(statementDate) {
+        await this.initStatementStatuses();
+        const loanChargesService = this.getLoanChargesService();
+        const products = await loanChargesService.getAllLoanProducts();
+        const results = await Promise.all(products.map(async (product) => {
+            const statementsStatus = await LoanStatementStatus_model_1.LoanStatementStatusModel.findOne({ productId: product._id, ...statementDate }).lean();
+            if (statementsStatus) {
+                return { ...statementsStatus, product };
+            }
+            return null;
+        }));
+        return results.filter((res) => !!res);
+    }
+    async getStatementStatus(productId, date) {
+        const statementDate = this.getStatementDateForDate(date);
+        return this.getCreateStatementStatus(productId, statementDate);
+    }
+    async getCreateStatementStatus(productId, statementDate) {
+        const statementStatus = await LoanStatementStatus_model_1.LoanStatementStatusModel.findOne({ productId, ...statementDate });
+        if (statementStatus) {
+            return statementStatus;
+        }
+        else {
+            const loanStatementStatus = {
+                productId: new mongoose_1.default.Types.ObjectId(productId),
+                year: statementDate.year,
+                month: statementDate.month,
+                actual: true,
+                locked: false,
+                lastCalculated: null,
+            };
+            const newStatementStatus = new LoanStatementStatus_model_1.LoanStatementStatusModel(loanStatementStatus);
+            await newStatementStatus.save();
+            return newStatementStatus;
+        }
+    }
+    async validateDate(productId, date) {
+        try {
+            const statementsStatus = await this.getStatementStatus(productId, date);
+            if (statementsStatus && statementsStatus.locked) {
+                return 'Statement is locked!';
+            }
+            return null;
+        }
+        catch (error) {
+            console.error(error);
+            return 'Internal Server Error';
+        }
+    }
+    async getBorrowerStatement(borrowerId) {
+        try {
+            const lastStatementDate = this.getStatementDateFromStringPeriod('LAST_MONTH');
+            const currentStatementDate = this.getStatementDateFromStringPeriod('CURRENT_MONTH');
+            const lastStatus = await this.getBorrowerMonthStatus(borrowerId, lastStatementDate);
+            const currentStatus = await this.getBorrowerMonthStatus(borrowerId, currentStatementDate);
+            const termLoanStatus = await this.termLoanService.isBorrowerTermLoanActual(borrowerId);
+            return { 'LAST_MONTH': lastStatus, 'CURRENT_MONTH': currentStatus, 'TERM_LOAN': termLoanStatus };
+        }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
+    }
+    async getBorrowerMonthStatus(borrowerId, statementDate) {
+        const loanChargesService = this.getLoanChargesService();
+        const products = await loanChargesService.getLoanProducts(borrowerId);
+        const lastResults = await Promise.all(products.map(async (product) => {
+            return await this.getCreateStatementStatus(product._id.toString(), statementDate);
+        }));
+        return lastResults.reduce((acc, res) => res.actual && acc, true);
+    }
+}
+exports.LoanStatementStatusService = LoanStatementStatusService;

package/services/loan-statement-status.service.ts

@@ -0,0 +1,177 @@
+import mongoose from 'mongoose';
+import dayjs from 'dayjs';
+
+import { ISelectedMonth } from '../helpers/date.helper';
+
+import {
+  ILoanStatementStatus,
+  LoanStatementStatusModel,
+} from '../models/LoanStatementStatus.model';
+import { IStatementPeriod } from './loan-statement.service';
+import { LoanChargesService } from './loan-charges.service';
+import { TermLoanService } from './term-loan.service';
+
+export type SelectablePeriod = 'LAST_MONTH' | 'CURRENT_MONTH' | 'ENTIRE_LOAN' | 'SELECTED_PERIOD';
+
+export class LoanStatementStatusService {
+  constructor(
+    private readonly getLoanChargesService: () => LoanChargesService,
+    private readonly termLoanService: TermLoanService,
+  ) {
+  }
+
+  async initStatementStatuses() {
+    const allStatuses = await LoanStatementStatusModel.find().lean();
+    if (allStatuses.length === 0) {
+      const loanChargesService = this.getLoanChargesService();
+      const loanProducts = await loanChargesService.getAllLoanProducts();
+      const endDate = dayjs().utcOffset(0).startOf('month');
+      for (const product of loanProducts) {
+        let currentDate = dayjs(product.startDate).utcOffset(0).startOf('month');
+        while (currentDate.diff(endDate, 'month') <= 0) {
+          const statementDate = this.getStatementDateForDate(currentDate.toDate());
+          await this.getCreateStatementStatus(product._id.toString(), statementDate);
+          currentDate = currentDate.add(1, 'month');
+        }
+      }
+    }
+  }
+
+  getStatementDateFromStringPeriod(period: SelectablePeriod): ISelectedMonth {
+    let startOf = null;
+    switch (period) {
+      case 'CURRENT_MONTH':
+        startOf = dayjs().utcOffset(0).startOf('month');
+        break;
+      case 'LAST_MONTH':
+        startOf = dayjs().utcOffset(0).startOf('month').subtract(1, 'second').startOf('month');
+        break;
+    }
+    if (!startOf) {
+      return startOf;
+    }
+    return { year: startOf.year(), month: startOf.month() + 1 };
+  }
+
+  getStatementDateForDate(date: Date): ISelectedMonth {
+    const startOf = dayjs(date).utcOffset(0).startOf('month');
+    return { year: startOf.year(), month: startOf.month() + 1 };
+  }
+
+  getStatementDateFromPeriod(period: IStatementPeriod): ISelectedMonth {
+    return { year: period.start.year(), month: period.start.month() + 1 };
+  }
+
+  getDateFromStatementDate(statementDate: ISelectedMonth): Date {
+    return dayjs().utcOffset(0).set('year', statementDate.year).set('month', statementDate.month - 1).startOf('month').toDate();
+  }
+
+  getPeriodsFromStatementDate(statementDate: ISelectedMonth): IStatementPeriod[] {
+    if (statementDate.month < 1 || statementDate.month > 12) {
+      throw new Error('Invalid month number. Month should be between 1 and 12.');
+    }
+
+    const startOfMonth = dayjs()
+      .set('year', statementDate.year)
+      .set('month', statementDate.month - 1)
+      .utcOffset(0)
+      .startOf('month');
+    const endOfMonth = startOfMonth.endOf('month');
+
+    return [{ start: startOfMonth, end: endOfMonth }];
+  }
+
+  async toggleStatementLock(productId: string, statementDate: ISelectedMonth) {
+    const statementStatus = await this.getCreateStatementStatus(productId, statementDate);
+    if (statementStatus) {
+      statementStatus.locked = !statementStatus.locked;
+      await statementStatus.save();
+    }
+  }
+
+  async updateStatementStatus(productId: string, statementDate: ISelectedMonth, actual: boolean) {
+    const statementStatus = await this.getCreateStatementStatus(productId, statementDate);
+    if (statementStatus && !statementStatus.locked) {
+      statementStatus.actual = actual;
+      if (actual) {
+        statementStatus.lastCalculated = new Date();
+      }
+      await statementStatus.save();
+    }
+  }
+
+  async getAllStatementsStatus(statementDate: ISelectedMonth) {
+    await this.initStatementStatuses();
+    const loanChargesService = this.getLoanChargesService();
+    const products = await loanChargesService.getAllLoanProducts();
+    const results = await Promise.all(products.map(async (product) => {
+      const statementsStatus = await LoanStatementStatusModel.findOne({ productId: product._id, ...statementDate }).lean();
+      if (statementsStatus) {
+        return { ...statementsStatus, product };
+      }
+      return null;
+    }));
+    return results.filter((res) => !!res);
+  }
+
+  async getStatementStatus(productId: string, date: Date) {
+    const statementDate = this.getStatementDateForDate(date);
+    return this.getCreateStatementStatus(productId, statementDate);
+  }
+
+  async getCreateStatementStatus(productId: string, statementDate: ISelectedMonth) {
+    const statementStatus = await LoanStatementStatusModel.findOne({ productId, ...statementDate });
+    if (statementStatus) {
+      return statementStatus;
+    } else {
+      const loanStatementStatus: ILoanStatementStatus = {
+        productId: new mongoose.Types.ObjectId(productId),
+        year: statementDate.year,
+        month: statementDate.month,
+        actual: true,
+        locked: false,
+        lastCalculated: null,
+      };
+      const newStatementStatus = new LoanStatementStatusModel(loanStatementStatus);
+      await newStatementStatus.save();
+      return newStatementStatus;
+    }
+
+  }
+
+  async validateDate(productId: string, date: Date) {
+    try {
+      const statementsStatus = await this.getStatementStatus(productId, date);
+      if (statementsStatus && statementsStatus.locked) {
+        return 'Statement is locked!';
+      }
+      return null;
+    } catch (error) {
+      console.error(error);
+      return 'Internal Server Error';
+    }
+  }
+
+  async getBorrowerStatement(borrowerId: string): Promise<{ [K in SelectablePeriod | 'TERM_LOAN']?: boolean }> {
+    try {
+      const lastStatementDate = this.getStatementDateFromStringPeriod('LAST_MONTH');
+      const currentStatementDate = this.getStatementDateFromStringPeriod('CURRENT_MONTH');
+      const lastStatus = await this.getBorrowerMonthStatus(borrowerId, lastStatementDate);
+      const currentStatus = await this.getBorrowerMonthStatus(borrowerId, currentStatementDate);
+      const termLoanStatus = await this.termLoanService.isBorrowerTermLoanActual(borrowerId);
+      return { 'LAST_MONTH': lastStatus, 'CURRENT_MONTH': currentStatus, 'TERM_LOAN': termLoanStatus };
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+  }
+
+  async getBorrowerMonthStatus(borrowerId: string, statementDate: ISelectedMonth) {
+    const loanChargesService = this.getLoanChargesService();
+    const products = await loanChargesService.getLoanProducts(borrowerId);
+    const lastResults = await Promise.all(products.map(async (product) => {
+      return await this.getCreateStatementStatus(product._id.toString(), statementDate);
+    }));
+    return lastResults.reduce((acc, res) => res.actual && acc, true);
+  }
+}

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

@@ -0,0 +1,186 @@
+/// <reference types="lodash" />
+/// <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" />
+/// <reference types="mongoose/types/inferschematype" />
+import dayjs from 'dayjs';
+import { ILoanStatementTransactionDoc, ILoanStatementTransactionWithId } from '../models/LoanStatementTransaction.model';
+import { ELedgerReportType } from '../db/loan-statement.db';
+import { FinancialIndexesService } from './financial-indexes.service';
+import { LoanTransactionsService } from './loan-transactions.service';
+import { LoanStatementStatusService, SelectablePeriod } from './loan-statement-status.service';
+import { LoanChargesService } from './loan-charges.service';
+import { LoanPaymentsService } from './loan-payments.service';
+import { LoanStatementBalanceService } from './loan-statement-balance.service';
+import { TermLoanService } from './term-loan.service';
+import { UploadsService } from './uploads.service';
+import { LoanStatementEffectsService } from './loan-statement-effects.service';
+export interface IStatementPeriod {
+    start: dayjs.Dayjs;
+    end: dayjs.Dayjs;
+}
+export declare class LoanStatementService {
+    private readonly financialIndexesService;
+    private readonly loanChargesService;
+    private readonly loanPaymentsService;
+    private readonly loanStatementBalanceService;
+    private readonly loanStatementStatusService;
+    private readonly loanTransactionsService;
+    private readonly termLoanService;
+    private readonly uploadsService;
+    private readonly getLoanStatementEffectsService;
+    constructor(financialIndexesService: FinancialIndexesService, loanChargesService: LoanChargesService, loanPaymentsService: LoanPaymentsService, loanStatementBalanceService: LoanStatementBalanceService, loanStatementStatusService: LoanStatementStatusService, loanTransactionsService: LoanTransactionsService, termLoanService: TermLoanService, uploadsService: UploadsService, getLoanStatementEffectsService: () => LoanStatementEffectsService);
+    private getGroupedData;
+    getTransactionById(transactionId: string): Promise<import("mongoose").FlattenMaps<ILoanStatementTransactionDoc> & {
+        _id: import("mongoose").Types.ObjectId;
+    }>;
+    getFirstStatementTransaction(productId: string): Promise<ILoanStatementTransactionDoc>;
+    getBorrowerWithPeriods(borrowerId: string, period: {
+        selectedPeriod: string;
+        selectedStart: Date;
+        selectedEnd: Date;
+    }, splitPeriods?: boolean): Promise<any[]>;
+    getPeriods(selectedPeriod: string, productId: string): Promise<IStatementPeriod[]>;
+    getDays(period: {
+        start: dayjs.Dayjs;
+        end: dayjs.Dayjs;
+    }): string[];
+    calculateBorrowerStatement(borrowerId: string, selectedPeriod: SelectablePeriod): Promise<void>;
+    recalculateAllProducts(): Promise<void>;
+    calculateAllBorrowers(): Promise<void>;
+    calculateProductStatement(productId: string, periods: IStatementPeriod[]): Promise<void>;
+    useFloatingBalance(productId: string): Promise<boolean>;
+    calculateStatement(productId: string, period: IStatementPeriod, statementDate?: Date): Promise<void>;
+    reorderStatementForDate(productId: string, date: Date): Promise<void>;
+    getBalancesDaily(productId: string, period: {
+        start: Date;
+        end: Date;
+    }): Promise<{
+        balance: number;
+        floatedBalance: number;
+        day: string;
+    }[]>;
+    private calculateDisbursementFee;
+    cleanProductStatement(productId: string, statementDate: Date): Promise<void>;
+    cleanProductAllStatements(chargesId: string[]): Promise<void>;
+    getProductStatementPdfData(productId: string, start: string, end: string): Promise<{
+        groupedData: {
+            INTEREST_FEE: number;
+            ADMIN_FEE: number;
+            UNUSED_LINE_FEE: number;
+            WIRE_FEE: number;
+            ANNUAL_LINE_FEE: number;
+        };
+        otherStatements: any[];
+        totalAmount: number;
+        transactions: import("../models/LoanTransaction.model").ILoanTransactionViewWithBank[];
+    }>;
+    getProductShortStatementRepresentation(productId: string, start: string, end: string): Promise<any[][]>;
+    createStatementTransaction(transaction: Partial<ILoanStatementTransactionWithId>): Promise<void>;
+    updateStatementTransaction(transaction: Partial<ILoanStatementTransactionWithId>): Promise<void>;
+    saveLoanTransaction(transaction: Partial<ILoanStatementTransactionWithId>): Promise<void>;
+    deleteStatementTransaction(transactionId: string): Promise<void>;
+    addBalancesToStatements(transactionDocs: ILoanStatementTransactionDoc[]): Promise<{
+        floatedBalance: number;
+        order: number;
+        date: Date;
+        chargeId: import("mongoose").Types.ObjectId;
+        amount: number;
+        amountPaid?: number;
+        balance?: number;
+        isSystem: boolean;
+        memo: string;
+        settlementCode?: string;
+        userId?: import("mongoose").Types.ObjectId;
+        isEditable?: boolean;
+        _id?: any;
+        __v?: any;
+        $locals: Record<string, unknown>;
+        $op: "save" | "validate" | "remove";
+        $where: Record<string, unknown>;
+        baseModelName?: string;
+        collection: import("mongoose").Collection<import("bson").Document>;
+        db: import("mongoose").Connection;
+        errors?: import("mongoose").Error.ValidationError;
+        id?: any;
+        isNew: boolean;
+        schema: import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
+            [x: string]: unknown;
+        }, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
+            [x: string]: unknown;
+        }>> & import("mongoose").FlatRecord<{
+            [x: string]: unknown;
+        }> & Required<{
+            _id: unknown;
+        }>>;
+    }[]>;
+    getLastTransactionOrder(transaction: Partial<ILoanStatementTransactionDoc>, onlySystem?: boolean): Promise<number>;
+    getPreviousTransaction(transaction: ILoanStatementTransactionDoc): Promise<ILoanStatementTransactionDoc>;
+    getTransactionsFromDate(productId: string, startDate: Date): Promise<ILoanStatementTransactionDoc[]>;
+    getTransactionsForPeriod(productId: string, period: {
+        start: Date;
+        end: Date;
+    }): Promise<ILoanStatementTransactionDoc[]>;
+    recalculateAllBalances(borrowerIds: string[], userId: string): Promise<void>;
+    recalculateAllStatements(selectedPeriod: SelectablePeriod, borrowerIds: string[]): Promise<void>;
+    recalculateAllTermLoans(borrowerIds: string[]): Promise<void>;
+    getStatementBorrowersTransactions(start: string, end: string, selectedPeriod: string, selectedBorrowerIds: string[], ledgerType: ELedgerReportType): Promise<{
+        transactions: ({
+            borrowerCode: string;
+            type: string;
+            chargeCode: string;
+            PLCode: string;
+            productCode: string;
+            productName: string;
+            info: string;
+            title: string;
+            amount: string;
+            statementAmount: string;
+        } | import("lodash").Omit<import("../db/reports.db").ILedgerReportRow, "balance" | "floatedBalance">)[];
+    }[]>;
+    getBorrowerComplianceData(borrowerId: string, date: Date): Promise<{
+        productTotals: {
+            [productId: string]: number;
+        };
+        total: number;
+        totalPaid: number;
+        dueDate: any;
+    }>;
+    private getOutstandingStatements;
+    getOutstandingStatementsExcel(borrowerIds: string[], selectedDate: Date, fullMonth: boolean): Promise<any>;
+    getBorrowerProductTotals(borrowerId: string): Promise<{
+        productTotals: {
+            [productId: string]: number;
+        };
+        total: number;
+        totalPaid: number;
+        dueDate: any;
+    }>;
+    getProductsTotals(productIds: string[]): Promise<{
+        [productId: string]: number;
+    }>;
+    private getAccruedStatement;
+    calculateAccruedStatementForBBC(bbcDateId: string): Promise<number>;
+    calculateAccruedStatementForBorrower(borrowerId: string): Promise<number>;
+}