gemcap-be-common 1.2.140 → 1.3.0

package/services/groups.service.ts

@@ -0,0 +1,64 @@
+import { IBorrowerGroupWithId } from '../interfaces/group.interface';
+import { ICustomerGroupDocument } from '../models/CustomerGroup.model';
+import { groupsMap } from '../db/groups.db';
+
+import MappedGroup, { IMappedGroup } from '../models/MappedGroup.model';
+
+export class GroupsService {
+  async createBorrowerGroups(borrowerId: string, groupType: string, groups: IBorrowerGroupWithId[]) {
+    const groupIds = groups.map((group) => group._id);
+    const allExistedGroups: ICustomerGroupDocument[] = await groupsMap[groupType].Model.find({ borrowerId }).lean();
+    await Promise.all(allExistedGroups.map(async (group) => {
+      if (!groupIds.includes(group.id)) {
+        await groupsMap[groupType].Model.findByIdAndDelete(group.id);
+      }
+    }))
+    await Promise.all(groups.map(async (group) => {
+      if (!group._id) {
+        const newGroup = new groupsMap[groupType].Model(group);
+        await newGroup.save();
+      } else {
+        await groupsMap[groupType].Model.findByIdAndUpdate(group._id, group);
+      }
+    }));
+  }
+
+  async getBorrowerGroups(borrowerId: string, relationshipGroups: string | string[]) {
+    if (typeof relationshipGroups == 'string') {
+      relationshipGroups = [relationshipGroups];
+    }
+    const allCustomerGroups = await Promise.all(relationshipGroups.map(async (groupName) => {
+      const groups = await groupsMap[groupName].Model.find({ borrowerId }).sort({ 'createdAt': 1 });
+      return { [groupName]: groups };
+    }))
+    return allCustomerGroups.reduce((acc, group) => {
+      return { ...acc, ...group };
+    }, {});
+  }
+
+  async createMappedGroups(borrowerId: string, groupType: string, groups: IMappedGroup[]) {
+    await MappedGroup.deleteMany({ borrowerId, groupType });
+    await Promise.all(groups.map(async (group) => {
+      const newMappedGroup = new MappedGroup({
+        borrowerId,
+        group1: group.group1,
+        group2: group.group2,
+        groupType: groupType,
+      });
+      await newMappedGroup.save();
+    }));
+  }
+
+  async getMappedGroups(borrowerId: string, groupTypes: string | string[]) {
+    if (typeof groupTypes == 'string') {
+      groupTypes = [groupTypes];
+    }
+    const allMappedGroups = await Promise.all(groupTypes.map(async (groupType) => {
+      const groups = await MappedGroup.find({ borrowerId, groupType });
+      return { [groupType]: groups };
+    }))
+    return allMappedGroups.reduce((acc, group) => {
+      return { ...acc, ...group };
+    }, {});
+  }
+}

package/services/inventory-availability.service.d.ts

@@ -0,0 +1,13 @@
+import { IInventoryAvailability, IInventoryAvailabilityDocument, InventoryAvailabilityPaginators } from '../models/InventoryAvailability.model';
+import { ManualEntryService } from './manual-entry.service';
+export declare class InventoryAvailabilityService {
+    private readonly manualEntryService;
+    constructor(manualEntryService: ManualEntryService);
+    getLatestBBCFilters(excludedBBCDateId: string): Promise<import("../models/InventoryAvailability.model").IInventoryFilter[]>;
+    getInventoryAvailability(bbcDateId: string, paginators: InventoryAvailabilityPaginators): Promise<Partial<IInventoryAvailabilityDocument>>;
+    getInventoryAvailabilityFilters(bbcDateId: string): Promise<IInventoryAvailabilityDocument>;
+    updateInventoryAvailabilityFilters(inventoryAvailability: IInventoryAvailability): Promise<IInventoryAvailabilityDocument>;
+    getAllInventorySettings(bbcDateId: string, borrowerId: string): Promise<any>;
+    checkCreateAvailability(bbcDateId: string): Promise<void>;
+    toggleManualInventoryAvailability(bbcDateId: string, useManualInputs: boolean): Promise<void>;
+}

package/services/inventory-availability.service.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InventoryAvailabilityService = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const lodash_1 = __importDefault(require("lodash"));
+const mongoose_1 = __importDefault(require("mongoose"));
+const inventory_availability_db_1 = require("../db/inventory-availability.db");
+const bbcDates_db_1 = require("../db/bbcDates.db");
+const BBCDate_model_1 = require("../models/BBCDate.model");
+const inventory_availability_results_enum_1 = require("../enums/inventory-availability-results.enum");
+const InventoryAvailability_model_1 = require("../models/InventoryAvailability.model");
+const inventory_availability_1 = require("../db/inventory-availability");
+const availability_service_1 = require("./availability.service");
+class InventoryAvailabilityService {
+    manualEntryService;
+    constructor(manualEntryService) {
+        this.manualEntryService = manualEntryService;
+    }
+    async getLatestBBCFilters(excludedBBCDateId) {
+        const bbcDateDoc = await BBCDate_model_1.BBCDateModel.findById(excludedBBCDateId).lean();
+        if (!bbcDateDoc) {
+            return [];
+        }
+        const latestBBCDate = await BBCDate_model_1.BBCDateModel.aggregate([
+            {
+                $match: {
+                    '_id': { $ne: new mongoose_1.default.Types.ObjectId(excludedBBCDateId) },
+                    'borrowerId': new mongoose_1.default.Types.ObjectId(bbcDateDoc.borrowerId),
+                },
+            }, {
+                $sort: {
+                    'bbcDate': -1,
+                },
+            },
+        ]);
+        if (latestBBCDate.length === 0) {
+            return [];
+        }
+        for (const bbcDate of latestBBCDate) {
+            const availability = await this.getInventoryAvailabilityFilters(bbcDate._id.toString());
+            if (!!availability) {
+                return availability.filters;
+            }
+        }
+        return [];
+    }
+    async getInventoryAvailability(bbcDateId, paginators) {
+        const availability = await this.getInventoryAvailabilityFilters(bbcDateId);
+        const { borrowerId } = await (0, bbcDates_db_1.getBBCDateDoc)(bbcDateId);
+        if (!availability) {
+            const lastFilters = await this.getLatestBBCFilters(bbcDateId);
+            const newAvailability = {
+                bbcDateId: new mongoose_1.default.Types.ObjectId(bbcDateId),
+                borrowerId: new mongoose_1.default.Types.ObjectId(borrowerId),
+                filters: lastFilters,
+                options: { maxAdvanceRatePriority: true },
+                useManualInputs: false,
+                results: {
+                    [inventory_availability_results_enum_1.EInventoryAvailabilityResults.UNIQ_ITEMS]: {
+                        items: [],
+                        totalItems: 0,
+                        paginatorOptions: paginators[inventory_availability_results_enum_1.EInventoryAvailabilityResults.UNIQ_ITEMS],
+                    },
+                    [inventory_availability_results_enum_1.EInventoryAvailabilityResults.NON_UNIQ_ITEMS]: {
+                        items: [],
+                        totalItems: 0,
+                        paginatorOptions: paginators[inventory_availability_results_enum_1.EInventoryAvailabilityResults.NON_UNIQ_ITEMS],
+                    },
+                    [inventory_availability_results_enum_1.EInventoryAvailabilityResults.NOT_MATCHED_ITEMS]: {
+                        items: [],
+                        totalItems: 0,
+                        paginatorOptions: paginators[inventory_availability_results_enum_1.EInventoryAvailabilityResults.NOT_MATCHED_ITEMS],
+                    },
+                },
+                summary: [],
+            };
+            return newAvailability;
+        }
+        const items = await (0, inventory_availability_1.getInventoryAvailabilityItems)(String(availability._id), paginators);
+        availability.results = { ...availability.results, ...items };
+        return availability;
+    }
+    async getInventoryAvailabilityFilters(bbcDateId) {
+        return await (0, inventory_availability_db_1.getInventoryAvailabilityByBBCDateId)(bbcDateId);
+    }
+    async updateInventoryAvailabilityFilters(inventoryAvailability) {
+        return await (0, inventory_availability_1.createInventoryAvailability)(inventoryAvailability);
+    }
+    async getAllInventorySettings(bbcDateId = null, borrowerId) {
+        const availabilities = await InventoryAvailability_model_1.InventoryAvailabilityModel.aggregate([
+            {
+                $match: {
+                    $and: [
+                        { 'borrowerId': new mongoose_1.default.Types.ObjectId(borrowerId) },
+                        { 'bbcDateId': { '$ne': new mongoose_1.default.Types.ObjectId(bbcDateId) } },
+                    ],
+                },
+            },
+        ]);
+        return availabilities.reduce((acc, availability) => {
+            const settings = lodash_1.default.pick(availability, ['filters', 'options']);
+            return { ...acc, [availability.bbcDateId.toString()]: settings };
+        }, {});
+    }
+    async checkCreateAvailability(bbcDateId) {
+        const inventoryAvailability = await (0, inventory_availability_db_1.getInventoryAvailabilityByBBCDateId)(bbcDateId);
+        if (inventoryAvailability) {
+            return;
+        }
+        const newAvailability = await this.getInventoryAvailability(bbcDateId, availability_service_1.START_PAGINATORS);
+        if (newAvailability) {
+            await (0, inventory_availability_1.createInventoryAvailability)(newAvailability);
+        }
+    }
+    async toggleManualInventoryAvailability(bbcDateId, useManualInputs) {
+        await this.checkCreateAvailability(bbcDateId);
+        await (0, inventory_availability_db_1.setManualInputsToggle)(bbcDateId, useManualInputs);
+        const inventoryAvailability = await (0, inventory_availability_db_1.getInventoryAvailabilityByBBCDateId)(bbcDateId);
+        if (!inventoryAvailability) {
+            return;
+        }
+        if (useManualInputs) {
+            const manualRates = await this.manualEntryService.getInventoryManualEntry(bbcDateId);
+            const summaryTotal = {
+                advanceRate: 0,
+                availability: 0,
+                inventoryName: 'TOTAL',
+                isGroup: false,
+                order: 1000,
+                totalQty: 0,
+                totalValue: 0,
+            };
+            const newSummary = manualRates.items.map((item, order) => {
+                return {
+                    order,
+                    isGroup: false,
+                    inventoryName: item.inventoryName,
+                    totalQty: item.totalQty,
+                    totalValue: item.totalValue,
+                    advanceRate: new decimal_js_1.default(item.advanceRate).div(100).toDP(2).toNumber(),
+                    availability: item.availability,
+                };
+            });
+            const updateSummaryTotal = (summaryTotal, item) => {
+                summaryTotal.availability += item.availability;
+                summaryTotal.totalQty += item.totalQty;
+                summaryTotal.totalValue += item.totalValue;
+                if (summaryTotal.totalValue) {
+                    summaryTotal.advanceRate = summaryTotal.availability / summaryTotal.totalValue;
+                }
+                else {
+                    summaryTotal.advanceRate = 0;
+                }
+            };
+            newSummary.forEach((item) => updateSummaryTotal(summaryTotal, item));
+            summaryTotal.availability = new decimal_js_1.default(summaryTotal.availability).toDP(2).toNumber();
+            summaryTotal.totalQty = new decimal_js_1.default(summaryTotal.totalQty).toDP(2).toNumber();
+            summaryTotal.totalValue = new decimal_js_1.default(summaryTotal.totalValue).toDP(2).toNumber();
+            summaryTotal.advanceRate = new decimal_js_1.default(summaryTotal.advanceRate).toDP(2).toNumber();
+            await (0, inventory_availability_db_1.saveInventoryAvailabilitySummary)(String(inventoryAvailability._id), [...newSummary, summaryTotal]);
+        }
+        else {
+            await (0, inventory_availability_db_1.saveInventoryAvailabilitySummary)(String(inventoryAvailability._id), []);
+        }
+    }
+}
+exports.InventoryAvailabilityService = InventoryAvailabilityService;

package/services/inventory-availability.service.ts

@@ -0,0 +1,187 @@
+import Decimal from 'decimal.js';
+import _ from 'lodash';
+import mongoose from 'mongoose';
+
+import {
+  getInventoryAvailabilityByBBCDateId,
+  saveInventoryAvailabilitySummary,
+  setManualInputsToggle,
+} from '../db/inventory-availability.db';
+import { getBBCDateDoc } from '../db/bbcDates.db';
+import { BBCDateModel, IBBCDateDoc } from '../models/BBCDate.model';
+import { EInventoryAvailabilityResults } from '../enums/inventory-availability-results.enum';
+import {
+  IInventoryAvailability,
+  IInventoryAvailabilityDocument, IInventoryAvailabilityResults,
+  IInventoryAvailabilitySummary, InventoryAvailabilityModel,
+  InventoryAvailabilityPaginators,
+} from '../models/InventoryAvailability.model';
+
+import {
+  createInventoryAvailability,
+  getInventoryAvailabilityItems,
+} from '../db/inventory-availability';
+import { ManualEntryService } from './manual-entry.service';
+import { START_PAGINATORS } from './availability.service';
+
+export class InventoryAvailabilityService {
+
+  constructor(
+    private readonly manualEntryService: ManualEntryService,
+  ) {
+  }
+
+  async getLatestBBCFilters(excludedBBCDateId: string) {
+    const bbcDateDoc = await BBCDateModel.findById(excludedBBCDateId).lean();
+    if (!bbcDateDoc) {
+      return [];
+    }
+    const latestBBCDate = await BBCDateModel.aggregate<IBBCDateDoc>([
+      {
+        $match: {
+          '_id': { $ne: new mongoose.Types.ObjectId(excludedBBCDateId) },
+          'borrowerId': new mongoose.Types.ObjectId(bbcDateDoc.borrowerId),
+        },
+      }, {
+        $sort: {
+          'bbcDate': -1,
+        },
+      },
+    ]);
+    if (latestBBCDate.length === 0) {
+      return [];
+    }
+    for (const bbcDate of latestBBCDate) {
+      const availability = await this.getInventoryAvailabilityFilters(bbcDate._id.toString());
+      if (!!availability) {
+        return availability.filters;
+      }
+    }
+    return [];
+  }
+
+  async getInventoryAvailability(bbcDateId: string, paginators: InventoryAvailabilityPaginators) {
+    const availability = await this.getInventoryAvailabilityFilters(bbcDateId);
+    const { borrowerId } = await getBBCDateDoc(bbcDateId);
+    if (!availability) {
+      const lastFilters = await this.getLatestBBCFilters(bbcDateId);
+      const newAvailability: Partial<IInventoryAvailabilityDocument> = {
+        bbcDateId: new mongoose.Types.ObjectId(bbcDateId),
+        borrowerId: new mongoose.Types.ObjectId(borrowerId),
+        filters: lastFilters,
+        options: { maxAdvanceRatePriority: true },
+        useManualInputs: false,
+        results: {
+          [EInventoryAvailabilityResults.UNIQ_ITEMS]: {
+            items: [],
+            totalItems: 0,
+            paginatorOptions: paginators[EInventoryAvailabilityResults.UNIQ_ITEMS],
+          },
+          [EInventoryAvailabilityResults.NON_UNIQ_ITEMS]: {
+            items: [],
+            totalItems: 0,
+            paginatorOptions: paginators[EInventoryAvailabilityResults.NON_UNIQ_ITEMS],
+          },
+          [EInventoryAvailabilityResults.NOT_MATCHED_ITEMS]: {
+            items: [],
+            totalItems: 0,
+            paginatorOptions: paginators[EInventoryAvailabilityResults.NOT_MATCHED_ITEMS],
+          },
+        },
+        summary: [],
+      };
+      return newAvailability;
+    }
+    const items = await getInventoryAvailabilityItems(String(availability._id), paginators);
+    availability.results = (<IInventoryAvailabilityResults>{ ...availability.results, ...items });
+    return availability;
+  }
+
+  async getInventoryAvailabilityFilters(bbcDateId: string) {
+    return await getInventoryAvailabilityByBBCDateId(bbcDateId);
+  }
+
+  async updateInventoryAvailabilityFilters(inventoryAvailability: IInventoryAvailability) {
+    return await createInventoryAvailability(inventoryAvailability);
+  }
+
+  async getAllInventorySettings(bbcDateId: string = null, borrowerId: string) {
+    const availabilities = await InventoryAvailabilityModel.aggregate([
+      {
+        $match: {
+          $and: [
+            { 'borrowerId': new mongoose.Types.ObjectId(borrowerId) },
+            { 'bbcDateId': { '$ne': new mongoose.Types.ObjectId(bbcDateId) } },
+          ],
+        },
+      },
+    ]);
+    return availabilities.reduce((acc, availability) => {
+      const settings = _.pick(availability, ['filters', 'options']);
+      return { ...acc, [availability.bbcDateId.toString()]: settings };
+    }, {});
+  }
+
+  async checkCreateAvailability(bbcDateId: string) {
+    const inventoryAvailability = await getInventoryAvailabilityByBBCDateId(bbcDateId);
+    if (inventoryAvailability) {
+      return;
+    }
+    const newAvailability = await this.getInventoryAvailability(bbcDateId, START_PAGINATORS);
+    if (newAvailability) {
+      await createInventoryAvailability(newAvailability);
+    }
+  }
+
+  async toggleManualInventoryAvailability(bbcDateId: string, useManualInputs: boolean) {
+    await this.checkCreateAvailability(bbcDateId);
+    await setManualInputsToggle(bbcDateId, useManualInputs);
+    const inventoryAvailability = await getInventoryAvailabilityByBBCDateId(bbcDateId);
+    if (!inventoryAvailability) {
+      return;
+    }
+    if (useManualInputs) {
+      const manualRates = await this.manualEntryService.getInventoryManualEntry(bbcDateId);
+      const summaryTotal: IInventoryAvailabilitySummary = {
+        advanceRate: 0,
+        availability: 0,
+        inventoryName: 'TOTAL',
+        isGroup: false,
+        order: 1000,
+        totalQty: 0,
+        totalValue: 0,
+      };
+      const newSummary = manualRates.items.map((item, order) => {
+        return <IInventoryAvailabilitySummary>{
+          order,
+          isGroup: false,
+          inventoryName: item.inventoryName,
+          totalQty: item.totalQty,
+          totalValue: item.totalValue,
+          advanceRate: new Decimal(item.advanceRate).div(100).toDP(2).toNumber(),
+          availability: item.availability,
+        };
+      });
+
+      const updateSummaryTotal = (summaryTotal: IInventoryAvailabilitySummary, item: IInventoryAvailabilitySummary) => {
+        summaryTotal.availability += item.availability;
+        summaryTotal.totalQty += item.totalQty;
+        summaryTotal.totalValue += item.totalValue;
+        if (summaryTotal.totalValue) {
+          summaryTotal.advanceRate = summaryTotal.availability / summaryTotal.totalValue;
+        } else {
+          summaryTotal.advanceRate = 0;
+        }
+      };
+
+      newSummary.forEach((item) => updateSummaryTotal(summaryTotal, item));
+      summaryTotal.availability = new Decimal(summaryTotal.availability).toDP(2).toNumber();
+      summaryTotal.totalQty = new Decimal(summaryTotal.totalQty).toDP(2).toNumber();
+      summaryTotal.totalValue = new Decimal(summaryTotal.totalValue).toDP(2).toNumber();
+      summaryTotal.advanceRate = new Decimal(summaryTotal.advanceRate).toDP(2).toNumber();
+      await saveInventoryAvailabilitySummary(String(inventoryAvailability._id), [...newSummary, summaryTotal]);
+    } else {
+      await saveInventoryAvailabilitySummary(String(inventoryAvailability._id), []);
+    }
+  }
+}

package/services/inventory.service.d.ts

@@ -0,0 +1,118 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import mongoose from 'mongoose';
+import { IInventoryItem } from '../models/InventoryItem.model';
+import { IUploadedItems } from '../interfaces/collaterals.interface';
+import { CollateralsService } from './collaterals.service';
+export declare class InventoryService {
+    private readonly collateralsService;
+    constructor(collateralsService: CollateralsService);
+    updateInventorySKU({ bbcDate, borrowerId, items }: IUploadedItems<IInventoryItem>): Promise<({
+        skuDate: Date;
+        category: string;
+        sku: string;
+        qty: number;
+        value: number;
+        expiryDate: Date;
+        location: string;
+        unitCost: number;
+        skuDescription1: string;
+        skuDescription2: string;
+        skuDescription3: string;
+        detail1: string;
+        detail2: string;
+        detail3: string;
+        bbcSheetId: mongoose.Types.ObjectId;
+        order: number;
+    } | {
+        skuDate: string;
+        category: string;
+        sku: string;
+        qty: number;
+        value: number;
+        expiryDate: Date;
+        location: string;
+        unitCost: number;
+        skuDescription1: string;
+        skuDescription2: string;
+        skuDescription3: string;
+        detail1: string;
+        detail2: string;
+        detail3: string;
+        bbcSheetId: mongoose.Types.ObjectId;
+        order: number;
+    })[]>;
+    getBenford(borrowerId: string): Promise<any[] | {
+        _id: any;
+        bbcDates: any;
+        confirmed: any[];
+    }>;
+    getInventoryAgingPlot(borrowerId: string, rangeStart: any, rangeEnd: any): Promise<{
+        name: string;
+        data: number[];
+    }[]>;
+    getAllSkuValues(borrowerId: string, startDate: string, endDate: string): Promise<any[]>;
+    getFirstSeenNew(sheetIds: mongoose.Types.ObjectId[], sku: string): Promise<{
+        bbcDate: Date;
+    }[]>;
+    getInconsistentData(bbcDateId: string): Promise<{
+        SKU: string;
+        UNIT_COST: number;
+        CALCULATED_UNIT_COST: number;
+        DIFFERENCE: number;
+        QTY: number;
+        VALUE_CHANGE: number;
+    }[]>;
+    getUnitCostDifference(borrowerId: string): Promise<{
+        SKU: string;
+        CURRENT_UNIT_COST: number;
+        LOWEST_UNIT_COST: number;
+        LOWEST_UNIT_COST_DATE: string;
+        DIFFERENCE: number;
+        CURRENT_QTY: number;
+        VALUE_CHANGE: number;
+    }[]>;
+    getExposures(borrowerId: string, useCustomerGroup: boolean): Promise<{
+        allCategoryNames: any[];
+        formattedSeriesData: {
+            name: Date;
+            data: any[];
+        }[];
+    }>;
+    getInventoryTurn(borrowerId: string, startDate: string, endDate: string): Promise<{
+        tableByUnit: any[];
+        tableByValue: any[];
+    }>;
+    getInvoiceMovement(borrowerId: string, bbcDateId: string): Promise<{
+        reportAdditions: any[];
+        reportRemoved: any[];
+    }>;
+    getContras(borrowerId: string, startDate: string, endDate: string): Promise<any[]>;
+    getExtension(borrowerId: string, startDate: string, endDate: string): Promise<any[]>;
+    compareInventories(bbcDateId: string): Promise<{
+        addedInventories: any[];
+        removedInventories: any[];
+    }>;
+}