@zauru-sdk/utils 6.19.0 → 6.20.0

package/dist/esm/zauru/priceAdjustmentRules.utils.js

@@ -1,6 +1,7 @@
 import { handlePossibleAxiosErrors } from "@zauru-sdk/common";
 import { createWebAppTableRegister, getVariablesByName, getWebAppTableRegisters, updateWebAppTableRegister, } from "@zauru-sdk/services";
 const TABLE_VAR = "price_adjustment_rules_web_app_table_id";
+export const PRICE_ADJUSTMENT_REVERSAL_RULES_TABLE_VAR = "price_adjustment_reversal_rules_web_app_table_id";
 const DEFAULT_FILTERS = {
     itemMode: "all",
     itemIds: [],
@@ -44,6 +45,29 @@ export const updatePriceAdjustmentRule = (headers, session, id, body) => {
         return updateWebAppTableRegister(headers, tableId, Number(id), body);
     });
 };
+const getReversalTableId = async (headers, session) => {
+    const vars = await getVariablesByName(headers, session, [
+        PRICE_ADJUSTMENT_REVERSAL_RULES_TABLE_VAR,
+    ]);
+    return vars[PRICE_ADJUSTMENT_REVERSAL_RULES_TABLE_VAR];
+};
+export const filterActivePriceAdjustmentReversalRules = (rules) => (rules ?? []).filter((rule) => !rule.data?.fechaEliminacion && rule.data?.activa !== false);
+export const getPriceAdjustmentReversalRules = (headers, session) => handlePossibleAxiosErrors(async () => {
+    const tableId = await getReversalTableId(headers, session);
+    const response = await getWebAppTableRegisters(session, tableId);
+    if (response.error) {
+        throw new Error(`Ocurrió un error al consultar las reglas de reversión de precio: ${response.userMsg}`);
+    }
+    return response.data ?? [];
+});
+export const createPriceAdjustmentReversalRule = (headers, session, body) => handlePossibleAxiosErrors(async () => {
+    const tableId = await getReversalTableId(headers, session);
+    return createWebAppTableRegister(headers, tableId, body);
+});
+export const updatePriceAdjustmentReversalRule = (headers, session, id, body) => handlePossibleAxiosErrors(async () => {
+    const tableId = await getReversalTableId(headers, session);
+    return updateWebAppTableRegister(headers, tableId, Number(id), body);
+});
 export const normalizeComparableValue = (value) => String(value ?? "").replace(/\s+/g, " ").trim();
 export const formatReceptionTypeValue = (type) => [type?.Nombre, type?.Codigo]
     .map((part) => String(part ?? "").trim())
@@ -104,11 +128,15 @@ export const applyPriceAdjustmentRules = (basePrice, rules, ctx) => {
     let runningTotal = safeBase;
     const steps = [];
     const normalized = rules
-        .map((rule) => ("data" in rule ? rule.data : rule))
-        .filter((rule) => Boolean(rule))
-        .filter((rule) => !rule.fechaEliminacion && rule.activa !== false)
-        .sort((a, b) => (a.prioridad ?? 0) - (b.prioridad ?? 0));
-    for (const rule of normalized) {
+        .map((rule) => ({
+        rule: "data" in rule ? rule.data : rule,
+        ruleId: "data" in rule ? rule.id : undefined,
+    }))
+        .filter((entry) => Boolean(entry.rule));
+    const activeRules = normalized
+        .filter(({ rule }) => !rule.fechaEliminacion && rule.activa !== false)
+        .sort((a, b) => (a.rule.prioridad ?? 0) - (b.rule.prioridad ?? 0));
+    for (const { rule, ruleId } of activeRules) {
         if (!priceAdjustmentRuleMatches(rule, ctx)) {
             continue;
         }
@@ -125,6 +153,7 @@ export const applyPriceAdjustmentRules = (basePrice, rules, ctx) => {
         }
         runningTotal = roundMoney(runningTotal);
         steps.push({
+            ...(ruleId !== undefined ? { ruleId } : {}),
             ruleName: rule.nombre,
             operation: rule.operacion,
             valueType: rule.tipoValor,
@@ -142,3 +171,78 @@ export const applyPriceAdjustmentRules = (basePrice, rules, ctx) => {
     result.description = formatPriceAdjustmentDescription(result);
     return result;
 };
+const sameMoney = (left, right) => Math.abs(roundMoney(left, 2) - roundMoney(right, 2)) < 0.000001;
+export const buildPriceAdjustmentReversalPlan = ({ calculation, currentPrice, reversalRules, history, }) => {
+    const base = {
+        calculationId: calculation.calculationId,
+        detailId: calculation.detailId,
+        itemId: calculation.itemId,
+        previousPrice: roundMoney(currentPrice, 2),
+        finalPrice: roundMoney(currentPrice, 2),
+        penaltyAmount: 0,
+        matches: [],
+    };
+    if (!calculation.calculationId || calculation.detailId == null) {
+        return {
+            ...base,
+            status: "ineligible",
+            reason: "El cálculo no contiene calculationId y detailId.",
+        };
+    }
+    const activeRules = filterActivePriceAdjustmentReversalRules(reversalRules);
+    const reversalBySource = new Map(activeRules.map((entry) => [entry.data.sourceRuleId, entry]));
+    const applicable = calculation.steps.flatMap((step) => {
+        if (step.ruleId == null ||
+            step.operation !== "add" ||
+            step.appliedAmount <= 0) {
+            return [];
+        }
+        const reversal = reversalBySource.get(step.ruleId);
+        if (!reversal)
+            return [];
+        return [
+            {
+                sourceRuleId: step.ruleId,
+                sourceRuleName: step.ruleName,
+                reversalRuleId: reversal.id,
+                reversalRuleName: reversal.data.nombre,
+                appliedAmount: roundMoney(step.appliedAmount),
+            },
+        ];
+    });
+    if (applicable.length === 0) {
+        return {
+            ...base,
+            status: "ineligible",
+            reason: "Ningún paso del cálculo tiene una regla de reversión activa.",
+        };
+    }
+    const calculationHistory = (history ?? []).filter((entry) => entry.calculationId === calculation.calculationId &&
+        entry.detailId === calculation.detailId);
+    const alreadyAppliedSourceIds = new Set(calculationHistory.map((entry) => entry.sourceRuleId));
+    const pending = applicable.filter((match) => !alreadyAppliedSourceIds.has(match.sourceRuleId));
+    if (pending.length === 0) {
+        return {
+            ...base,
+            status: "already_applied",
+            reason: "Todas las reglas vinculadas ya fueron penalizadas.",
+        };
+    }
+    const expectedCurrentPrice = roundMoney(Number(calculation.finalPrice) +
+        calculationHistory.reduce((sum, entry) => sum + entry.amount, 0), 2);
+    if (!sameMoney(currentPrice, expectedCurrentPrice)) {
+        return {
+            ...base,
+            status: "price_changed",
+            reason: `El precio actual ${roundMoney(currentPrice, 2)} no coincide con el precio esperado ${expectedCurrentPrice}.`,
+        };
+    }
+    const penaltyAmount = roundMoney(-pending.reduce((sum, match) => sum + match.appliedAmount, 0));
+    return {
+        ...base,
+        status: "eligible",
+        finalPrice: roundMoney(currentPrice + penaltyAmount, 2),
+        penaltyAmount,
+        matches: pending,
+    };
+};

package/dist/zauru/priceAdjustmentRules.utils.d.ts

@@ -1,10 +1,15 @@
 import type { Session } from "@remix-run/node";
-import { AxiosUtilsResponse, PriceAdjustmentContext, PriceAdjustmentFilters, PriceAdjustmentResult, PriceAdjustmentRule, WebAppRowGraphQL, WebAppTableUpdateResponse } from "@zauru-sdk/types";
+import { AxiosUtilsResponse, PriceAdjustmentContext, PriceAdjustmentFilters, PriceAdjustmentResult, PriceAdjustmentRule, PriceAdjustmentReversalPlan, PriceAdjustmentReversalRule, PriceAdjustmentStep, CertificationPenaltyHistoryEntry, WebAppRowGraphQL, WebAppTableUpdateResponse } from "@zauru-sdk/types";
+export declare const PRICE_ADJUSTMENT_REVERSAL_RULES_TABLE_VAR = "price_adjustment_reversal_rules_web_app_table_id";
 export declare const defaultPriceAdjustmentFilters: () => PriceAdjustmentFilters;
 export declare const filterActivePriceAdjustmentRules: (rules?: WebAppRowGraphQL<PriceAdjustmentRule>[]) => WebAppRowGraphQL<PriceAdjustmentRule>[];
 export declare const getPriceAdjustmentRules: (headers: any, session: Session) => Promise<AxiosUtilsResponse<WebAppRowGraphQL<PriceAdjustmentRule>[]>>;
 export declare const createPriceAdjustmentRule: (headers: any, session: Session, body: PriceAdjustmentRule) => Promise<AxiosUtilsResponse<WebAppTableUpdateResponse>>;
 export declare const updatePriceAdjustmentRule: (headers: any, session: Session, id: string, body: Partial<PriceAdjustmentRule>) => Promise<AxiosUtilsResponse<WebAppTableUpdateResponse>>;
+export declare const filterActivePriceAdjustmentReversalRules: (rules?: WebAppRowGraphQL<PriceAdjustmentReversalRule>[]) => WebAppRowGraphQL<PriceAdjustmentReversalRule>[];
+export declare const getPriceAdjustmentReversalRules: (headers: any, session: Session) => Promise<AxiosUtilsResponse<WebAppRowGraphQL<PriceAdjustmentReversalRule>[]>>;
+export declare const createPriceAdjustmentReversalRule: (headers: any, session: Session, body: PriceAdjustmentReversalRule) => Promise<AxiosUtilsResponse<WebAppTableUpdateResponse>>;
+export declare const updatePriceAdjustmentReversalRule: (headers: any, session: Session, id: string | number, body: Partial<PriceAdjustmentReversalRule>) => Promise<AxiosUtilsResponse<WebAppTableUpdateResponse>>;
 export declare const normalizeComparableValue: (value: string | number | undefined | null) => string;
 export declare const formatReceptionTypeValue: (type?: {
     Nombre?: string;
@@ -13,3 +18,15 @@ export declare const formatReceptionTypeValue: (type?: {
 export declare const priceAdjustmentRuleMatches: (rule: PriceAdjustmentRule, ctx: PriceAdjustmentContext) => boolean;
 export declare const formatPriceAdjustmentDescription: (result: Pick<PriceAdjustmentResult, "basePrice" | "finalPrice" | "steps">, baseLabel?: string) => string;
 export declare const applyPriceAdjustmentRules: (basePrice: number, rules: Array<PriceAdjustmentRule | WebAppRowGraphQL<PriceAdjustmentRule>>, ctx: PriceAdjustmentContext) => PriceAdjustmentResult;
+export declare const buildPriceAdjustmentReversalPlan: ({ calculation, currentPrice, reversalRules, history, }: {
+    calculation: {
+        calculationId?: string;
+        detailId?: number;
+        itemId: number;
+        finalPrice: number;
+        steps: PriceAdjustmentStep[];
+    };
+    currentPrice: number;
+    reversalRules: WebAppRowGraphQL<PriceAdjustmentReversalRule>[];
+    history?: CertificationPenaltyHistoryEntry[];
+}) => PriceAdjustmentReversalPlan;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zauru-sdk/utils",
-  "version": "6.19.0",
+  "version": "6.20.0",
   "description": "Utilidades, parseo de request y demás para desarrollo de webapps de Zauru",
   "main": "./dist/esm/index.js",
   "module": "./dist/esm/index.js",
@@ -71,12 +71,12 @@
   "dependencies": {
     "@aws-sdk/client-cloudwatch-logs": "^3.1123.0",
     "@remix-run/node": "^2.8.1",
-    "@zauru-sdk/common": "^6.8.1",
+    "@zauru-sdk/common": "^6.8.3",
     "@zauru-sdk/config": "^6.0.0",
     "@zauru-sdk/graphql": "^6.8.0",
-    "@zauru-sdk/services": "^6.11.4",
-    "@zauru-sdk/types": "^6.19.0",
+    "@zauru-sdk/services": "^6.11.6",
+    "@zauru-sdk/types": "^6.21.0",
     "moment": "^2.30.1"
   },
-  "gitHead": "a5b35540efd2b3395e05ea0182c97d78f059c3c4"
+  "gitHead": "7d373b9f5c25ab0198e72590c661bc9eb17cf80f"
 }