gemcap-be-common 1.2.72 → 1.2.74

package/queries/inventory/turn.ts

@@ -0,0 +1,176 @@
+import Decimal from 'decimal.js';
+import dayjs from 'dayjs';
+
+import { getBBCDatesForPeriod } from '../../db/bbcDates.db';
+import { getBBCSheetsByType } from '../../db/bbcSheets.db';
+import { ECollaterals } from '../../enums/collaterals.enum';
+import { getCollateralDocsByBBC } from '../../db/collaterals.db';
+import { getAllUniqSKUInRangeNew } from '../../db/inventories';
+import { IInventoryItem } from '../../models/InventoryItem.model';
+import { IBBCDateDoc } from '../../models/BBCDate.model';
+import { TQueryParams } from '../../models/QueryResult.model';
+import { addHeaderToData } from '../../helpers/excel.helper';
+
+interface IGroupedCollaterals extends IBBCDateDoc {
+  items: IInventoryItem[];
+}
+
+export const getInventoryTurnFull = async (params: TQueryParams) => {
+  const { borrowerId, startDate, endDate } = params;
+  const {
+    tableByUnit,
+    tableByValue,
+  } = await getInventoryTurn(borrowerId.toString(), startDate.toISOString(), endDate.toISOString());
+  const headerByUnit = getInventoryTurnHeader('byUnit');
+  const headerByValue = getInventoryTurnHeader('byValue');
+
+  const tableByUnitFull = addHeaderToData(headerByUnit, tableByUnit);
+  const tableByValueFull = addHeaderToData(headerByValue, tableByValue);
+
+  return {
+    'by unit': tableByUnitFull, 'by value': tableByValueFull,
+  };
+};
+
+export const getInventoryTurn = async (borrowerId: string, startDate: string, endDate: string) => {
+  const bbcDates = await getBBCDatesForPeriod(borrowerId, new Date(startDate), new Date(endDate));
+  const bbcIds = bbcDates.map((bbc) => bbc._id.toString());
+  const bbcSheets = await getBBCSheetsByType(bbcIds, ECollaterals.INVENTORY);
+  const skuGroup = (await getAllUniqSKUInRangeNew(bbcSheets.map((bbcSheet) => bbcSheet._id.toString()))).pop();
+  const BBCs: IGroupedCollaterals[] = await getCollateralDocsByBBC(bbcIds, ECollaterals.INVENTORY);
+  return getDifference(skuGroup ? skuGroup.skus.sort() : [], BBCs);
+};
+
+const getDifference = (uniqSKUs: string[], BBCs: IGroupedCollaterals[]) => {
+  if (uniqSKUs) {
+    const groupedBbc = uniqSKUs.map((sku) => {
+      let minUnitCost = 0;
+      const totalSum = BBCs.map((bbc) => {
+        const skuItems = bbc.items.filter((item) => item.sku === sku);
+        const unitCosts = skuItems.map((item) => item.qty === 0 ? 0 : new Decimal(item.value).div(item.qty).toNumber());
+        if (unitCosts.length) {
+          minUnitCost = Math.min(...unitCosts);
+        }
+        const sum = skuItems.reduce((acc, item) => new Decimal(acc).add(item.qty).toNumber(), 0);
+        return { bbc: bbc.bbcDate, sum };
+      });
+      return { sku, totalSum, minUnitCost };
+    });
+    const groupedBbcWithDifferences = groupedBbc.map((group) => {
+      const differences = [];
+      group.totalSum.forEach((sumGroup, index) => {
+        if (index > 0) {
+          const firstDate = dayjs(group.totalSum[index - 1].bbc);
+          const lastDate = dayjs(sumGroup.bbc);
+          const diffDays = lastDate.diff(firstDate, 'day');
+          const diff = new Decimal(group.totalSum[index - 1].sum).sub(sumGroup.sum).toNumber();
+          const diffPerDay = diffDays > 0 ? new Decimal(diff).div(diffDays).toNumber() : 0;
+          differences.push({
+            bbc: sumGroup.bbc,
+            diff,
+            diffDays,
+            decreasePerDay: diffPerDay > 0 ? diffPerDay : 0,
+            increasePerDay: diffPerDay < 0 ? diffPerDay : 0,
+          });
+        }
+      });
+      return { ...group, differences };
+    });
+    const tableByUnit = [];
+    groupedBbcWithDifferences.forEach((group) => {
+      const totalDifference = group.differences.reduce((acc, group) => {
+        if (group.diff < 0) {
+          const diff = new Decimal(acc.increasesOverPeriod).add(group.diff).toNumber();
+          return { ...acc, increasesOverPeriod: diff };
+        } else {
+          const diff = new Decimal(acc.decreasesOverPeriod).add(Math.abs(group.diff)).toNumber();
+          return { ...acc, decreasesOverPeriod: diff };
+        }
+      }, { increasesOverPeriod: 0, decreasesOverPeriod: 0 });
+      const { increasesOverPeriod, decreasesOverPeriod } = totalDifference;
+      const current = group.totalSum[group.totalSum.length - 1].sum;
+      const firstDate = dayjs(group.totalSum[0].bbc);
+      const lastDate = dayjs(group.totalSum[group.totalSum.length - 1].bbc);
+      const dayInRange = lastDate.diff(firstDate, 'day');
+      const averageIncreasesPerDay = new Decimal(increasesOverPeriod).div(dayInRange).toNumber();
+      const averageDecreasesPerDay = new Decimal(decreasesOverPeriod).div(dayInRange).toNumber();
+      // const increaseDiffs = group.differences.filter((diff) => diff.increasePerDay < 0);
+      // const decreaseDiffs = group.differences.filter((diff) => diff.decreasePerDay > 0);
+      // const averageIncreasePerDay_test = increaseDiffs.length > 0
+      //   ? new Decimal(increaseDiffs.reduce((acc, diff) => new Decimal(diff.increasePerDay).add(acc).toNumber(), 0)).div(decreaseDiffs.length).toNumber()
+      //   : 0;
+      // const averageDecreasesPerDay_test = decreaseDiffs.length > 0
+      //   ? new Decimal(decreaseDiffs.reduce((acc, diff) => new Decimal(diff.decreasePerDay).add(acc).toNumber(), 0)).div(decreaseDiffs.length).toNumber()
+      //   : 0;
+      const daysToClear = averageDecreasesPerDay === 0
+        ? 0
+        : new Decimal(current).div(averageDecreasesPerDay).toDP().toNumber();
+      const ranking = averageDecreasesPerDay === 0
+        ? Math.round(averageIncreasesPerDay)
+        : new Decimal(averageIncreasesPerDay).div(averageDecreasesPerDay).toDP().toNumber();
+      tableByUnit.push({
+        sku: group.sku,
+        current,
+        minUnitCost: group.minUnitCost,
+        increasesOverPeriod,
+        decreasesOverPeriod,
+        averageIncreasesPerDay,
+        averageDecreasesPerDay,
+        daysToClear,
+        ranking,
+      });
+    });
+    tableByUnit.sort((a, b) => a.ranking > b.ranking ? -1 : 0);
+    const tableByValue = [];
+    tableByUnit.forEach((unit) => {
+      const minUnitCost = unit.minUnitCost;
+      const current = new Decimal(unit.current).mul(minUnitCost).toNumber();
+      const increasesOverPeriod = new Decimal(unit.increasesOverPeriod).mul(minUnitCost).toNumber();
+      const decreasesOverPeriod = new Decimal(unit.decreasesOverPeriod).mul(minUnitCost).toNumber();
+      const averageIncreasesPerDay = new Decimal(unit.averageIncreasesPerDay).mul(minUnitCost).toNumber();
+      const averageDecreasesPerDay = new Decimal(unit.averageDecreasesPerDay).mul(minUnitCost).toNumber();
+      const daysToClear = Math.round(new Decimal(unit.daysToClear).mul(minUnitCost).toNumber());
+      const ranking = Math.round(new Decimal(unit.ranking).mul(minUnitCost).toNumber());
+      tableByValue.push({
+        sku: unit.sku,
+        minUnitCost,
+        current,
+        increasesOverPeriod,
+        decreasesOverPeriod,
+        averageIncreasesPerDay,
+        averageDecreasesPerDay,
+        daysToClear,
+        ranking,
+      });
+    });
+    return { tableByUnit, tableByValue };
+  }
+  return { tableByUnit: [], tableByValue: [] };
+};
+
+const getInventoryTurnHeader = (type: 'byUnit' | 'byValue') => {
+  const headerMap = {
+    'byUnit': {
+      sku: 'SKU',
+      current: 'Current number of units',
+      increasesOverPeriod: 'Increases in units over period',
+      decreasesOverPeriod: 'Decreases in units over period',
+      averageIncreasesPerDay: 'Average increases in units per day',
+      averageDecreasesPerDay: 'Average decreases in units per day',
+      daysToClear: 'Days to clear',
+      ranking: 'Ranking',
+    },
+    'byValue': {
+      sku: 'SKU',
+      current: 'Current value',
+      minUnitCost: 'Min unit cost',
+      increasesOverPeriod: 'Increases over in value period',
+      decreasesOverPeriod: 'Decreases over in value period',
+      averageIncreasesPerDay: 'Average value increases per day',
+      averageDecreasesPerDay: 'Average value decreases per day',
+      daysToClear: 'Days to clear',
+      ranking: 'Ranking',
+    },
+  };
+  return headerMap[type];
+};

package/queries/inventory/unit-cost-difference.d.ts

@@ -1,4 +1,5 @@
 import { TQueryParams } from '../../models/QueryResult.model';
+export declare const getUnitCostDifferenceFull: (params: TQueryParams) => Promise<{}[]>;
 export declare const getUnitCostDifference: (params: TQueryParams) => Promise<{
     SKU: string;
     CURRENT_UNIT_COST: number;
@@ -8,12 +9,3 @@ export declare const getUnitCostDifference: (params: TQueryParams) => Promise<{
     CURRENT_QTY: number;
     VALUE_CHANGE: number;
 }[]>;
-export declare const getUnitCostDifferenceHeader: () => {
-    SKU: string;
-    CURRENT_QTY: string;
-    CURRENT_UNIT_COST: string;
-    LOWEST_UNIT_COST: string;
-    LOWEST_UNIT_COST_DATE: string;
-    DIFFERENCE: string;
-    VALUE_CHANGE: string;
-};

package/queries/inventory/unit-cost-difference.js

@@ -3,12 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUnitCostDifferenceHeader = exports.getUnitCostDifference = void 0;
+exports.getUnitCostDifference = exports.getUnitCostDifferenceFull = void 0;
 const mongoose_1 = __importDefault(require("mongoose"));
 const decimal_js_1 = __importDefault(require("decimal.js"));
 const collaterals_db_1 = require("../../db/collaterals.db");
 const collaterals_enum_1 = require("../../enums/collaterals.enum");
 const inventories_1 = require("../../db/inventories");
+const excel_helper_1 = require("../../helpers/excel.helper");
+const getUnitCostDifferenceFull = async (params) => {
+    const data = await (0, exports.getUnitCostDifference)(params);
+    const header = getUnitCostDifferenceHeader();
+    return (0, excel_helper_1.addHeaderToData)(header, data);
+};
+exports.getUnitCostDifferenceFull = getUnitCostDifferenceFull;
 const getUnitCostDifference = async (params) => {
     const { borrowerId } = params;
     const bbcGroups = await (0, collaterals_db_1.findCollateralsWithSheets)(borrowerId.toString(), [collaterals_enum_1.ECollaterals.INVENTORY]);
@@ -42,4 +49,3 @@ const getUnitCostDifferenceHeader = () => {
         VALUE_CHANGE: 'Value change',
     };
 };
-exports.getUnitCostDifferenceHeader = getUnitCostDifferenceHeader;

package/queries/inventory/unit-cost-difference.ts

@@ -5,6 +5,13 @@ import { findCollateralsWithSheets } from '../../db/collaterals.db';
 import { ECollaterals } from '../../enums/collaterals.enum';
 import { getSKUUnitCostForAllDates } from '../../db/inventories';
 import { TQueryParams } from '../../models/QueryResult.model';
+import { addHeaderToData } from '../../helpers/excel.helper';
+
+export const getUnitCostDifferenceFull = async (params: TQueryParams) => {
+  const data = await getUnitCostDifference(params);
+  const header = getUnitCostDifferenceHeader();
+  return addHeaderToData(header, data);
+};
 
 export const getUnitCostDifference = async (params: TQueryParams) => {
   const { borrowerId } = params;
@@ -28,7 +35,7 @@ export const getUnitCostDifference = async (params: TQueryParams) => {
     .sort((a, b) => a.VALUE_CHANGE > b.VALUE_CHANGE ? -1 : 0);
 };
 
-export const getUnitCostDifferenceHeader = () => {
+const getUnitCostDifferenceHeader = () => {
   return {
     SKU: 'SKU',
     CURRENT_QTY: 'qty',