@pisell/pisellos 2.3.30 → 2.3.31

package/lib/model/strategy/adapter/dataVariant/evaluator.js

@@ -0,0 +1,583 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/model/strategy/adapter/dataVariant/evaluator.ts
+var evaluator_exports = {};
+__export(evaluator_exports, {
+  DataVariantEvaluator: () => DataVariantEvaluator,
+  default: () => evaluator_default
+});
+module.exports = __toCommonJS(evaluator_exports);
+var import_engine = require("../../engine");
+var import_getDateIsInSchedule = require("../../../../modules/Schedule/getDateIsInSchedule");
+var import_adapter = require("./adapter");
+var DataVariantEvaluator = class {
+  constructor() {
+    this.strategyConfigs = [];
+    this.adapter = new import_adapter.DataVariantAdapter();
+  }
+  /**
+   * 设置策略配置列表，仅保留 metadata.type === 'data_variant' 的策略。
+   */
+  setStrategyConfigs(configs) {
+    this.strategyConfigs = this.normalizeStrategyConfigs(configs);
+  }
+  getStrategyConfigs() {
+    return this.strategyConfigs;
+  }
+  /**
+   * 批量解析商品 Data Variant。
+   *
+   * 先执行全局预计算，再只针对商品自身 data_variants 引用到的规则做商品级判断。
+   */
+  resolveProducts(businessData) {
+    const strategyConfigs = businessData.strategyConfigs ? this.normalizeStrategyConfigs(businessData.strategyConfigs) : this.strategyConfigs;
+    const menuScopeMap = this.buildMenuScopeMap(businessData.menuList || []);
+    const scheduleTimePoints = this.buildScheduleTimePoints(
+      strategyConfigs,
+      businessData.scheduleList || []
+    );
+    const { globalEffectiveRuleMap, rawResults } = this.buildGlobalEffectiveRuleMap(
+      strategyConfigs,
+      businessData,
+      menuScopeMap
+    );
+    const products = businessData.products.map((product) => {
+      const resolvedProduct = this.resolveProduct(
+        product,
+        businessData,
+        globalEffectiveRuleMap,
+        menuScopeMap
+      );
+      return this.resolveProductBundleItems(
+        resolvedProduct,
+        businessData,
+        globalEffectiveRuleMap,
+        menuScopeMap
+      );
+    });
+    return {
+      products,
+      globalEffectiveRuleMap,
+      menuScopeMap,
+      scheduleTimePoints,
+      rawResults
+    };
+  }
+  /**
+   * 根据 operator/field 判断条件是否依赖当前商品。
+   */
+  getConditionScope(rule) {
+    if (rule.operator === "schedule_match")
+      return "global";
+    if (rule.operator === "menu_match")
+      return "product";
+    if (rule.operator === "product_match")
+      return "product";
+    if (rule.field === "product" || rule.field === "productIdAndVariantId") {
+      return "product";
+    }
+    return "global";
+  }
+  /**
+   * 将餐牌 partyroom_package 预构建为 Map/Set 索引。
+   */
+  buildMenuScopeMap(menuList) {
+    const map = /* @__PURE__ */ new Map();
+    for (const menu of menuList) {
+      if ((menu == null ? void 0 : menu.status) && menu.status !== "valid")
+        continue;
+      const menuId = this.toNumber(menu == null ? void 0 : menu.form_record_id);
+      if (!menuId)
+        continue;
+      const scope = {
+        isAllProducts: false,
+        collectionIds: /* @__PURE__ */ new Set(),
+        productKeys: /* @__PURE__ */ new Set(),
+        productAllVariantIds: /* @__PURE__ */ new Set()
+      };
+      const packageConfig = menu.partyroom_package;
+      const products = Array.isArray(packageConfig == null ? void 0 : packageConfig.products) ? packageConfig.products : [];
+      if ((packageConfig == null ? void 0 : packageConfig.type) === "product_all") {
+        scope.isAllProducts = true;
+      } else if ((packageConfig == null ? void 0 : packageConfig.type) === "product_collection") {
+        for (const item of products) {
+          const collectionId = this.toNumber(item.product_collection_id);
+          if (collectionId) {
+            scope.collectionIds.add(collectionId);
+          }
+        }
+      } else if ((packageConfig == null ? void 0 : packageConfig.type) === "products") {
+        for (const item of products) {
+          const productId = this.toNumber(item.product_id);
+          const variantId = this.toNumber(item.product_variant_id);
+          if (!productId)
+            continue;
+          if (variantId === 0) {
+            scope.productAllVariantIds.add(productId);
+          } else {
+            scope.productKeys.add(this.buildProductKey(productId, variantId));
+          }
+        }
+      }
+      map.set(menuId, scope);
+    }
+    return map;
+  }
+  /**
+   * 从当前策略中所有 schedule_match.value 绑定的 schedule_id 提取时间点。
+   *
+   * 这里不依赖餐牌，只读取策略配置和调用方传入的 scheduleList。
+   */
+  buildScheduleTimePoints(strategyConfigs, scheduleList) {
+    const scheduleIds = this.collectScheduleIdsFromStrategies(strategyConfigs);
+    if (!scheduleIds.length || !scheduleList.length)
+      return [];
+    const scheduleIdSet = new Set(scheduleIds);
+    const matchedSchedules = scheduleList.filter(
+      (schedule) => scheduleIdSet.has(Number(schedule.id))
+    );
+    return this.extractTimePointsFromSchedules(matchedSchedules);
+  }
+  buildGlobalEffectiveRuleMap(strategyConfigs, businessData, menuScopeMap) {
+    const globalEffectiveRuleMap = /* @__PURE__ */ new Map();
+    const rawResults = [];
+    const engine = this.createEngine(businessData, menuScopeMap);
+    const context = this.adapter.prepareGlobalContext(businessData);
+    for (const config of strategyConfigs) {
+      if (!this.isStrategyActive(config))
+        continue;
+      const { globalConfig, productRules } = this.splitStrategyConfig(config);
+      const result = engine.evaluate(globalConfig, context);
+      rawResults.push(result);
+      if (!result.applicable)
+        continue;
+      globalEffectiveRuleMap.set(String(config.metadata.id), {
+        ruleId: String(config.metadata.id),
+        priority: this.getStrategyPriority(config),
+        strategyConfig: config,
+        productRules,
+        globalResult: result
+      });
+    }
+    return { globalEffectiveRuleMap, rawResults };
+  }
+  resolveProduct(product, businessData, globalEffectiveRuleMap, menuScopeMap) {
+    const dataVariants = this.getProductDataVariants(product);
+    if (!dataVariants.length)
+      return product;
+    const matchedVariants = [];
+    for (const variant of dataVariants) {
+      const rule = globalEffectiveRuleMap.get(
+        String(variant.data_variant_rule_id)
+      );
+      if (!rule)
+        continue;
+      if (!this.evaluateProductRules(rule, product, businessData, menuScopeMap)) {
+        continue;
+      }
+      matchedVariants.push({
+        ruleId: rule.ruleId,
+        priority: rule.priority,
+        data: variant.data || {},
+        variant
+      });
+    }
+    if (!matchedVariants.length)
+      return product;
+    return this.mergeMatchedVariants(product, matchedVariants);
+  }
+  /**
+   * 解析套餐子商品上的 Data Variant 覆盖。
+   *
+   * bundle_item 以 bundle_product_id / bundle_variant_id 作为商品身份参与 product_match 等条件判断。
+   */
+  resolveProductBundleItems(product, businessData, globalEffectiveRuleMap, menuScopeMap) {
+    const bundleGroups = product.bundle_group;
+    if (!Array.isArray(bundleGroups) || bundleGroups.length === 0) {
+      return product;
+    }
+    const resolvedGroups = bundleGroups.map((group) => {
+      const bundleItems = group == null ? void 0 : group.bundle_item;
+      if (!Array.isArray(bundleItems) || bundleItems.length === 0) {
+        return group;
+      }
+      return {
+        ...group,
+        bundle_item: bundleItems.map(
+          (item) => this.resolveBundleItem(
+            item,
+            businessData,
+            globalEffectiveRuleMap,
+            menuScopeMap
+          )
+        )
+      };
+    });
+    return {
+      ...product,
+      bundle_group: resolvedGroups
+    };
+  }
+  /**
+   * 将 bundle_item 转为 DataVariantProduct 并评估 data_variants。
+   */
+  resolveBundleItem(item, businessData, globalEffectiveRuleMap, menuScopeMap) {
+    const bundleProduct = this.toBundleItemDataVariantProduct(item);
+    if (!this.getProductDataVariants(bundleProduct).length) {
+      return item;
+    }
+    const resolvedItem = this.resolveProduct(
+      bundleProduct,
+      businessData,
+      globalEffectiveRuleMap,
+      menuScopeMap
+    );
+    return this.mergeBundleItemResolvedData(item, resolvedItem);
+  }
+  /**
+   * bundle_item 的商品身份映射：bundle_product_id + bundle_variant_id。
+   */
+  toBundleItemDataVariantProduct(item) {
+    const productId = item.bundle_product_id ?? item.product_id;
+    const variantId = item.bundle_variant_id ?? item.variant_id ?? item.product_variant_id ?? 0;
+    return {
+      id: productId,
+      product_id: productId,
+      product_variant_id: variantId,
+      variant_id: variantId,
+      collection: item.collection,
+      data_variants: item.data_variants
+    };
+  }
+  /**
+   * 仅回写命中的字段，避免污染 bundle_item 的结构字段。
+   */
+  mergeBundleItemResolvedData(originalItem, resolvedItem) {
+    var _a;
+    const appliedInfo = resolvedItem._dataVariant;
+    if (!((_a = appliedInfo == null ? void 0 : appliedInfo.appliedFields) == null ? void 0 : _a.length)) {
+      return originalItem;
+    }
+    const result = { ...originalItem };
+    for (const field of appliedInfo.appliedFields) {
+      if (resolvedItem[field] !== void 0) {
+        result[field] = resolvedItem[field];
+      }
+    }
+    result._dataVariant = appliedInfo;
+    return result;
+  }
+  evaluateProductRules(rule, product, businessData, menuScopeMap) {
+    if (!rule.productRules.length)
+      return true;
+    const engine = this.createEngine(businessData, menuScopeMap);
+    const context = this.adapter.prepareProductContext(businessData, product);
+    const productOnlyConfig = {
+      ...rule.strategyConfig,
+      conditions: {
+        operator: "and",
+        rules: rule.productRules,
+        actionIds: rule.strategyConfig.conditions.actionIds || []
+      }
+    };
+    return engine.evaluate(productOnlyConfig, context).applicable;
+  }
+  /**
+   * 拆分策略条件。
+   *
+   * 当前 MVP 支持顶层 and 原子条件拆分；复杂条件保守地放到商品级完整判断。
+   */
+  splitStrategyConfig(config) {
+    const conditions = config.conditions;
+    const globalRules = [];
+    const productRules = [];
+    if (conditions.operator !== "and") {
+      return {
+        globalConfig: {
+          ...config,
+          conditions: this.createAlwaysTrueConditions(conditions.actionIds)
+        },
+        productRules: this.flattenConditionRules(conditions)
+      };
+    }
+    for (const rule of conditions.rules) {
+      if (this.isConditionGroup(rule)) {
+        productRules.push(...this.flattenConditionRules(rule));
+        continue;
+      }
+      if (this.getConditionScope(rule) === "product") {
+        productRules.push(rule);
+      } else {
+        globalRules.push(rule);
+      }
+    }
+    return {
+      globalConfig: {
+        ...config,
+        conditions: {
+          operator: "and",
+          rules: globalRules,
+          actionIds: conditions.actionIds || []
+        }
+      },
+      productRules
+    };
+  }
+  createEngine(businessData, menuScopeMap) {
+    const operatorHandlers = {
+      schedule_match: (fieldValue, compareValue) => this.evaluateScheduleMatch(
+        fieldValue,
+        compareValue,
+        businessData.scheduleList || []
+      ),
+      menu_match: (fieldValue, compareValue) => this.evaluateMenuMatch(fieldValue, compareValue, menuScopeMap),
+      array_intersects: (fieldValue, compareValue) => this.evaluateArrayIntersects(fieldValue, compareValue)
+    };
+    return new import_engine.StrategyEngine({
+      debug: false,
+      enableTrace: false,
+      operatorHandlers
+    });
+  }
+  evaluateScheduleMatch(fieldValue, compareValue, scheduleList) {
+    const scheduleDateTime = String(fieldValue || "");
+    const scheduleIds = this.normalizeNumberArray(compareValue);
+    if (!scheduleIds.length)
+      return true;
+    if (!scheduleDateTime || !(scheduleList == null ? void 0 : scheduleList.length))
+      return false;
+    const matchedSchedules = scheduleList.filter(
+      (schedule) => scheduleIds.includes(Number(schedule.id))
+    );
+    return (0, import_getDateIsInSchedule.getDateIsInSchedule)(scheduleDateTime, matchedSchedules);
+  }
+  evaluateMenuMatch(fieldValue, compareValue, menuScopeMap) {
+    const menuIds = this.normalizeNumberArray(compareValue);
+    if (!menuIds.length)
+      return true;
+    for (const menuId of menuIds) {
+      const scope = menuScopeMap.get(menuId);
+      if (!scope)
+        continue;
+      if (this.isProductInMenuScope(fieldValue, scope))
+        return true;
+    }
+    return false;
+  }
+  evaluateArrayIntersects(fieldValue, compareValue) {
+    const fieldValues = this.normalizeComparableArray(fieldValue);
+    const compareValues = this.normalizeComparableArray(compareValue);
+    if (!fieldValues.length || !compareValues.length)
+      return false;
+    const compareSet = new Set(compareValues);
+    return fieldValues.some((item) => compareSet.has(item));
+  }
+  collectScheduleIdsFromStrategies(strategyConfigs) {
+    const scheduleIds = /* @__PURE__ */ new Set();
+    for (const config of strategyConfigs) {
+      if (!this.isStrategyActive(config))
+        continue;
+      const rules = this.flattenConditionRules(config.conditions);
+      for (const rule of rules) {
+        if (rule.operator !== "schedule_match")
+          continue;
+        for (const scheduleId of this.normalizeNumberArray(rule.value)) {
+          scheduleIds.add(scheduleId);
+        }
+      }
+    }
+    return Array.from(scheduleIds);
+  }
+  extractTimePointsFromSchedules(schedules) {
+    const timePoints = /* @__PURE__ */ new Set();
+    for (const schedule of schedules) {
+      switch (schedule.type) {
+        case "standard": {
+          this.addDateTimePoint(timePoints, schedule.start_time);
+          this.addDateTimePoint(timePoints, schedule.end_time);
+          break;
+        }
+        case "time-slots": {
+          const slots = Array.isArray(schedule.time_slot) ? schedule.time_slot : [];
+          for (const slot of slots) {
+            this.addRawTimePoint(timePoints, slot.start_time);
+            this.addRawTimePoint(timePoints, slot.end_time);
+          }
+          break;
+        }
+        case "designation": {
+          const designations = Array.isArray(schedule.designation) ? schedule.designation : schedule.designation ? [schedule.designation] : [];
+          for (const designation of designations) {
+            this.addRawTimePoint(timePoints, designation.start_time);
+            this.addRawTimePoint(timePoints, designation.end_time);
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    return Array.from(timePoints).sort(
+      (a, b) => this.timeToMinutes(a) - this.timeToMinutes(b)
+    );
+  }
+  addDateTimePoint(points, value) {
+    const time = this.extractTimeFromDateTime(value);
+    if (time)
+      points.add(time);
+  }
+  addRawTimePoint(points, value) {
+    const time = this.normalizeTime(value);
+    if (time)
+      points.add(time);
+  }
+  extractTimeFromDateTime(value) {
+    if (!value)
+      return null;
+    const match = value.match(/(\d{1,2}):(\d{2})/);
+    if (!match)
+      return null;
+    return `${match[1].padStart(2, "0")}:${match[2]}`;
+  }
+  normalizeTime(value) {
+    if (!value)
+      return null;
+    const match = value.match(/^(\d{1,2}):(\d{2})/);
+    if (!match)
+      return null;
+    return `${match[1].padStart(2, "0")}:${match[2]}`;
+  }
+  timeToMinutes(value) {
+    const [hour, minute] = value.split(":").map((item) => Number(item));
+    if (!Number.isFinite(hour) || !Number.isFinite(minute))
+      return 0;
+    return hour * 60 + minute;
+  }
+  isProductInMenuScope(product, scope) {
+    if (scope.isAllProducts)
+      return true;
+    if (!product || typeof product !== "object")
+      return false;
+    const productId = this.toNumber(product.id ?? product.product_id);
+    const variantId = this.toNumber(product.product_variant_id);
+    const productKey = this.buildProductKey(productId, variantId);
+    const collectionIds = Array.isArray(product.collection_ids) ? product.collection_ids.map((id) => this.toNumber(id)) : [];
+    return collectionIds.some((id) => scope.collectionIds.has(id)) || scope.productKeys.has(productKey) || scope.productAllVariantIds.has(productId);
+  }
+  mergeMatchedVariants(product, matchedVariants) {
+    const original = { ...product };
+    const sortedVariants = [...matchedVariants].sort((a, b) => {
+      if (a.priority !== b.priority)
+        return a.priority - b.priority;
+      return Number(a.ruleId) - Number(b.ruleId);
+    });
+    const result = { ...product };
+    const appliedRuleIds = [];
+    const appliedFields = /* @__PURE__ */ new Set();
+    for (const matched of sortedVariants) {
+      for (const [key, value] of Object.entries(matched.data)) {
+        if (value === void 0)
+          continue;
+        result[key] = value;
+        appliedFields.add(key);
+      }
+      appliedRuleIds.push(matched.ruleId);
+    }
+    result._dataVariant = {
+      appliedRuleIds,
+      appliedFields: Array.from(appliedFields),
+      original
+    };
+    return result;
+  }
+  getProductDataVariants(product) {
+    return Array.isArray(product.data_variants) ? product.data_variants : [];
+  }
+  normalizeStrategyConfigs(configs) {
+    return configs.filter(
+      (config) => {
+        var _a;
+        return ((_a = config == null ? void 0 : config.metadata) == null ? void 0 : _a.type) === "data_variant";
+      }
+    );
+  }
+  isStrategyActive(config) {
+    var _a;
+    const status = (_a = config.metadata.custom) == null ? void 0 : _a.status;
+    return !status || status === "active";
+  }
+  getStrategyPriority(config) {
+    var _a;
+    const priority = Number((_a = config.metadata.custom) == null ? void 0 : _a.priority);
+    if (Number.isFinite(priority))
+      return priority;
+    return Math.max(
+      0,
+      ...config.actions.map((action) => Number(action.priority || 0))
+    );
+  }
+  createAlwaysTrueConditions(actionIds) {
+    return {
+      operator: "and",
+      rules: [],
+      actionIds
+    };
+  }
+  flattenConditionRules(group) {
+    const rules = [];
+    for (const rule of group.rules) {
+      if (this.isConditionGroup(rule)) {
+        rules.push(...this.flattenConditionRules(rule));
+      } else {
+        rules.push(rule);
+      }
+    }
+    return rules;
+  }
+  isConditionGroup(rule) {
+    return "rules" in rule && Array.isArray(rule.rules);
+  }
+  normalizeNumberArray(value) {
+    if (!Array.isArray(value))
+      return [];
+    return value.map((item) => this.toNumber(item)).filter((item) => item > 0);
+  }
+  normalizeComparableArray(value) {
+    const list = Array.isArray(value) ? value : value == null || value === "" ? [] : [value];
+    const normalized = list.map((item) => {
+      if (item == null || item === "")
+        return "";
+      const parsed = Number(item);
+      return Number.isFinite(parsed) ? String(parsed) : String(item).trim();
+    }).filter(Boolean);
+    return Array.from(new Set(normalized));
+  }
+  buildProductKey(productId, variantId) {
+    return `${productId}:${variantId}`;
+  }
+  toNumber(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+};
+var evaluator_default = DataVariantEvaluator;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataVariantEvaluator
+});

package/lib/model/strategy/adapter/dataVariant/examples.d.ts

@@ -0,0 +1,39 @@
+import type { StrategyConfig } from '../../type';
+import type { ScheduleItem } from '../../../../modules/Schedule/types';
+import type { DataVariantItem, DataVariantMenu, DataVariantProduct, DataVariantRuleMetadata } from './type';
+/**
+ * 构造示例用 data_variant 记录，字段结构与后端 /product/query 返回一致。
+ */
+export declare function createExampleDataVariant(ruleId: number | string, data: Record<string, any>, overrides?: Partial<Omit<DataVariantItem, 'data_variant_rule_id' | 'data'>>): DataVariantItem;
+/**
+ * 晚场餐牌价：命中日程 + 餐牌商品范围后覆盖 price / stock。
+ */
+export declare const EVENING_MENU_PRICE_STRATEGY: StrategyConfig<DataVariantRuleMetadata>;
+/**
+ * VIP 商品价：演示 product_match 与更高优先级字段覆盖。
+ */
+export declare const VIP_PRODUCT_PRICE_STRATEGY: StrategyConfig<DataVariantRuleMetadata>;
+/**
+ * 客户/渠道/业务范围价：演示 customer_id、channel、business_code 的 in 条件。
+ */
+export declare const CUSTOMER_SCOPE_PRICE_STRATEGY: StrategyConfig<DataVariantRuleMetadata>;
+/**
+ * 示例日程：2026-06-26 17:00 ~ 20:00 生效。
+ */
+export declare const DATA_VARIANT_EXAMPLE_SCHEDULES: ScheduleItem[];
+/**
+ * 示例餐牌：product_collection = 128 的商品均属于餐牌。
+ */
+export declare const DATA_VARIANT_EXAMPLE_MENUS: DataVariantMenu[];
+/**
+ * 示例商品：同时带两条 Data Variant 覆盖数据。
+ */
+export declare const DATA_VARIANT_EXAMPLE_PRODUCTS: DataVariantProduct[];
+/**
+ * Data Variant 评估器示例调用。
+ */
+export declare function runDataVariantDemo(): import("./type").ResolvedDataVariantResult;
+/**
+ * 客户/渠道/业务范围条件示例调用。
+ */
+export declare function runCustomerScopeDataVariantDemo(): import("./type").ResolvedDataVariantResult;