gemcap-be-common 1.2.140 → 1.3.0

package/services/lock.service.d.ts

@@ -0,0 +1,6 @@
+import { CollateralsService } from './collaterals.service';
+export declare class LockService {
+    private readonly collateralsService;
+    constructor(collateralsService: CollateralsService);
+    isDateLocked(checkDate: Date, borrowerId: string): Promise<boolean>;
+}

package/services/lock.service.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockService = void 0;
+const AvailabilitySigns_model_1 = require("../models/AvailabilitySigns.model");
+class LockService {
+    collateralsService;
+    constructor(collateralsService) {
+        this.collateralsService = collateralsService;
+    }
+    async isDateLocked(checkDate, borrowerId) {
+        const bbcDocsAfter = await this.collateralsService.gebNextBBC(borrowerId, checkDate);
+        const activeSignsAfter = await AvailabilitySigns_model_1.AvailabilitySignsModel.aggregate([
+            {
+                $match: {
+                    'bbcDateId': { $in: bbcDocsAfter.map((bbc) => bbc._id) },
+                },
+            }, {
+                $unwind: {
+                    path: '$signs',
+                    preserveNullAndEmptyArrays: true,
+                },
+            }, {
+                $match: {
+                    'signs.revokedAt': {
+                        $exists: false,
+                    },
+                },
+            }, {
+                $group: {
+                    '_id': '$_id',
+                    'requiredSigns': { $first: '$requiredSigns' },
+                    'signs': { $push: '$signs' },
+                },
+            }, {
+                $match: {
+                    $expr: {
+                        $gte: [{ '$size': '$signs' }, '$requiredSigns'],
+                    },
+                },
+            },
+        ]);
+        return activeSignsAfter.length > 0;
+    }
+}
+exports.LockService = LockService;

package/services/lock.service.ts

@@ -0,0 +1,45 @@
+import { AvailabilitySignsModel } from '../models/AvailabilitySigns.model';
+
+import { CollateralsService } from './collaterals.service';
+
+export class LockService {
+  constructor(
+    private readonly collateralsService: CollateralsService,
+  ) {
+  }
+
+  async isDateLocked(checkDate: Date, borrowerId: string) {
+    const bbcDocsAfter = await this.collateralsService.gebNextBBC(borrowerId, checkDate);
+    const activeSignsAfter = await AvailabilitySignsModel.aggregate([
+      {
+        $match: {
+          'bbcDateId': { $in: bbcDocsAfter.map((bbc) => bbc._id) },
+        },
+      }, {
+        $unwind: {
+          path: '$signs',
+          preserveNullAndEmptyArrays: true,
+        },
+      }, {
+        $match: {
+          'signs.revokedAt': {
+            $exists: false,
+          },
+        },
+      }, {
+        $group: {
+          '_id': '$_id',
+          'requiredSigns': { $first: '$requiredSigns' },
+          'signs': { $push: '$signs' },
+        },
+      }, {
+        $match: {
+          $expr: {
+            $gte: [{ '$size': '$signs' }, '$requiredSigns'],
+          },
+        },
+      },
+    ]);
+    return activeSignsAfter.length > 0;
+  }
+}

package/services/manual-entry.service.d.ts

@@ -0,0 +1,20 @@
+import { IInventoryManualEntryDoc } from '../models/InventoryManualEntry.model';
+import { IAvailabilitySummary, IReceivableManualSummary } from '../models/ReceivableAvailability.model';
+import { SummaryMultipliers } from '../models/ReceivableAvailabilityManualSummary.model';
+import { InventoryAvailabilityService } from './inventory-availability.service';
+export declare const emptySummary: IAvailabilitySummary;
+export declare class ManualEntryService {
+    private readonly getInventoryAvailabilityService;
+    constructor(getInventoryAvailabilityService: () => InventoryAvailabilityService);
+    private getPreviousInventoryEntries;
+    getInventoryManualEntry(bbcDateId: string): Promise<import("../models/InventoryManualEntry.model").IInventoryManualEntry>;
+    updateInventoryManualEntry(manualEntry: Partial<IInventoryManualEntryDoc>): Promise<void>;
+    getReceivableManualSummary(bbcDateId: string): Promise<{
+        summary: IAvailabilitySummary;
+        multipliers: SummaryMultipliers;
+    }>;
+    updateReceivableManualSummary(manualSummary: IReceivableManualSummary, update: {
+        [index: string]: number;
+    }, multiplier: boolean): Promise<IReceivableManualSummary>;
+    saveReceivableManualSummary(bbcDateId: string, summary: IReceivableManualSummary): Promise<void>;
+}

package/services/manual-entry.service.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManualEntryService = exports.emptySummary = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const numbers_helper_1 = require("../helpers/numbers.helper");
+const inventory_manual_entry_db_1 = require("../db/inventory-manual-entry.db");
+const InventoryManualEntry_model_1 = require("../models/InventoryManualEntry.model");
+const inventory_availability_db_1 = require("../db/inventory-availability.db");
+const BBCDate_model_1 = require("../models/BBCDate.model");
+const bbcDates_db_1 = require("../db/bbcDates.db");
+const collaterals_enum_1 = require("../enums/collaterals.enum");
+const ReceivableAvailabilityManualSummary_model_1 = require("../models/ReceivableAvailabilityManualSummary.model");
+exports.emptySummary = {
+    invoiceAmount: 0,
+    creditNotes: 0,
+    excludedCustomerDeduction: 0,
+    grossAR: 0,
+    permittedOver: 0,
+    preliminaryEligibleBalance: 0,
+    creditNotesNegative: 0,
+    deduction: 0,
+    partiallyPaidDeduction: 0,
+    contraDeduction: 0,
+    crossAgeDeduction: 0,
+    waivedDeduction: 0,
+    balanceAfterCrossAge: 0,
+    finalResult: 0,
+    insuredComponent: 0,
+    uninsuredComponent: 0,
+    insuredAvailability: 0,
+    uninsuredAvailability: 0,
+    ARReserves: 0,
+    ARAvailability: 0,
+};
+const emptyMultipliers = {
+    insuredAvailability: 0,
+    uninsuredAvailability: 0,
+};
+const recalculateAvailabilitySummary = (summary, multiplier, update = null) => {
+    const updatedIndexes = (!update || multiplier) ? [] : Object.keys(update);
+    summary.summary.grossAR = new decimal_js_1.default(summary.summary.invoiceAmount)
+        .plus(summary.summary.excludedCustomerDeduction)
+        .plus(summary.summary.creditNotes)
+        .toNumber();
+    summary.summary.preliminaryEligibleBalance = new decimal_js_1.default(summary.summary.grossAR).plus(summary.summary.permittedOver).toNumber();
+    summary.summary.balanceAfterCrossAge = new decimal_js_1.default(summary.summary.preliminaryEligibleBalance)
+        .plus(summary.summary.deduction)
+        .plus(summary.summary.partiallyPaidDeduction)
+        .plus(summary.summary.contraDeduction)
+        .plus(summary.summary.crossAgeDeduction)
+        .plus(summary.summary.creditNotesNegative)
+        .toNumber();
+    summary.summary.finalResult = new decimal_js_1.default(summary.summary.balanceAfterCrossAge).plus(summary.summary.waivedDeduction).toNumber();
+    if (updatedIndexes.includes('insuredComponent')) {
+        summary.summary.uninsuredComponent = new decimal_js_1.default(summary.summary.finalResult).sub(summary.summary.insuredComponent).toNumber();
+    }
+    else if (updatedIndexes.includes('uninsuredComponent')) {
+        summary.summary.insuredComponent = new decimal_js_1.default(summary.summary.finalResult).sub(summary.summary.uninsuredComponent).toNumber();
+    }
+    else {
+        summary.summary.uninsuredComponent = new decimal_js_1.default(summary.summary.finalResult).sub(summary.summary.insuredComponent).toNumber();
+    }
+    summary.summary.insuredAvailability = new decimal_js_1.default(summary.summary.insuredComponent)
+        .mul(summary.multipliers.insuredAvailability || 0)
+        .div(100)
+        .toNumber();
+    summary.summary.uninsuredAvailability = new decimal_js_1.default(summary.summary.uninsuredComponent)
+        .mul(summary.multipliers.uninsuredAvailability || 0)
+        .div(100)
+        .toNumber();
+    summary.summary.ARAvailability = new decimal_js_1.default(summary.summary.insuredAvailability)
+        .plus(summary.summary.uninsuredAvailability)
+        .sub(summary.summary.ARReserves)
+        .toNumber();
+    return summary;
+};
+class ManualEntryService {
+    getInventoryAvailabilityService;
+    constructor(getInventoryAvailabilityService) {
+        this.getInventoryAvailabilityService = getInventoryAvailabilityService;
+    }
+    async getPreviousInventoryEntries(bbcDateId) {
+        const currentBBC = await BBCDate_model_1.BBCDateModel.findById(bbcDateId);
+        if (currentBBC) {
+            const allBBCs = await (0, bbcDates_db_1.getBBCDatesByType)(currentBBC.borrowerId.toString(), [collaterals_enum_1.ECollaterals.INVENTORY]);
+            const previousBBCs = allBBCs.filter((bbc) => bbc.bbcDate < currentBBC.bbcDate);
+            if (previousBBCs.length > 0) {
+                const lastBBC = previousBBCs[0];
+                const previousEntries = await (0, inventory_manual_entry_db_1.getInventoryManualEntryData)(lastBBC._id.toString());
+                return previousEntries.items;
+            }
+            else {
+                return [];
+            }
+        }
+        return [];
+    }
+    async getInventoryManualEntry(bbcDateId) {
+        const manualEntryData = await (0, inventory_manual_entry_db_1.getInventoryManualEntryData)(bbcDateId);
+        if (!manualEntryData.items.length) {
+            const previousEntries = await this.getPreviousInventoryEntries(bbcDateId);
+            const mappedItems = previousEntries.map((e) => {
+                const { _id, ...rest } = e;
+                return rest;
+            });
+            const newEntries = await InventoryManualEntry_model_1.InventoryManualEntryModel.findOneAndUpdate({ bbcDateId: bbcDateId }, { items: mappedItems }, {
+                upsert: true,
+                new: true,
+            }).lean();
+            manualEntryData.items = newEntries.items;
+        }
+        return manualEntryData;
+    }
+    async updateInventoryManualEntry(manualEntry) {
+        const foundEntry = await InventoryManualEntry_model_1.InventoryManualEntryModel.findOne({ bbcDateId: manualEntry.bbcDateId }).lean();
+        manualEntry.items = manualEntry.items.map((item) => {
+            item.availability = (0, numbers_helper_1.roundToXDigits)((0, numbers_helper_1.roundToXDigits)(item.totalValue - item.ineligible) * item.advanceRate / 100);
+            return item;
+        });
+        if (!foundEntry) {
+            const mappedItems = manualEntry.items.map((item) => {
+                const { _id, ...rest } = item;
+                return rest;
+            });
+            const newEntry = await InventoryManualEntry_model_1.InventoryManualEntryModel.create({
+                bbcDateId: new mongoose_1.default.Types.ObjectId(manualEntry.bbcDateId),
+                items: mappedItems,
+            });
+            await newEntry.save();
+            return;
+        }
+        const mappedItems = manualEntry.items.map((item) => {
+            if (String(item._id).includes('new_')) {
+                const { _id, ...rest } = item;
+                return rest;
+            }
+            return item;
+        });
+        await InventoryManualEntry_model_1.InventoryManualEntryModel.findOneAndUpdate({ bbcDateId: manualEntry.bbcDateId }, { items: mappedItems }).lean();
+        const inventoryAvailability = await (0, inventory_availability_db_1.getInventoryAvailabilityByBBCDateId)(manualEntry.bbcDateId);
+        if (inventoryAvailability && inventoryAvailability.useManualInputs) {
+            const inventoryAvailabilityService = this.getInventoryAvailabilityService();
+            await inventoryAvailabilityService.toggleManualInventoryAvailability(manualEntry.bbcDateId, true);
+        }
+    }
+    async getReceivableManualSummary(bbcDateId) {
+        const manualSummary = await ReceivableAvailabilityManualSummary_model_1.ReceivableAvailabilityManualSummary.findOne({ bbcDateId });
+        if (!manualSummary) {
+            return { summary: exports.emptySummary, multipliers: emptyMultipliers };
+        }
+        return {
+            summary: manualSummary.summary ? manualSummary.summary : exports.emptySummary,
+            multipliers: manualSummary.multipliers ? manualSummary.multipliers : emptyMultipliers,
+        };
+    }
+    async updateReceivableManualSummary(manualSummary, update, multiplier) {
+        const negativeKeys = ['permittedOver', 'deduction', 'partiallyPaidDeduction', 'contraDeduction', 'crossAgeDeduction', 'creditNotesNegative'];
+        Object.entries(update).forEach(([index, value]) => {
+            value = negativeKeys.includes(index) ? new decimal_js_1.default(value).abs().neg().toNumber() : new decimal_js_1.default(value).abs().toNumber();
+            if (multiplier) {
+                manualSummary.multipliers[index] = value;
+            }
+            else {
+                manualSummary.summary[index] = value;
+            }
+        });
+        return recalculateAvailabilitySummary(manualSummary, multiplier, multiplier ? null : update);
+    }
+    async saveReceivableManualSummary(bbcDateId, summary) {
+        const normalizedSummary = recalculateAvailabilitySummary(summary, false);
+        const existingSummary = await ReceivableAvailabilityManualSummary_model_1.ReceivableAvailabilityManualSummary.findOne({ bbcDateId });
+        if (existingSummary) {
+            existingSummary.summary = normalizedSummary.summary;
+            existingSummary.multipliers = summary.multipliers;
+            await existingSummary.save();
+        }
+        else {
+            await ReceivableAvailabilityManualSummary_model_1.ReceivableAvailabilityManualSummary.create({ bbcDateId, summary: normalizedSummary.summary, multipliers: summary.multipliers });
+        }
+    }
+}
+exports.ManualEntryService = ManualEntryService;

package/services/manual-entry.service.ts

@@ -0,0 +1,201 @@
+import mongoose from 'mongoose';
+import Decimal from 'decimal.js';
+
+import { roundToXDigits } from '../helpers/numbers.helper';
+import { getInventoryManualEntryData } from '../db/inventory-manual-entry.db';
+import {
+  IInventoryManualEntryDoc,
+  IInventoryManualEntryItem,
+  InventoryManualEntryModel,
+} from '../models/InventoryManualEntry.model';
+import { getInventoryAvailabilityByBBCDateId } from '../db/inventory-availability.db';
+import { BBCDateModel } from '../models/BBCDate.model';
+import { getBBCDatesByType } from '../db/bbcDates.db';
+import { ECollaterals } from '../enums/collaterals.enum';
+import {
+  IAvailabilitySummary, IReceivableManualSummary,
+} from '../models/ReceivableAvailability.model';
+import {
+  ReceivableAvailabilityManualSummary,
+  SummaryMultipliers,
+} from '../models/ReceivableAvailabilityManualSummary.model';
+
+import { InventoryAvailabilityService } from './inventory-availability.service';
+
+export const emptySummary: IAvailabilitySummary = {
+  invoiceAmount: 0,
+  creditNotes: 0,
+  excludedCustomerDeduction: 0,
+  grossAR: 0,
+  permittedOver: 0,
+  preliminaryEligibleBalance: 0,
+  creditNotesNegative: 0,
+  deduction: 0,
+  partiallyPaidDeduction: 0,
+  contraDeduction: 0,
+  crossAgeDeduction: 0,
+  waivedDeduction: 0,
+  balanceAfterCrossAge: 0,
+  finalResult: 0,
+  insuredComponent: 0,
+  uninsuredComponent: 0,
+  insuredAvailability: 0,
+  uninsuredAvailability: 0,
+  ARReserves: 0,
+  ARAvailability: 0,
+};
+
+const emptyMultipliers: SummaryMultipliers = {
+  insuredAvailability: 0,
+  uninsuredAvailability: 0,
+};
+
+const recalculateAvailabilitySummary = (summary: IReceivableManualSummary, multiplier: boolean, update: { [index: string]: number } = null): IReceivableManualSummary => {
+  const updatedIndexes = (!update || multiplier) ? [] : Object.keys(update);
+
+  summary.summary.grossAR = new Decimal(summary.summary.invoiceAmount)
+    .plus(summary.summary.excludedCustomerDeduction)
+    .plus(summary.summary.creditNotes)
+    .toNumber();
+  summary.summary.preliminaryEligibleBalance = new Decimal(summary.summary.grossAR).plus(summary.summary.permittedOver).toNumber();
+  summary.summary.balanceAfterCrossAge = new Decimal(summary.summary.preliminaryEligibleBalance)
+    .plus(summary.summary.deduction)
+    .plus(summary.summary.partiallyPaidDeduction)
+    .plus(summary.summary.contraDeduction)
+    .plus(summary.summary.crossAgeDeduction)
+    .plus(summary.summary.creditNotesNegative)
+    .toNumber();
+  summary.summary.finalResult = new Decimal(summary.summary.balanceAfterCrossAge).plus(summary.summary.waivedDeduction).toNumber();
+
+  if(updatedIndexes.includes('insuredComponent')) {
+    summary.summary.uninsuredComponent = new Decimal(summary.summary.finalResult).sub(summary.summary.insuredComponent).toNumber()
+  } else if (updatedIndexes.includes('uninsuredComponent')) {
+    summary.summary.insuredComponent = new Decimal(summary.summary.finalResult).sub(summary.summary.uninsuredComponent).toNumber()
+  } else {
+    summary.summary.uninsuredComponent = new Decimal(summary.summary.finalResult).sub(summary.summary.insuredComponent).toNumber()
+  }
+  summary.summary.insuredAvailability = new Decimal(summary.summary.insuredComponent)
+    .mul(summary.multipliers.insuredAvailability || 0)
+    .div(100)
+    .toNumber();
+  summary.summary.uninsuredAvailability = new Decimal(summary.summary.uninsuredComponent)
+    .mul(summary.multipliers.uninsuredAvailability || 0)
+    .div(100)
+    .toNumber();
+  summary.summary.ARAvailability = new Decimal(summary.summary.insuredAvailability)
+    .plus(summary.summary.uninsuredAvailability)
+    .sub(summary.summary.ARReserves)
+    .toNumber();
+  return summary;
+};
+
+export class ManualEntryService {
+
+  constructor(
+    private readonly getInventoryAvailabilityService: () => InventoryAvailabilityService,
+  ) {
+  }
+
+  private async getPreviousInventoryEntries(bbcDateId: string) {
+    const currentBBC = await BBCDateModel.findById(bbcDateId);
+    if (currentBBC) {
+      const allBBCs = await getBBCDatesByType(currentBBC.borrowerId.toString(), [ECollaterals.INVENTORY]);
+      const previousBBCs = allBBCs.filter((bbc) => bbc.bbcDate < currentBBC.bbcDate);
+      if (previousBBCs.length > 0) {
+        const lastBBC = previousBBCs[0];
+        const previousEntries = await getInventoryManualEntryData(lastBBC._id.toString());
+        return previousEntries.items;
+      } else {
+        return [];
+      }
+    }
+    return [];
+  }
+
+  async getInventoryManualEntry(bbcDateId: string) {
+    const manualEntryData = await getInventoryManualEntryData(bbcDateId);
+    if (!manualEntryData.items.length) {
+      const previousEntries = await this.getPreviousInventoryEntries(bbcDateId);
+      const mappedItems = previousEntries.map((e: (IInventoryManualEntryItem & { _id: string })) => {
+        const { _id, ...rest } = e;
+        return rest;
+      });
+      const newEntries = await InventoryManualEntryModel.findOneAndUpdate({ bbcDateId: bbcDateId }, { items: mappedItems }, {
+        upsert: true,
+        new: true,
+      }).lean();
+      manualEntryData.items = newEntries.items;
+    }
+    return manualEntryData;
+  }
+
+  async updateInventoryManualEntry(manualEntry: Partial<IInventoryManualEntryDoc>) {
+    const foundEntry = await InventoryManualEntryModel.findOne({ bbcDateId: manualEntry.bbcDateId }).lean();
+    manualEntry.items = manualEntry.items.map((item) => {
+      item.availability = roundToXDigits(roundToXDigits(item.totalValue - item.ineligible) * item.advanceRate / 100);
+      return item;
+    });
+    if (!foundEntry) {
+      const mappedItems = manualEntry.items.map((item) => {
+        const { _id, ...rest } = item;
+        return rest;
+      });
+      const newEntry = await InventoryManualEntryModel.create({
+        bbcDateId: new mongoose.Types.ObjectId(manualEntry.bbcDateId),
+        items: mappedItems,
+      });
+      await newEntry.save();
+      return;
+    }
+    const mappedItems = manualEntry.items.map((item) => {
+      if (String(item._id).includes('new_')) {
+        const { _id, ...rest } = item;
+        return rest;
+      }
+      return item;
+    });
+    await InventoryManualEntryModel.findOneAndUpdate({ bbcDateId: manualEntry.bbcDateId }, { items: mappedItems }).lean();
+    const inventoryAvailability = await getInventoryAvailabilityByBBCDateId(manualEntry.bbcDateId);
+    if (inventoryAvailability && inventoryAvailability.useManualInputs) {
+      const inventoryAvailabilityService = this.getInventoryAvailabilityService();
+      await inventoryAvailabilityService.toggleManualInventoryAvailability(manualEntry.bbcDateId, true);
+    }
+  }
+
+  async getReceivableManualSummary(bbcDateId: string) {
+    const manualSummary = await ReceivableAvailabilityManualSummary.findOne({ bbcDateId });
+    if (!manualSummary) {
+      return { summary: emptySummary, multipliers: emptyMultipliers };
+    }
+
+    return {
+      summary: manualSummary.summary ? manualSummary.summary:  emptySummary,
+      multipliers: manualSummary.multipliers ? manualSummary.multipliers:  emptyMultipliers,
+    };
+  }
+
+  async updateReceivableManualSummary(manualSummary: IReceivableManualSummary, update: { [index: string]: number }, multiplier: boolean) {
+    const negativeKeys = ['permittedOver', 'deduction', 'partiallyPaidDeduction', 'contraDeduction', 'crossAgeDeduction', 'creditNotesNegative'];
+    Object.entries(update).forEach(([index, value]) => {
+      value = negativeKeys.includes(index) ? new Decimal(value).abs().neg().toNumber() : new Decimal(value).abs().toNumber();
+      if (multiplier) {
+        manualSummary.multipliers[index] = value;
+      } else {
+        manualSummary.summary[index] = value;
+      }
+    });
+    return recalculateAvailabilitySummary(manualSummary, multiplier, multiplier ? null : update);
+  }
+
+  async saveReceivableManualSummary(bbcDateId: string, summary: IReceivableManualSummary) {
+    const normalizedSummary = recalculateAvailabilitySummary(summary, false);
+    const existingSummary = await ReceivableAvailabilityManualSummary.findOne({ bbcDateId });
+    if (existingSummary) {
+      existingSummary.summary = normalizedSummary.summary;
+      existingSummary.multipliers = summary.multipliers;
+      await existingSummary.save();
+    } else {
+      await ReceivableAvailabilityManualSummary.create({ bbcDateId, summary: normalizedSummary.summary, multipliers: summary.multipliers });
+    }
+  }
+}

package/services/month-end-data.service.d.ts

@@ -0,0 +1,34 @@
+/// <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 { IMonthEndData } from '../models/MonthEndData.Model';
+export declare class MonthEndDataService {
+    upsertMonthEndData(input: IMonthEndData): Promise<import("mongoose").Document<unknown, {}, IMonthEndData> & IMonthEndData & Required<{
+        _id: import("mongoose").Types.ObjectId;
+    }>>;
+    getMonthEndData(productId: string, year: number, month: number): Promise<(import("mongoose").Document<unknown, {}, IMonthEndData> & IMonthEndData & Required<{
+        _id: import("mongoose").Types.ObjectId;
+    }>)[]>;
+}

package/services/month-end-data.service.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonthEndDataService = void 0;
+const MonthEndData_Model_1 = require("../models/MonthEndData.Model");
+class MonthEndDataService {
+    async upsertMonthEndData(input) {
+        const { productId, year, month, dataType, dataValue } = input;
+        if (!Object.values(MonthEndData_Model_1.EMonthEndDataType).includes(input.dataType)) {
+            throw new Error(`Invalid dataType: ${dataType}`);
+        }
+        return MonthEndData_Model_1.MonthEndData.findOneAndUpdate({
+            productId,
+            year,
+            month,
+            dataType,
+        }, {
+            $set: {
+                dataValue,
+            },
+        }, {
+            upsert: true,
+            new: true,
+            setDefaultsOnInsert: true,
+        });
+    }
+    async getMonthEndData(productId, year, month) {
+        return MonthEndData_Model_1.MonthEndData.find({ productId, year, month });
+    }
+}
+exports.MonthEndDataService = MonthEndDataService;

package/services/month-end-data.service.ts

@@ -0,0 +1,35 @@
+import { EMonthEndDataType, IMonthEndData, MonthEndData } from '../models/MonthEndData.Model';
+
+export class MonthEndDataService {
+
+  async upsertMonthEndData(input: IMonthEndData) {
+    const { productId, year, month, dataType, dataValue } = input;
+
+    if (!Object.values(EMonthEndDataType).includes(input.dataType)) {
+      throw new Error(`Invalid dataType: ${dataType}`);
+    }
+
+    return MonthEndData.findOneAndUpdate(
+      {
+        productId,
+        year,
+        month,
+        dataType,
+      },
+      {
+        $set: {
+          dataValue,
+        },
+      },
+      {
+        upsert: true,
+        new: true,
+        setDefaultsOnInsert: true,
+      },
+    );
+  }
+
+  async getMonthEndData(productId: string, year: number, month: number) {
+    return MonthEndData.find({ productId, year, month });
+  }
+}