@pisell/pisellos 2.1.38 → 2.2.1

package/lib/server/modules/products/index.js

@@ -0,0 +1,434 @@
+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/server/modules/products/index.ts
+var products_exports = {};
+__export(products_exports, {
+  ProductsModule: () => ProductsModule
+});
+module.exports = __toCommonJS(products_exports);
+var import_BaseModule = require("../../../modules/BaseModule");
+var import_lodash_es = require("lodash-es");
+var import_types = require("./types");
+var import_product = require("../../utils/product");
+var INDEXDB_STORE_NAME = "products";
+var ProductsModule = class extends import_BaseModule.BaseModule {
+  constructor(name, version) {
+    super(name, version);
+    this.defaultName = "products";
+    this.defaultVersion = "1.0.0";
+    // IndexDBManager 实例
+    this.otherParams = {};
+    // 商品价格缓存：Map<日期, 应用了价格的商品列表>
+    this.productsPriceCache = /* @__PURE__ */ new Map();
+    // 缓存配置
+    this.CACHE_MAX_DAYS = 7;
+    // 最多缓存7天
+    // 商品格式化器列表
+    this.formatters = [];
+    // 是否已注册内置价格格式化器
+    this.isPriceFormatterRegistered = false;
+  }
+  async initialize(core, options) {
+    var _a;
+    this.core = core;
+    this.store = options.store;
+    this.otherParams = options.otherParams || {};
+    if (Array.isArray((_a = options.initialState) == null ? void 0 : _a.list)) {
+      this.store.list = options.initialState.list;
+      this.syncProductsMap();
+      this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
+    } else {
+      this.store.list = [];
+      this.store.map = /* @__PURE__ */ new Map();
+    }
+    this.request = core.getPlugin("request");
+    const appPlugin = core.getPlugin("app");
+    if (appPlugin) {
+      const app = appPlugin.getApp();
+      this.dbManager = app.dbManager;
+      if (this.dbManager) {
+        console.log("[Products] IndexDB Manager 已初始化");
+      } else {
+        console.warn("[Products] IndexDB Manager 未找到");
+      }
+    }
+    this.registerBuiltinPriceFormatter();
+  }
+  /**
+   * 加载商品价格（原始方法，不带缓存）
+   * @private
+   */
+  async loadProductsPrice({
+    ids = [],
+    customer_id,
+    schedule_date
+  }) {
+    const productsData = await this.request.post(
+      `/product/query/price`,
+      {
+        ids,
+        customer_id,
+        schedule_date
+      },
+      { useCache: true }
+    );
+    return productsData.data;
+  }
+  /**
+   * 获取应用了价格的商品列表（带缓存）
+   * 使用日期作为缓存 key，同一天的商品价格会被缓存
+   * 缓存的是已经应用了价格的完整商品列表，避免重复转换
+   * @param schedule_date 日期
+   * @param extraContext 额外的上下文数据（可选，由 Server 层传入）
+   * @returns 应用了价格的商品列表
+   */
+  async getProductsWithPrice(schedule_date, extraContext) {
+    const cacheKey = schedule_date;
+    if (this.productsPriceCache.has(cacheKey)) {
+      console.log(`[ProductsModule] 💰 商品价格缓存命中: ${cacheKey}`);
+      return this.productsPriceCache.get(cacheKey);
+    }
+    console.log(`[ProductsModule] 🌐 获取商品并应用价格: ${cacheKey}`);
+    const result = await this.prepareProductsWithPrice(schedule_date, extraContext);
+    this.productsPriceCache.set(cacheKey, result);
+    console.log(`[ProductsModule] ✅ 商品价格已缓存: ${cacheKey}, 共 ${result.length} 个商品`);
+    this.cleanExpiredPriceCache();
+    return result;
+  }
+  /**
+   * 准备带价格的商品数据（通过格式化器流程处理）
+   * @param schedule_date 日期
+   * @param extraContext 额外的上下文数据（可选）
+   * @returns 完整处理后的商品列表
+   * @private
+   */
+  async prepareProductsWithPrice(schedule_date, extraContext) {
+    const allProducts = await this.getProducts();
+    const priceData = await this.loadProductsPrice({
+      ids: allProducts.map((product) => product.id),
+      schedule_date
+    });
+    const context = {
+      schedule_date,
+      priceData,
+      ...extraContext
+      // 合并 Server 层传入的额外数据（如 scheduleList）
+    };
+    const processedProducts = await this.applyFormatters(allProducts, context);
+    await this.core.effects.emit(
+      import_types.ProductsHooks.onProductsPriceApplied,
+      processedProducts
+    );
+    return processedProducts;
+  }
+  /**
+   * 应用所有已注册的格式化器
+   * @param products 商品列表
+   * @param context 上下文信息
+   * @returns 格式化后的商品列表
+   * @private
+   */
+  async applyFormatters(products, context) {
+    let result = products;
+    if (this.formatters.length === 0) {
+      console.warn("[ProductsModule] ⚠️ 没有注册任何格式化器");
+      return result;
+    }
+    for (let i = 0; i < this.formatters.length; i++) {
+      const formatter = this.formatters[i];
+      try {
+        console.log(`[ProductsModule] 📝 应用格式化器 ${i + 1}/${this.formatters.length}`);
+        result = await formatter(result, context);
+      } catch (error) {
+        console.error(`[ProductsModule] ❌ 格式化器 ${i + 1} 执行失败:`, error);
+      }
+    }
+    console.log(`[ProductsModule] ✅ 所有格式化器已应用，共 ${this.formatters.length} 个`);
+    return result;
+  }
+  /**
+   * 注册内置的价格格式化器
+   * 这个格式化器负责将价格数据应用到商品上
+   * @private
+   */
+  registerBuiltinPriceFormatter() {
+    if (this.isPriceFormatterRegistered) {
+      console.warn("[ProductsModule] 内置价格格式化器已注册，跳过");
+      return;
+    }
+    const priceFormatter = (products, context) => {
+      if (!context.priceData || context.priceData.length === 0) {
+        console.log("[ProductsModule] 💰 没有价格数据，跳过价格应用");
+        return products;
+      }
+      console.log(`[ProductsModule] 💰 应用价格数据到 ${products.length} 个商品`);
+      return (0, import_product.applyPriceDataToProducts)(products, context.priceData);
+    };
+    const detailValueFormatter = (products, context) => {
+      return (0, import_product.applyDetailValueToProducts)(products, context);
+    };
+    this.formatters.unshift(priceFormatter);
+    this.formatters.push(detailValueFormatter);
+    this.isPriceFormatterRegistered = true;
+    console.log("[ProductsModule] ✅ 内置价格格式化器已注册（第 1 个）");
+  }
+  /**
+   * 注册商品格式化器
+   * 格式化器会按注册顺序依次执行（内置价格格式化器始终是第一个）
+   * @param formatter 格式化函数
+   * @param prepend 是否插入到队列开头（默认 false，追加到末尾）
+   * @example
+   * ```ts
+   * productsModule.registerFormatter((products, context) => {
+   *   return products.map(p => ({
+   *     ...p,
+   *     custom_field: 'custom_value'
+   *   }));
+   * });
+   * ```
+   */
+  registerFormatter(formatter, prepend = false) {
+    if (prepend) {
+      const insertIndex = this.isPriceFormatterRegistered ? 1 : 0;
+      this.formatters.splice(insertIndex, 0, formatter);
+      console.log(`[ProductsModule] 📌 已在位置 ${insertIndex + 1} 插入格式化器，当前共 ${this.formatters.length} 个`);
+    } else {
+      this.formatters.push(formatter);
+      console.log(`[ProductsModule] 📌 已注册格式化器，当前共 ${this.formatters.length} 个`);
+    }
+  }
+  /**
+   * 清空所有格式化器（包括内置价格格式化器）
+   * @param keepBuiltin 是否保留内置价格格式化器（默认 true）
+   */
+  clearFormatters(keepBuiltin = true) {
+    if (keepBuiltin && this.isPriceFormatterRegistered) {
+      this.formatters = [this.formatters[0]];
+      console.log("[ProductsModule] 🧹 已清空自定义格式化器，保留内置价格格式化器");
+    } else {
+      this.formatters = [];
+      this.isPriceFormatterRegistered = false;
+      console.log("[ProductsModule] 🧹 已清空所有格式化器");
+    }
+  }
+  /**
+   * 清理过期的价格缓存
+   * 当缓存数量超过限制时，删除最老的缓存
+   * @private
+   */
+  cleanExpiredPriceCache() {
+    if (this.productsPriceCache.size > this.CACHE_MAX_DAYS) {
+      const keys = Array.from(this.productsPriceCache.keys());
+      const oldestKey = keys[0];
+      this.productsPriceCache.delete(oldestKey);
+      console.log(`[ProductsModule] 🧹 清理过期商品价格缓存: ${oldestKey}`);
+    }
+  }
+  /**
+   * 清空商品价格缓存
+   * 可用于手动刷新价格数据
+   */
+  clearPriceCache() {
+    this.productsPriceCache.clear();
+    console.log("[ProductsModule] 🗑️ 商品价格缓存已清空");
+  }
+  /**
+   * 加载完整商品列表通过接口（包含所有详细数据）
+   * @param params 查询参数
+   */
+  async loadProductsByServer(params) {
+    var _a, _b;
+    const {
+      category_ids = [],
+      product_ids = [],
+      collection = [],
+      customer_id,
+      cacheId
+    } = params || {};
+    try {
+      const productsData = await this.request.post(
+        `/product/query`,
+        {
+          open_bundle: 1,
+          exclude_extension_type: [
+            "product_party",
+            "product_event",
+            "product_series_event",
+            "product_package_ticket",
+            "ticket",
+            "event_item"
+          ],
+          force_ignore_cache_flag: 1,
+          // 获取所有详细信息
+          with: [
+            "category",
+            "collection",
+            "resourceRelation",
+            // 套餐
+            "bundleGroup.bundleItem",
+            // 单规格
+            "optionGroup.optionItem",
+            // 组合规格
+            "variantGroup.variantItem"
+          ],
+          open_deposit: 1,
+          with_count: ["bundleGroup", "optionGroup"],
+          status: "published",
+          num: 500,
+          skip: 1,
+          category_ids,
+          ids: product_ids,
+          collection,
+          front_end_cache_id: cacheId,
+          application_code: (_a = this.otherParams) == null ? void 0 : _a.channel
+        },
+        { useCache: true }
+      );
+      await this.saveProductsToIndexDB(((_b = productsData == null ? void 0 : productsData.data) == null ? void 0 : _b.list) || []);
+      await this.core.effects.emit(
+        import_types.ProductsHooks.onProductsLoaded,
+        productsData.data.list
+      );
+      return productsData.data.list;
+    } catch (error) {
+      console.error("[Products] 加载商品数据失败:", error);
+      return [];
+    }
+  }
+  /**
+   * 获取商品列表（从缓存）
+   */
+  async getProducts() {
+    return (0, import_lodash_es.cloneDeep)(this.store.list);
+  }
+  /**
+   * 根据ID获取单个商品（从内存缓存）
+   * 使用 Map 快速查询，时间复杂度 O(1)
+   */
+  async getProductById(id) {
+    const product = this.store.map.get(id);
+    return product ? (0, import_lodash_es.cloneDeep)(product) : void 0;
+  }
+  /**
+   * 清空缓存
+   */
+  async clear() {
+    this.store.list = [];
+    this.store.map.clear();
+    if (this.dbManager) {
+      try {
+        await this.dbManager.clear(INDEXDB_STORE_NAME);
+        console.log("[Products] IndexDB 缓存已清空");
+      } catch (error) {
+        console.error("[Products] 清空 IndexDB 缓存失败:", error);
+      }
+    }
+    console.log("[Products] 缓存已清空");
+  }
+  /**
+   * 从 IndexDB 加载商品数据
+   * @private
+   */
+  async loadProductsFromIndexDB() {
+    if (!this.dbManager) {
+      return [];
+    }
+    try {
+      const products = await this.dbManager.getAll(INDEXDB_STORE_NAME);
+      return products || [];
+    } catch (error) {
+      console.error("[Products] 从 IndexDB 读取数据失败:", error);
+      return [];
+    }
+  }
+  /**
+   * 保存商品数据到 IndexDB（平铺存储）
+   * @private
+   */
+  async saveProductsToIndexDB(products) {
+    if (!this.dbManager) {
+      return;
+    }
+    try {
+      await this.dbManager.clear(INDEXDB_STORE_NAME);
+      const savePromises = products.map(
+        (product) => this.dbManager.add(INDEXDB_STORE_NAME, product)
+      );
+      await Promise.all(savePromises);
+      console.log(
+        `[Products] 已将 ${products.length} 个商品平铺保存到 IndexDB`
+      );
+    } catch (error) {
+      console.error("[Products] 保存数据到 IndexDB 失败:", error);
+    }
+  }
+  /**
+   * 同步更新商品 Map 缓存
+   * 将 list 中的商品同步到 map，以 id 为 key
+   * @private
+   */
+  syncProductsMap() {
+    this.store.map.clear();
+    for (const product of this.store.list) {
+      this.store.map.set(product.id, product);
+    }
+    console.log(`[Products] Map 缓存已同步，共 ${this.store.map.size} 个商品`);
+  }
+  /**
+   * 预加载模块数据（统一接口）
+   * 在模块注册后自动调用
+   */
+  async preload() {
+    console.log("[Products] 开始预加载数据...");
+    try {
+      const cachedData = await this.loadProductsFromIndexDB();
+      if (cachedData && cachedData.length > 0) {
+        console.log(`[Products] 从 IndexDB 加载了 ${cachedData.length} 个商品`);
+        this.store.list = (0, import_lodash_es.cloneDeep)(cachedData);
+        this.syncProductsMap();
+        this.core.effects.emit(
+          import_types.ProductsHooks.onProductsChanged,
+          this.store.list
+        );
+        return;
+      }
+      console.log("[Products] IndexDB 中没有缓存数据，从服务器加载...");
+    } catch (error) {
+      console.warn("[Products] 从 IndexDB 加载数据失败:", error);
+    }
+    const products = await this.loadProductsByServer();
+    if (products && products.length > 0) {
+      await this.saveProductsToIndexDB(products);
+      this.store.list = (0, import_lodash_es.cloneDeep)(products);
+      this.syncProductsMap();
+      this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
+    }
+  }
+  /**
+   * 获取模块的路由定义
+   * Products 模块暂不提供路由，由 Server 层统一处理
+   */
+  getRoutes() {
+    return [];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProductsModule
+});

package/lib/server/modules/products/types.d.ts

@@ -0,0 +1,94 @@
+import { ProductData } from '../../../modules/Product/types';
+/**
+ * Products 模块状态
+ */
+export interface ProductsState {
+    /** 完整商品列表 */
+    list: ProductData[];
+    /** 商品 Map 缓存（以 id 为 key，加速查询） */
+    map: Map<number, ProductData>;
+}
+/**
+ * 商品格式化后数据
+ */
+export interface FormattedProductData extends ProductData {
+    /** 是否打开详情弹窗 */
+    isOpenDetailModal?: boolean;
+    /** 购物车详情值 */
+    cartDetailValue?: any;
+}
+/**
+ * 加载报价单商品价格参数
+ */
+export interface LoadProductsPriceParams {
+    ids: number[];
+    schedule_date: string;
+    customer_id?: number;
+}
+/**
+ * 加载报价单商品价格返回数据
+ */
+export interface LoadProductsPriceData {
+    id: number;
+    price: string;
+    base_price: string;
+    variant: {
+        id: number;
+        product_id: number;
+        base_price: number;
+        price: number;
+    }[];
+    bundle_group: {
+        id: number;
+        bundle_item: {
+            id: number;
+            product_id: number;
+            group_id: number;
+            bundle_product_id: number;
+            bundle_variant_id: number;
+            price: number;
+            price_type: string;
+            price_type_ext: string;
+        }[];
+    }[];
+}
+/**
+ * 加载报价单商品价格返回数据
+ */
+export interface LoadProductsPriceResponse {
+    code: number;
+    data: LoadProductsPriceData[];
+    message: string;
+    status: boolean;
+}
+/**
+ * Products 模块状态
+ */
+export interface ProductsState {
+    /** 完整商品列表 */
+    list: ProductData[];
+    /** 商品 Map 缓存（以 id 为 key，加速查询） */
+    map: Map<number, ProductData>;
+}
+/**
+ * Products 模块钩子
+ */
+export declare enum ProductsHooks {
+    onProductsLoaded = "products:onProductsLoaded",
+    onProductsChanged = "products:onProductsChanged",
+    onProductSelected = "products:onProductSelected",
+    onProductsPriceApplied = "products:onProductsPriceApplied"
+}
+/**
+ * 商品格式化器上下文
+ */
+export interface ProductFormatterContext {
+    schedule_date: string;
+    priceData?: LoadProductsPriceData[];
+    scheduleModule?: any;
+}
+/**
+ * 商品格式化器类型
+ * 用于对商品数据进行处理和格式化（包括价格应用、字段扩展等）
+ */
+export type ProductFormatter = (products: ProductData[], context: ProductFormatterContext) => ProductData[] | Promise<ProductData[]>;

package/lib/server/modules/products/types.js

@@ -0,0 +1,35 @@
+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/server/modules/products/types.ts
+var types_exports = {};
+__export(types_exports, {
+  ProductsHooks: () => ProductsHooks
+});
+module.exports = __toCommonJS(types_exports);
+var ProductsHooks = /* @__PURE__ */ ((ProductsHooks2) => {
+  ProductsHooks2["onProductsLoaded"] = "products:onProductsLoaded";
+  ProductsHooks2["onProductsChanged"] = "products:onProductsChanged";
+  ProductsHooks2["onProductSelected"] = "products:onProductSelected";
+  ProductsHooks2["onProductsPriceApplied"] = "products:onProductsPriceApplied";
+  return ProductsHooks2;
+})(ProductsHooks || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProductsHooks
+});

package/lib/server/modules/quotation/index.d.ts

@@ -0,0 +1,47 @@
+import { Module, PisellCore, ModuleOptions } from '../../../types';
+import { BaseModule } from '../../../modules/BaseModule';
+import { QuotationData } from './types';
+/**
+ * 报价单模块 - 用于管理报价单数据和计算商品价格
+ */
+export declare class QuotationModule extends BaseModule implements Module {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    private request;
+    private store;
+    private dbManager;
+    constructor(name?: string, version?: string);
+    initialize(core: PisellCore, options?: ModuleOptions): Promise<void>;
+    /**
+     * 加载报价单列表（从服务器）
+     * TODO: 接口地址待定
+     */
+    loadQuotationList(): Promise<QuotationData[]>;
+    /**
+     * 设置报价单列表
+     */
+    setQuotationList(quotationList: QuotationData[]): Promise<void>;
+    /**
+     * 获取报价单列表
+     */
+    getQuotationList(): QuotationData[];
+    /**
+     * 清空缓存
+     */
+    clear(): Promise<void>;
+    /**
+     * 从 IndexDB 加载报价单数据
+     * @private
+     */
+    private loadQuotationFromIndexDB;
+    /**
+     * 保存报价单数据到 IndexDB
+     * @private
+     */
+    private saveQuotationToIndexDB;
+    /**
+     * 预加载模块数据（统一接口）
+     * 在模块注册后自动调用
+     */
+    preload(): Promise<void>;
+}