gemcap-be-common 1.2.59 → 1.2.60

package/db/brokers.db.d.ts

@@ -0,0 +1,5 @@
+import { ILedgerDataRow } from './reports.db';
+import { ILoanProductDoc } from '../models/LoanProducts.model';
+import { IProductBrokerDocWithBroker } from '../models/ProductBroker.model';
+export declare const getProductBrokers: (productId: string) => Promise<IProductBrokerDocWithBroker[]>;
+export declare const enrichWithBrokers: (transactions: ILedgerDataRow[], product: ILoanProductDoc) => Promise<ILedgerDataRow[]>;

package/db/brokers.db.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrichWithBrokers = exports.getProductBrokers = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const mongoose_1 = __importDefault(require("mongoose"));
+const reports_db_1 = require("./reports.db");
+const ProductBroker_model_1 = require("../models/ProductBroker.model");
+const getProductBrokers = async (productId) => {
+    return ProductBroker_model_1.ProductBrokerModel.aggregate([
+        {
+            '$match': {
+                'productId': new mongoose_1.default.Types.ObjectId(productId),
+            },
+        }, {
+            $sort: { 'order': 1 },
+        }, {
+            $lookup: {
+                from: 'loan_brokers',
+                localField: 'loanBrokerId',
+                foreignField: '_id',
+                as: 'loanBroker',
+            },
+        }, {
+            $unwind: {
+                path: '$loanBroker',
+                preserveNullAndEmptyArrays: true,
+            },
+        }, {
+            $unset: ['createdAt', 'updatedAt', '__v'],
+        },
+    ]);
+};
+exports.getProductBrokers = getProductBrokers;
+const enrichWithBrokers = async (transactions, product) => {
+    const productBrokers = await (0, exports.getProductBrokers)(product._id.toString());
+    if (productBrokers.length === 0) {
+        return transactions;
+    }
+    const handleFee = (t, broker, shareName) => {
+        return {
+            ...t,
+            statementAmount: new decimal_js_1.default(-t.statementAmount).mul(broker[shareName]).toDP(2).toNumber(),
+            title: `${t.title.replace('ACCRUED', '').trim()}: ${broker.loanBroker.name}`,
+            chargeCode: broker.BSCode,
+            PLCode: broker.PLCode,
+            isBrokerFee: true,
+        };
+    };
+    const handlers = {
+        [reports_db_1.EChargeType.ADMIN_FEE]: (t, broker) => handleFee(t, broker, 'adminShare'),
+        [reports_db_1.EChargeType.INTEREST_FEE]: (t, broker) => handleFee(t, broker, 'interestShare'),
+        [reports_db_1.EChargeType.OTHER]: (t, broker) => handleFee(t, broker, 'otherShare'),
+    };
+    return transactions.reduce((acc, t) => {
+        const handler = handlers[reports_db_1.EChargeType[t.type]];
+        return handler ? [...acc, t, ...productBrokers.map((broker) => handler(t, broker))] : [...acc, t];
+    }, []);
+};
+exports.enrichWithBrokers = enrichWithBrokers;

package/db/brokers.db.ts

@@ -0,0 +1,60 @@
+import Decimal from 'decimal.js';
+import mongoose from 'mongoose';
+
+import { EChargeType, ILedgerDataRow } from './reports.db';
+import { ILoanProductDoc } from '../models/LoanProducts.model';
+import { IProductBrokerDocWithBroker, ProductBrokerModel } from '../models/ProductBroker.model';
+
+export const getProductBrokers = async (productId: string) => {
+  return ProductBrokerModel.aggregate<IProductBrokerDocWithBroker>([
+    {
+      '$match': {
+        'productId': new mongoose.Types.ObjectId(productId),
+      },
+    }, {
+      $sort: { 'order': 1 },
+    }, {
+      $lookup: {
+        from: 'loan_brokers',
+        localField: 'loanBrokerId',
+        foreignField: '_id',
+        as: 'loanBroker',
+      },
+    }, {
+      $unwind: {
+        path: '$loanBroker',
+        preserveNullAndEmptyArrays: true,
+      },
+    }, {
+      $unset: ['createdAt', 'updatedAt', '__v'],
+    },
+  ]);
+};
+
+export const enrichWithBrokers = async (transactions: ILedgerDataRow[], product: ILoanProductDoc): Promise<ILedgerDataRow[]> => {
+  const productBrokers = await getProductBrokers(product._id.toString());
+  if (productBrokers.length === 0) {
+    return transactions;
+  }
+  const handleFee = (t: ILedgerDataRow, broker: IProductBrokerDocWithBroker, shareName: 'adminShare' | 'interestShare' | 'otherShare'): ILedgerDataRow => {
+    return {
+      ...t,
+      statementAmount: new Decimal(-t.statementAmount).mul(broker[shareName]).toDP(2).toNumber(),
+      title: `${t.title.replace('ACCRUED', '').trim()}: ${broker.loanBroker.name}`,
+      chargeCode: broker.BSCode,
+      PLCode: broker.PLCode,
+      isBrokerFee: true,
+    };
+  };
+
+  const handlers = {
+    [EChargeType.ADMIN_FEE]: (t: ILedgerDataRow, broker: IProductBrokerDocWithBroker) => handleFee(t, broker, 'adminShare'),
+    [EChargeType.INTEREST_FEE]: (t: ILedgerDataRow, broker: IProductBrokerDocWithBroker) => handleFee(t, broker, 'interestShare'),
+    [EChargeType.OTHER]: (t: ILedgerDataRow, broker: IProductBrokerDocWithBroker) => handleFee(t, broker, 'otherShare'),
+  };
+
+  return transactions.reduce((acc, t) => {
+    const handler = handlers[EChargeType[t.type]];
+    return handler ? [...acc, t, ...productBrokers.map((broker) => handler(t, broker))] : [...acc, t];
+  }, <ILedgerDataRow[]>[]);
+};

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

@@ -0,0 +1,2 @@
+import { ILoanChargeView } from '../models/LoanCharges.model';
+export declare const getLoanChargeForProduct: (productId: string) => Promise<ILoanChargeView[]>;

package/db/loan-charges.db.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLoanChargeForProduct = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const LoanCharges_model_1 = require("../models/LoanCharges.model");
+const loan_products_db_1 = require("./loan-products.db");
+const getLoanChargeForProduct = async (productId) => {
+    return LoanCharges_model_1.LoanCharge.aggregate([
+        {
+            $match: {
+                'productId': new mongoose_1.default.Types.ObjectId(productId),
+                'deletedAt': { $exists: false },
+            },
+        }, {
+            $sort: {
+                'order': 1,
+            },
+        }, {
+            $unset: loan_products_db_1.fieldsToUnset,
+        },
+    ]);
+};
+exports.getLoanChargeForProduct = getLoanChargeForProduct;

package/db/loan-charges.db.ts

@@ -0,0 +1,21 @@
+import mongoose from 'mongoose';
+
+import { ILoanChargeView, LoanCharge } from '../models/LoanCharges.model';
+import { fieldsToUnset } from './loan-products.db';
+
+export const getLoanChargeForProduct = async (productId: string): Promise<ILoanChargeView[]> => {
+  return LoanCharge.aggregate<ILoanChargeView>([
+    {
+      $match: {
+        'productId': new mongoose.Types.ObjectId(productId),
+        'deletedAt': { $exists: false },
+      },
+    }, {
+      $sort: {
+        'order': 1,
+      },
+    }, {
+      $unset: fieldsToUnset,
+    },
+  ]);
+};

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

@@ -0,0 +1,2 @@
+import { ILoanPaymentDoc } from '../models/LoanPayment.model';
+export declare const getPaymentForTransaction: (productId: string, transactionId: string) => Promise<ILoanPaymentDoc[]>;

package/db/loan-payments.db.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPaymentForTransaction = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const LoanPayment_model_1 = require("../models/LoanPayment.model");
+const getPaymentForTransaction = async (productId, transactionId) => {
+    const payments = await LoanPayment_model_1.LoanPaymentModel.aggregate([
+        {
+            $match: {
+                'productId': new mongoose_1.default.Types.ObjectId(productId),
+                'paid.statementId': new mongoose_1.default.Types.ObjectId(transactionId),
+            },
+        },
+    ]);
+    if (payments.length === 0) {
+        return [];
+    }
+    return payments;
+};
+exports.getPaymentForTransaction = getPaymentForTransaction;

package/db/loan-payments.db.ts

@@ -0,0 +1,18 @@
+import mongoose from 'mongoose';
+
+import { ILoanPaymentDoc, LoanPaymentModel } from '../models/LoanPayment.model';
+
+export const getPaymentForTransaction = async (productId: string, transactionId: string) => {
+  const payments = await LoanPaymentModel.aggregate<ILoanPaymentDoc>([
+    {
+      $match: {
+        'productId': new mongoose.Types.ObjectId(productId),
+        'paid.statementId': new mongoose.Types.ObjectId(transactionId),
+      },
+    },
+  ]);
+  if (payments.length === 0) {
+    return [];
+  }
+  return payments;
+}

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

@@ -23,8 +23,10 @@
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
 import mongoose from 'mongoose';
+import { ILoanProductView } from '../models/LoanProducts.model';
 import { ILoanChargeView } from '../models/LoanCharges.model';
 import { IStatementPeriod } from '../models/LoanStatementTransaction.model';
+export declare const fieldsToUnset: string[];
 export declare const getLoanProductById: (productId: string) => Promise<mongoose.FlattenMaps<import("../models/LoanProducts.model").ILoanProductDoc> & {
     _id: mongoose.Types.ObjectId;
 }>;
@@ -35,3 +37,4 @@ export declare const getLoanProductBalance: (productId: string, forDate?: Date)
 export declare const getPostponedTransactions: (date: Date, productId: string, removePostponed?: boolean) => Promise<number>;
 export declare const getAverageBalance: (productId: string, period: IStatementPeriod, charge?: ILoanChargeView) => Promise<number>;
 export declare const useFloatingBalance: (productId: string) => Promise<boolean>;
+export declare const getLoanProducts: (borrowerId: string) => Promise<ILoanProductView[]>;

package/db/loan-products.db.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useFloatingBalance = exports.getAverageBalance = exports.getPostponedTransactions = exports.getLoanProductBalance = exports.getLoanProductById = void 0;
+exports.getLoanProducts = exports.useFloatingBalance = exports.getAverageBalance = exports.getPostponedTransactions = exports.getLoanProductBalance = exports.getLoanProductById = exports.fieldsToUnset = void 0;
 const mongoose_1 = __importDefault(require("mongoose"));
 const dayjs_1 = __importDefault(require("dayjs"));
 const minMax_1 = __importDefault(require("dayjs/plugin/minMax"));
@@ -16,6 +16,7 @@ const LoanProducts_model_1 = require("../models/LoanProducts.model");
 const LoanTransaction_model_1 = require("../models/LoanTransaction.model");
 const loan_types_enum_1 = require("../enums/loan-types.enum");
 dayjs_1.default.extend(minMax_1.default);
+exports.fieldsToUnset = ['order', '__v', 'createdAt', 'updatedAt', 'borrowerId'];
 const getLoanProductById = async (productId) => {
     return LoanProducts_model_1.LoanProduct.findById(productId).lean();
 };
@@ -165,3 +166,23 @@ const useFloatingBalance = async (productId) => {
     return product.type === loan_types_enum_1.ELoanTypes.REVOLVER;
 };
 exports.useFloatingBalance = useFloatingBalance;
+const getLoanProducts = async (borrowerId) => {
+    return LoanProducts_model_1.LoanProduct.aggregate([
+        {
+            $match: {
+                'borrowerId': new mongoose_1.default.Types.ObjectId(borrowerId),
+            },
+        }, {
+            $sort: {
+                'order': 1,
+            },
+        }, {
+            $unset: exports.fieldsToUnset,
+        }, {
+            $addFields: {
+                valid: true,
+            },
+        },
+    ]);
+};
+exports.getLoanProducts = getLoanProducts;

package/db/loan-products.db.ts

@@ -7,7 +7,7 @@ import { getDays } from '../helpers/date.helper';
 import { roundToXDigits } from '../helpers/numbers.helper';
 import { getTotalForDate } from './loan-statement.db';
 import { IPostponedTransactionWithTransaction, PostponedTransaction } from '../models/PostponedTransactions.model';
-import { LoanProduct } from '../models/LoanProducts.model';
+import { ILoanProductView, LoanProduct } from '../models/LoanProducts.model';
 import { ILoanChargeView } from '../models/LoanCharges.model';
 import { ILoanTransactionDoc, LoanTransaction } from '../models/LoanTransaction.model';
 import { IStatementPeriod } from '../models/LoanStatementTransaction.model';
@@ -15,6 +15,8 @@ import { ELoanTypes } from '../enums/loan-types.enum';
 
 dayjs.extend(minMax);
 
+export const fieldsToUnset = ['order', '__v', 'createdAt', 'updatedAt', 'borrowerId'];
+
 export const getLoanProductById = async (productId: string) => {
   return LoanProduct.findById(productId).lean();
 };
@@ -169,3 +171,23 @@ export const useFloatingBalance = async (productId: string) => {
   const product = await getLoanProductById(productId);
   return product.type === ELoanTypes.REVOLVER;
 };
+
+export const getLoanProducts = async (borrowerId: string) => {
+  return LoanProduct.aggregate<ILoanProductView>([
+    {
+      $match: {
+        'borrowerId': new mongoose.Types.ObjectId(borrowerId),
+      },
+    }, {
+      $sort: {
+        'order': 1,
+      },
+    }, {
+      $unset: fieldsToUnset,
+    }, {
+      $addFields: {
+        valid: true,
+      },
+    },
+  ]);
+}

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

@@ -1,2 +1,46 @@
+import { IStatementPeriod } from '../models/LoanStatementTransaction.model';
+export declare enum ELedgerReportType {
+    SHORT = 0,
+    DETAILED = 1
+}
+export declare const ledgerHeadersMap: {
+    0: {
+        borrowerCode: string;
+        type: string;
+        chargeCode: string;
+        PLCode: string;
+        productCode: string;
+        productName: string;
+        info: string;
+        title: string;
+        amount: string;
+        statementAmount: string;
+    };
+    1: {
+        borrowerCode: string;
+        date: string;
+        type: string;
+        chargeCode: string;
+        PLCode: string;
+        productCode: string;
+        productName: string;
+        info: string;
+        amount: string;
+        statementAmount: string;
+        title: string;
+        balance: string;
+        floatedBalance: string;
+        paymentDate: string;
+    };
+};
 export declare const getTotalTransactionAmountForCharge: (chargeId: string, start: Date, end: Date) => Promise<any>;
 export declare const getTotalForDate: (productId: string, date: Date) => Promise<number>;
+export declare const getStatementBorrowersTransactions: (start: string, end: string, selectedPeriod: string, selectedBorrowerIds: string[], ledgerType: ELedgerReportType) => Promise<{
+    transactions: any[];
+}[]>;
+export declare const getBorrowerWithPeriods: (borrowerId: string, period: {
+    selectedPeriod: string;
+    selectedStart: Date;
+    selectedEnd: Date;
+}, splitPeriods?: boolean) => Promise<any[]>;
+export declare const getPeriods: (selectedPeriod: string, productId: string) => Promise<IStatementPeriod[]>;

package/db/loan-statement.db.js

@@ -3,10 +3,52 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTotalForDate = exports.getTotalTransactionAmountForCharge = void 0;
+exports.getPeriods = exports.getBorrowerWithPeriods = exports.getStatementBorrowersTransactions = exports.getTotalForDate = exports.getTotalTransactionAmountForCharge = exports.ledgerHeadersMap = exports.ELedgerReportType = void 0;
+const lodash_1 = __importDefault(require("lodash"));
 const mongoose_1 = __importDefault(require("mongoose"));
+const dayjs_1 = __importDefault(require("dayjs"));
 const LoanStatementTransaction_model_1 = require("../models/LoanStatementTransaction.model");
 const LoanTransaction_model_1 = require("../models/LoanTransaction.model");
+const loan_products_db_1 = require("./loan-products.db");
+const LoanProducts_model_1 = require("../models/LoanProducts.model");
+const Borrower_model_1 = require("../models/Borrower.model");
+const loan_transactions_db_1 = require("./loan-transactions.db");
+const reports_db_1 = require("./reports.db");
+var ELedgerReportType;
+(function (ELedgerReportType) {
+    ELedgerReportType[ELedgerReportType["SHORT"] = 0] = "SHORT";
+    ELedgerReportType[ELedgerReportType["DETAILED"] = 1] = "DETAILED";
+})(ELedgerReportType || (exports.ELedgerReportType = ELedgerReportType = {}));
+exports.ledgerHeadersMap = {
+    [ELedgerReportType.SHORT]: {
+        borrowerCode: 'borrower code',
+        type: 'type',
+        chargeCode: 'BS code',
+        PLCode: 'P&L code',
+        productCode: 'product code',
+        productName: 'product name',
+        info: 'memo/reference',
+        title: 'title',
+        amount: 'amount',
+        statementAmount: 'Statement amount',
+    },
+    [ELedgerReportType.DETAILED]: {
+        borrowerCode: 'borrower code',
+        date: 'date',
+        type: 'type',
+        chargeCode: 'BS code',
+        PLCode: 'P&L code',
+        productCode: 'product code',
+        productName: 'product name',
+        info: 'memo/reference',
+        amount: 'amount',
+        statementAmount: 'Statement amount',
+        title: 'title',
+        balance: 'balance',
+        floatedBalance: 'floated balance',
+        paymentDate: 'payment date',
+    },
+};
 const getTotalTransactionAmountForCharge = async (chargeId, start, end) => {
     const results = await LoanStatementTransaction_model_1.LoanStatementTransactionModel.aggregate([
         {
@@ -58,3 +100,146 @@ const getTotalForDate = async (productId, date) => {
     return totalAmount[0].totalAmount;
 };
 exports.getTotalForDate = getTotalForDate;
+const getStatementBorrowersTransactions = async (start, end, selectedPeriod, selectedBorrowerIds, ledgerType) => {
+    const header = exports.ledgerHeadersMap[ledgerType];
+    if (!selectedBorrowerIds) {
+        return [{ transactions: [header] }];
+    }
+    const allTransactions = {};
+    await Promise.all(selectedBorrowerIds.map(async (borrowerId) => {
+        const products = await (0, loan_products_db_1.getLoanProducts)(borrowerId);
+        const periodFull = await (0, exports.getBorrowerWithPeriods)(borrowerId, {
+            selectedStart: new Date(start),
+            selectedEnd: new Date(end),
+            selectedPeriod,
+        });
+        const someMappedResults = products.reduce((acc, product) => {
+            return [
+                ...acc,
+                ...periodFull.map((periodDesc) => ({
+                    productStart: periodDesc.period.start,
+                    productEnd: periodDesc.period.end,
+                    productId: product._id.toString(),
+                })),
+            ];
+        }, []);
+        await Promise.all(someMappedResults.map(async (productDesc) => {
+            const borrowerTransactions = await (0, reports_db_1.getLedger)(productDesc.productId, new Date(productDesc.productStart), new Date(productDesc.productEnd), ledgerType, true);
+            Object.values(borrowerTransactions).forEach((transactions) => {
+                const [_header, ...onlyData] = transactions;
+                const mappedData = lodash_1.default.map(onlyData, (obj) => lodash_1.default.omit(obj, ['balance', 'floatedBalance']));
+                allTransactions[borrowerId] = mappedData;
+            });
+        }));
+    }));
+    const sortedTransactions = [];
+    for (const borrowerId of selectedBorrowerIds) {
+        console.log(borrowerId);
+        sortedTransactions.push(...allTransactions[borrowerId]);
+    }
+    return [{ transactions: [header, ...sortedTransactions] }];
+};
+exports.getStatementBorrowersTransactions = getStatementBorrowersTransactions;
+const getBorrowerWithPeriods = async (borrowerId, period, splitPeriods = false) => {
+    const borrower = await Borrower_model_1.BorrowerModel.findById(borrowerId).lean();
+    let start;
+    let end;
+    switch (period.selectedPeriod) {
+        case 'SELECTED_PERIOD': {
+            start = (0, dayjs_1.default)(new Date(period.selectedStart)).startOf('day');
+            end = (0, dayjs_1.default)(new Date(period.selectedEnd)).endOf('day');
+            break;
+        }
+        case 'ENTIRE_LOAN': {
+            const products = await LoanProducts_model_1.LoanProduct.find({ borrowerId: borrower._id.toString() }).lean();
+            const productPeriods = await Promise.all(products.map(async (product) => {
+                const periods = await (0, exports.getPeriods)(period.selectedPeriod, product._id.toString());
+                const periodStart = periods[0].start.startOf('day');
+                const periodEnd = periods[periods.length - 1].end.endOf('day');
+                return { periodStart, periodEnd };
+            }));
+            const starts = productPeriods.map((p) => p.periodStart);
+            const ends = productPeriods.map((p) => p.periodEnd);
+            start = dayjs_1.default.min(starts);
+            end = dayjs_1.default.max(ends);
+            break;
+        }
+        default: {
+            const periods = await (0, exports.getPeriods)(period.selectedPeriod, null);
+            start = periods[0].start.startOf('day');
+            end = periods[periods.length - 1].end.endOf('day');
+            break;
+        }
+    }
+    if (splitPeriods) {
+        const result = [];
+        let currentMonth = start.startOf('month');
+        while (currentMonth.isBefore(end) || currentMonth.isSame(end, 'month')) {
+            const startOfMonth = currentMonth.startOf('month');
+            const endOfMonth = currentMonth.endOf('month');
+            result.push({
+                _id: borrower._id.toString(),
+                code: borrower.code,
+                name: borrower.name,
+                period: {
+                    selectedPeriod: period.selectedPeriod,
+                    start: startOfMonth.utc().toDate().toISOString(),
+                    end: endOfMonth.utc().toDate().toISOString(),
+                },
+            });
+            currentMonth = currentMonth.add(1, 'month');
+        }
+        return result;
+    }
+    else {
+        return [{
+                _id: borrower._id.toString(),
+                code: borrower.code,
+                name: borrower.name,
+                period: {
+                    selectedPeriod: period.selectedPeriod,
+                    start: start.utc().toDate().toISOString(),
+                    end: end.utc().toDate().toISOString(),
+                },
+            }];
+    }
+};
+exports.getBorrowerWithPeriods = getBorrowerWithPeriods;
+const getPeriods = async (selectedPeriod, productId) => {
+    let start;
+    let end;
+    switch (selectedPeriod) {
+        case 'CURRENT_MONTH': {
+            start = (0, dayjs_1.default)().utcOffset(0).startOf('month');
+            end = (0, dayjs_1.default)().utcOffset(0).endOf('month');
+            return [{ start, end }];
+        }
+        case 'LAST_MONTH': {
+            start = (0, dayjs_1.default)().subtract(1, 'month').utcOffset(0).startOf('month');
+            end = (0, dayjs_1.default)().subtract(1, 'month').utcOffset(0).endOf('month');
+            return [{ start, end }];
+        }
+        case 'ENTIRE_LOAN': {
+            const product = await (0, loan_products_db_1.getLoanProductById)(productId);
+            const lastTransaction = await (0, loan_transactions_db_1.getLastTransactionForDate)(productId);
+            start = (0, dayjs_1.default)(product.startDate).tz('UTC');
+            let lastDate = (0, dayjs_1.default)(new Date()).endOf('month').toDate();
+            if (lastTransaction) {
+                if ((0, dayjs_1.default)(lastTransaction.date).tz('UTC').toDate() > (0, dayjs_1.default)(new Date()).endOf('month').toDate()) {
+                    lastDate = lastTransaction.date;
+                }
+            }
+            end = (0, dayjs_1.default)(lastDate);
+            const finish = (0, dayjs_1.default)(lastDate);
+            const periods = [];
+            do {
+                end = start.endOf('month');
+                periods.push({ start, end });
+                start = end.add(1, 'day').startOf('month').utc();
+            } while (finish.toDate() > end.toDate());
+            return periods;
+        }
+    }
+    return [];
+};
+exports.getPeriods = getPeriods;