@pisell/pisellos 2.2.302 → 2.2.304

package/dist/modules/Payment/cashRecommendationAlgorithm.js

@@ -8,10 +8,9 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
  * 现金支付推荐算法
  * 
  * 核心原理：
- * 1. 每个推荐金额都应该是独立的最优组合
- * 2. 不推荐在已有最优解基础上添加额外面额的组合
- * 3. 优先推荐使用不同数量币种的组合
- * 4. 根据组合判断去重，避免扩展组合
+ * 1. 第一项始终是精确应付金额
+ * 2. 其余推荐只能是严格大于应付金额的真实币种面额
+ * 3. 最多推荐三个更高面额
  */
 
 /**
@@ -47,377 +46,28 @@ export var CURRENCY_DENOMINATIONS = {
   'DEFAULT': [100, 50, 20, 10, 5, 1, 0.5, 0.25, 0.1, 0.05, 0.01]
 };
 
-/**
- * 支付组合类型定义
- */
-
 /**
  * 最优支付金额推荐算法
- * 推荐通过不同数量面额组合刚好足够支付的最小金额
+ * 返回精确应付金额，以及最多三个更高的真实币种面额
  * 
  * @param targetAmount 目标金额
  * @param denominations 币种面值数组
  * @returns 推荐支付金额数组
  */
 export function recommendOptimalPayments(targetAmount, denominations) {
-  // 参数验证
-  if (targetAmount <= 0 || !isFinite(targetAmount) || isNaN(targetAmount)) {
+  if (targetAmount <= 0 || !Number.isFinite(targetAmount)) {
     return [];
   }
-  if (!denominations || !Array.isArray(denominations) || denominations.length === 0) {
-    return [Math.ceil(targetAmount)];
-  }
-
-  // 过滤有效面额并限制搜索空间以提高性能
-  var maxReasonableDenom = targetAmount * 5; // 适度限制搜索空间
-  var validDenoms = denominations.filter(function (denom) {
-    return denom > 0 && isFinite(denom) && !isNaN(denom) && denom <= maxReasonableDenom;
-  }).slice(0, 8); // 限制面额数量以提高性能
-
-  if (validDenoms.length === 0) {
-    // 如果没有合适的面额，返回最接近的整数金额
-    return [Math.ceil(targetAmount)];
-  }
-  try {
-    // 处理精度问题，将金额转换为整数计算
-    var precision = 100; // 假设最小单位是0.01
-    var target = Math.round(targetAmount * precision);
-    var denoms = validDenoms.map(function (d) {
-      return Math.round(d * precision);
-    }).sort(function (a, b) {
-      return b - a;
-    });
-
-    // 存储不同的支付组合方案
-    var paymentOptions = [];
-
-    // 首先尝试找到精确匹配的组合
-    var exactCombination = findExactCombination(target, denoms, precision);
-    if (exactCombination) {
-      paymentOptions.push(exactCombination);
-    }
-
-    // 为了提高效率，我们将按币种数量来生成组合
-    // 1币种组合：只用一种面额
-    for (var i = 0; i < Math.min(denoms.length, 6); i++) {
-      var denom = denoms[i];
-      var count = Math.ceil(target / denom);
-      var sum = count * denom;
-      if (sum >= target && count <= 12) {
-        // 限制硬币数量以提高性能
-        paymentOptions.push({
-          combination: Array(count).fill(denom / precision),
-          sum: sum / precision,
-          coinCount: count,
-          denomTypes: 1
-        });
-      }
-    }
-
-    // 2币种组合：使用两种面额（大幅限制搜索范围以提高性能）
-    for (var _i = 0; _i < Math.min(denoms.length - 1, 5); _i++) {
-      for (var j = _i + 1; j < Math.min(denoms.length, 6); j++) {
-        var denom1 = denoms[_i];
-        var denom2 = denoms[j];
-
-        // 大幅限制搜索范围，基于目标金额动态调整
-        var maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 8);
-        var maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 10);
-        for (var count1 = 1; count1 <= maxCount1; count1++) {
-          for (var count2 = 1; count2 <= maxCount2; count2++) {
-            var _sum = count1 * denom1 + count2 * denom2;
-            if (_sum >= target) {
-              var combination = [].concat(_toConsumableArray(Array(count1).fill(denom1 / precision)), _toConsumableArray(Array(count2).fill(denom2 / precision)));
-              paymentOptions.push({
-                combination: combination,
-                sum: _sum / precision,
-                coinCount: count1 + count2,
-                denomTypes: 2
-              });
-            }
-          }
-        }
-      }
-    }
-
-    // 3币种组合：使用三种面额（大幅限制搜索以提高效率）
-    for (var _i2 = 0; _i2 < Math.min(denoms.length - 2, 3); _i2++) {
-      for (var _j = _i2 + 1; _j < Math.min(denoms.length - 1, 4); _j++) {
-        for (var k = _j + 1; k < Math.min(denoms.length, 5); k++) {
-          var _denom = denoms[_i2];
-          var _denom2 = denoms[_j];
-          var denom3 = denoms[k];
-
-          // 大幅限制搜索范围
-          var _maxCount = Math.min(Math.ceil(target / _denom) + 1, 5);
-          var _maxCount2 = Math.min(Math.ceil(target / _denom2) + 1, 6);
-          var maxCount3 = Math.min(Math.ceil(target / denom3) + 1, 8);
-          for (var _count = 1; _count <= _maxCount; _count++) {
-            for (var _count2 = 1; _count2 <= _maxCount2; _count2++) {
-              for (var count3 = 1; count3 <= maxCount3; count3++) {
-                var _sum2 = _count * _denom + _count2 * _denom2 + count3 * denom3;
-                if (_sum2 >= target) {
-                  var _combination = [].concat(_toConsumableArray(Array(_count).fill(_denom / precision)), _toConsumableArray(Array(_count2).fill(_denom2 / precision)), _toConsumableArray(Array(count3).fill(denom3 / precision)));
-                  paymentOptions.push({
-                    combination: _combination,
-                    sum: _sum2 / precision,
-                    coinCount: _count + _count2 + count3,
-                    denomTypes: 3
-                  });
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-
-    // 4币种组合：使用四种面额（极度限制搜索以提高性能）
-    for (var _i3 = 0; _i3 < Math.min(denoms.length - 3, 2); _i3++) {
-      for (var _j2 = _i3 + 1; _j2 < Math.min(denoms.length - 2, 3); _j2++) {
-        for (var _k = _j2 + 1; _k < Math.min(denoms.length - 1, 4); _k++) {
-          for (var l = _k + 1; l < Math.min(denoms.length, 5); l++) {
-            var _denom3 = denoms[_i3];
-            var _denom4 = denoms[_j2];
-            var _denom5 = denoms[_k];
-            var denom4 = denoms[l];
-
-            // 极度限制搜索范围
-            var _maxCount3 = Math.min(Math.ceil(target / _denom3) + 1, 3);
-            var _maxCount4 = Math.min(Math.ceil(target / _denom4) + 1, 4);
-            var _maxCount5 = Math.min(Math.ceil(target / _denom5) + 1, 5);
-            var maxCount4 = Math.min(Math.ceil(target / denom4) + 1, 6);
-            for (var _count3 = 1; _count3 <= _maxCount3; _count3++) {
-              for (var _count4 = 1; _count4 <= _maxCount4; _count4++) {
-                for (var _count5 = 1; _count5 <= _maxCount5; _count5++) {
-                  for (var count4 = 1; count4 <= maxCount4; count4++) {
-                    var _sum3 = _count3 * _denom3 + _count4 * _denom4 + _count5 * _denom5 + count4 * denom4;
-                    if (_sum3 >= target) {
-                      var _combination2 = [].concat(_toConsumableArray(Array(_count3).fill(_denom3 / precision)), _toConsumableArray(Array(_count4).fill(_denom4 / precision)), _toConsumableArray(Array(_count5).fill(_denom5 / precision)), _toConsumableArray(Array(count4).fill(denom4 / precision)));
-                      paymentOptions.push({
-                        combination: _combination2,
-                        sum: _sum3 / precision,
-                        coinCount: _count3 + _count4 + _count5 + count4,
-                        denomTypes: 4
-                      });
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-
-    // 如果没有找到任何组合，提供默认建议
-    if (paymentOptions.length === 0) {
-      // 找到大于等于目标金额的最小面额
-      var minValidDenom = validDenoms.find(function (denom) {
-        return denom >= targetAmount;
-      });
-      if (minValidDenom) {
-        return [minValidDenom];
-      } else {
-        // 使用最大面额的组合
-        var maxDenom = Math.max.apply(Math, _toConsumableArray(validDenoms));
-        var _count6 = Math.ceil(targetAmount / maxDenom);
-        return [_count6 * maxDenom];
-      }
-    }
-
-    // 移除重复和扩展组合
-    var uniqueCombinations = removeDuplicateAndExtendedCombinations(paymentOptions, targetAmount);
-
-    // 按币种类型数量排序，然后按总硬币数量排序，最后按金额排序
-    uniqueCombinations.sort(function (a, b) {
-      if (a.denomTypes !== b.denomTypes) {
-        return a.denomTypes - b.denomTypes;
-      }
-      if (a.coinCount !== b.coinCount) {
-        return a.coinCount - b.coinCount;
-      }
-      return a.sum - b.sum;
-    });
-
-    // 按金额去重并返回推荐的支付金额
-    var uniqueAmounts = new Set();
-    var finalResults = [];
-    for (var _i4 = 0, _uniqueCombinations = uniqueCombinations; _i4 < _uniqueCombinations.length; _i4++) {
-      var item = _uniqueCombinations[_i4];
-      var roundedAmount = Math.round(item.sum * 100) / 100; // 处理浮点数精度
-      if (!uniqueAmounts.has(roundedAmount) && finalResults.length < 10) {
-        uniqueAmounts.add(roundedAmount);
-        finalResults.push(roundedAmount);
-      }
-    }
-    return finalResults.sort(function (a, b) {
-      return a - b;
-    });
-  } catch (error) {
-    // 发生错误时返回安全的默认值
-    console.warn('推荐支付金额计算出错:', error);
-    // 返回最接近的整数金额作为兜底
-    var safeAmount = Math.ceil(targetAmount);
-    return [targetAmount, safeAmount];
-  }
-}
-
-/**
- * 尝试找到精确匹配目标金额的组合
- */
-function findExactCombination(target, denoms, precision) {
-  // 简单的深度优先搜索，限制搜索深度
-  function dfs(remaining, denomIndex, currentCombination) {
-    if (remaining === 0) {
-      return currentCombination;
-    }
-    if (remaining < 0 || denomIndex >= denoms.length || currentCombination.length > 10) {
-      return null;
-    }
-    var denom = denoms[denomIndex];
-
-    // 尝试使用当前面额 0 到 maxCount 次
-    var maxCount = Math.min(Math.floor(remaining / denom), 8);
-    for (var count = maxCount; count >= 0; count--) {
-      var newCombination = [].concat(_toConsumableArray(currentCombination), _toConsumableArray(Array(count).fill(denom)));
-      var result = dfs(remaining - count * denom, denomIndex + 1, newCombination);
-      if (result) {
-        return result;
-      }
-    }
-    return null;
-  }
-  var exactMatch = dfs(target, 0, []);
-  if (exactMatch && exactMatch.length > 0) {
-    var denomTypes = new Set(exactMatch).size;
-    return {
-      combination: exactMatch.map(function (d) {
-        return d / precision;
-      }),
-      sum: target / precision,
-      coinCount: exactMatch.length,
-      denomTypes: denomTypes
-    };
-  }
-  return null;
-}
-
-/**
- * 移除重复和扩展组合
- * 核心原理：如果组合A包含组合B的所有硬币，并且还有额外硬币，则A是B的扩展，应该被移除
- */
-function removeDuplicateAndExtendedCombinations(combinations, targetAmount) {
-  var result = [];
-
-  // 按币种类型数量、硬币数量、金额排序，确保较简单的组合在前面
-  combinations.sort(function (a, b) {
-    if (a.denomTypes !== b.denomTypes) {
-      return a.denomTypes - b.denomTypes;
-    }
-    if (a.coinCount !== b.coinCount) {
-      return a.coinCount - b.coinCount;
-    }
-    return a.sum - b.sum;
-  });
-  for (var i = 0; i < combinations.length; i++) {
-    var current = combinations[i];
-    var shouldSkip = false;
-
-    // 检查当前组合是否与已添加的组合重复或者是扩展
-    for (var j = 0; j < result.length; j++) {
-      var existing = result[j];
-
-      // 如果完全相同，跳过
-      if (isSameCombination(current.combination, existing.combination)) {
-        shouldSkip = true;
-        break;
-      }
-
-      // 如果当前组合是已存在组合的扩展，跳过
-      if (isExtensionOf(current.combination, existing.combination)) {
-        shouldSkip = true;
-        break;
-      }
-    }
-
-    // 检查是否有其他组合是当前组合的扩展，如果有，移除那些扩展
-    if (!shouldSkip) {
-      // 移除所有当前组合的扩展
-      for (var _j3 = result.length - 1; _j3 >= 0; _j3--) {
-        if (isExtensionOf(result[_j3].combination, current.combination)) {
-          result.splice(_j3, 1);
-        }
-      }
-      result.push(current);
-    }
-  }
-  return result;
-}
-
-/**
- * 检查组合A是否是组合B的扩展（即A包含B的所有硬币，并且还有额外的硬币）
- */
-function isExtensionOf(combinationA, combinationB) {
-  // 如果A的硬币数量少于等于B，A不可能是B的扩展
-  if (combinationA.length <= combinationB.length) {
-    return false;
-  }
-
-  // 统计每个面额的数量
-  var countA = {};
-  var countB = {};
-  combinationA.forEach(function (coin) {
-    countA[coin] = (countA[coin] || 0) + 1;
-  });
-  combinationB.forEach(function (coin) {
-    countB[coin] = (countB[coin] || 0) + 1;
-  });
-
-  // 检查B的所有面额在A中是否都有足够的数量
-  for (var coin in countB) {
-    if (!countA[coin] || countA[coin] < countB[coin]) {
-      return false;
-    }
-  }
-
-  // 检查A是否有B没有的额外硬币
-  var hasExtra = false;
-  for (var _coin in countA) {
-    if (countA[_coin] > (countB[_coin] || 0)) {
-      hasExtra = true;
-      break;
-    }
-  }
-  return hasExtra;
-}
-
-/**
- * 检查两个组合是否本质相同（相同的面额组合）
- */
-function isSameCombination(combinationA, combinationB) {
-  if (combinationA.length !== combinationB.length) {
-    return false;
-  }
-  var countA = {};
-  var countB = {};
-  combinationA.forEach(function (coin) {
-    countA[coin] = (countA[coin] || 0) + 1;
-  });
-  combinationB.forEach(function (coin) {
-    countB[coin] = (countB[coin] || 0) + 1;
-  });
-
-  // 检查两个组合是否有相同的面额和数量
-  for (var coin in countA) {
-    if (countA[coin] !== (countB[coin] || 0)) {
-      return false;
-    }
-  }
-  for (var _coin2 in countB) {
-    if (countB[_coin2] !== (countA[_coin2] || 0)) {
-      return false;
-    }
-  }
-  return true;
+  var precision = 100;
+  var normalizedTarget = Math.round(targetAmount * precision) / precision;
+  var higherDenominations = _toConsumableArray(new Set((Array.isArray(denominations) ? denominations : []).filter(function (denomination) {
+    return denomination > 0 && Number.isFinite(denomination);
+  }).map(function (denomination) {
+    return Math.round(denomination * precision) / precision;
+  }))).filter(function (denomination) {
+    return denomination > normalizedTarget;
+  }).sort(function (a, b) {
+    return a - b;
+  }).slice(0, 3);
+  return [normalizedTarget].concat(_toConsumableArray(higherDenominations));
 }

package/dist/modules/Payment/walletpass.js

@@ -851,7 +851,7 @@ export var WalletPassPaymentImpl = /*#__PURE__*/function () {
     key: "getUserIdentificationCodeListAsync",
     value: function () {
       var _getUserIdentificationCodeListAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(params) {
-        var _newParams$products, _newParams$prepare_pa, _this$walletParams4, newParams, platform, response, sortedData;
+        var _newParams$products, _newParams$prepare_pa, _this$walletParams4, newParams, response, sortedData;
         return _regeneratorRuntime().wrap(function _callee6$(_context6) {
           while (1) switch (_context6.prev = _context6.next) {
             case 0:
@@ -864,20 +864,19 @@ export var WalletPassPaymentImpl = /*#__PURE__*/function () {
               this.paymentModule.logInfo('[WalletPass] 商品列表为空，跳过获取用户识别码列表');
               return _context6.abrupt("return", []);
             case 5:
-              platform = this.paymentModule.getPlatform();
-              if (!(platform === 'pc' || platform === 'h5')) {
-                _context6.next = 11;
-                break;
-              }
-              this.userIdentificationCodes = [];
-              this.emitEvent(WalletPassHooks.OnUserIdentificationCodesUpdated, {
-                userIdentificationCodes: []
-              });
-              this.paymentModule.logInfo('[WalletPass] 用户端平台跳过获取用户识别码列表', {
-                platform: platform
-              });
-              return _context6.abrupt("return", []);
-            case 11:
+              // const platform = this.paymentModule.getPlatform();
+              // if (platform === 'pc' || platform === 'h5') {
+              //   this.userIdentificationCodes = [];
+              //   this.emitEvent(WalletPassHooks.OnUserIdentificationCodesUpdated, {
+              //     userIdentificationCodes: [],
+              //   } as OnUserIdentificationCodesUpdatedEventData);
+              //   this.paymentModule.logInfo(
+              //     '[WalletPass] 用户端平台跳过获取用户识别码列表',
+              //     { platform },
+              //   );
+              //   return [];
+              // }
+
               if (typeof newParams.payment_order_id === 'string' && newParams.payment_order_id.startsWith('LOCAL_')) {
                 newParams.payment_order_id = undefined;
               }
@@ -888,9 +887,9 @@ export var WalletPassPaymentImpl = /*#__PURE__*/function () {
                 filter_prepare_wallet_pass: newParams.filter_prepare_wallet_pass,
                 payment_order_id: (_this$walletParams4 = this.walletParams) === null || _this$walletParams4 === void 0 ? void 0 : _this$walletParams4.payment_order_id
               });
-              _context6.next = 15;
+              _context6.next = 9;
               return this.paymentModule.request.post('/machinecode/prepare/deduction', newParams);
-            case 15:
+            case 9:
               response = _context6.sent;
               // 对获取到的数据进行排序，将错误码为 500100、500200、500300 的项目排到最后
               sortedData = sortUserIdentificationCodeList((response === null || response === void 0 ? void 0 : response.data) || []);
@@ -911,19 +910,19 @@ export var WalletPassPaymentImpl = /*#__PURE__*/function () {
                 })
               });
               return _context6.abrupt("return", this.userIdentificationCodes);
-            case 23:
-              _context6.prev = 23;
+            case 17:
+              _context6.prev = 17;
               _context6.t0 = _context6["catch"](0);
               this.paymentModule.logError('[WalletPass] 获取用户识别码列表失败', _context6.t0, {
                 customer_id: params.customer_id,
                 available: params.available
               });
               return _context6.abrupt("return", []);
-            case 27:
+            case 21:
             case "end":
               return _context6.stop();
           }
-        }, _callee6, this, [[0, 23]]);
+        }, _callee6, this, [[0, 17]]);
       }));
       function getUserIdentificationCodeListAsync(_x7) {
         return _getUserIdentificationCodeListAsync.apply(this, arguments);

package/dist/modules/Product/types.d.ts

@@ -23,12 +23,25 @@ export interface ProductDataVariant {
     module_data_id: number;
     /** 关联 data_variant_rule.id */
     data_variant_rule_id: number;
+    /** 多货币结算等业务类型 */
+    business_type?: 'multi_currency_settlement' | string;
+    /** 数据状态；多货币结算仅处理 enable 记录 */
+    status?: 'enable' | 'disable' | string;
     /** 命中策略后覆盖到商品上的字段 */
     data: Record<string, any>;
     created_at: string | null;
     updated_at: string | null;
     deleted_at: string | null;
 }
+export interface ProductSettlementOption extends Record<string, any> {
+    settlement_type: 'legal_currency' | 'virtual_currency' | string;
+    currency_product_id?: number;
+    price: string;
+    data_variant_id?: number;
+    data_variant_rule_id: number | string;
+    available: boolean;
+    disabled_reason?: string;
+}
 /**
  * 商品基本信息接口
  */
@@ -61,6 +74,8 @@ export interface ProductData {
     sum_stock: number;
     /** 商品价格 */
     price: string;
+    /** 当前上下文解析出的可选结算货币 */
+    available_settlement_options?: ProductSettlementOption[];
     /** 商品原价 */
     original_price: string;
     /** 商品成本价 */
@@ -239,6 +254,14 @@ export interface ProductData {
     option_group_count: number;
     /** 智能定价变体列表，/product/query with dataVariants 返回 */
     data_variants?: ProductDataVariant[];
+    /**
+     * 商品接口规则计算结果；data_variant_ids 按优先级从高到低排列。
+     * 空数组表示规则已经计算完成但没有命中 Data Variant。
+     */
+    metadata?: {
+        data_variant_ids?: Array<number | string>;
+        [key: string]: any;
+    };
     /** 服务时长 */
     service_times?: any;
 }

package/dist/modules/ProductList/index.d.ts

@@ -1,6 +1,6 @@
 import { Module, PisellCore } from '../../types';
 import { BaseModule } from '../BaseModule';
-import { ProductListLoadProductsParams } from './types';
+import { ProductListLoadProductsParams, ProductListStoreQueryParams } from './types';
 import { ProductData } from '../Product/types';
 export * from './types';
 export declare class ProductList extends BaseModule implements Module {
@@ -52,6 +52,7 @@ export declare class ProductList extends BaseModule implements Module {
     getRawProductPriceSources(ids: number[]): Map<number, ProductData>;
     getProducts(): Promise<ProductData[]>;
     getProduct(id: number): Promise<ProductData | undefined>;
+    queryProducts(params?: ProductListStoreQueryParams): Promise<ProductData[]>;
     getProductByIds(ids: number[]): Promise<ProductData[] | undefined>;
     addProduct(products: ProductData[]): Promise<void>;
     selectProducts(products: ProductData[]): Promise<void>;