@pisell/pisellos 2.1.36 → 2.2.1

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

@@ -0,0 +1,234 @@
+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/menu/index.ts
+var menu_exports = {};
+__export(menu_exports, {
+  MenuModule: () => MenuModule
+});
+module.exports = __toCommonJS(menu_exports);
+var import_lodash_es = require("lodash-es");
+var import_BaseModule = require("../../../modules/BaseModule");
+var import_types = require("./types");
+var INDEXDB_STORE_NAME = "menu";
+var MenuModule = class extends import_BaseModule.BaseModule {
+  // IndexDBManager 实例
+  constructor(name, version) {
+    super(name, version);
+    this.defaultName = "menu";
+    this.defaultVersion = "1.0.0";
+  }
+  async initialize(core, options) {
+    var _a;
+    this.core = core;
+    this.store = options == null ? void 0 : options.store;
+    this.request = core.getPlugin("request");
+    if (!this.request) {
+      throw new Error("MenuModule 需要 request 插件支持");
+    }
+    if (Array.isArray((_a = options == null ? void 0 : options.initialState) == null ? void 0 : _a.menuList)) {
+      this.store.menuList = options == null ? void 0 : options.initialState.menuList;
+      this.syncMenuMap();
+      this.core.effects.emit(import_types.MenuHooks.onMenuChanged, this.store.menuList);
+    } else {
+      this.store.menuList = [];
+      this.store.map = /* @__PURE__ */ new Map();
+    }
+    const appPlugin = core.getPlugin("app");
+    if (appPlugin) {
+      const app = appPlugin.getApp();
+      this.dbManager = app.dbManager;
+      if (this.dbManager) {
+        console.log("[Menu] IndexDB Manager 已初始化");
+      } else {
+        console.warn("[Menu] IndexDB Manager 未找到");
+      }
+    }
+  }
+  /**
+   * 加载餐牌列表（从服务器）
+   */
+  async loadMenuList() {
+    var _a;
+    try {
+      const response = await this.request.get(
+        `/form/data/v1`,
+        {
+          skip: 1,
+          num: 999,
+          code: "menu_list"
+        },
+        { useCache: true }
+      );
+      const menuList = ((_a = response == null ? void 0 : response.data) == null ? void 0 : _a.list) || [];
+      await this.saveMenuToIndexDB(menuList);
+      await this.setMenuList(menuList);
+      return menuList;
+    } catch (error) {
+      console.error("[Menu] 加载餐牌数据失败:", error);
+      return [];
+    }
+  }
+  /**
+   * 设置餐牌列表
+   */
+  async setMenuList(menuList) {
+    this.store.menuList = menuList;
+    this.syncMenuMap();
+    await this.core.effects.emit(import_types.MenuHooks.onMenuLoaded, menuList);
+  }
+  /**
+   * 获取餐牌列表
+   */
+  getMenuList() {
+    return this.store.menuList;
+  }
+  /**
+   * 根据 form_record_id 数组获取餐牌详情
+   * 使用 Map 快速查询，时间复杂度 O(m)，m 为 ids 数量
+   */
+  getMenuByIds(ids) {
+    if (!ids || ids.length === 0) {
+      return [];
+    }
+    const result = [];
+    for (const id of ids) {
+      const menu = this.store.map.get(id);
+      if (menu) {
+        result.push(menu);
+      }
+    }
+    return result;
+  }
+  /**
+   * 同步更新餐牌 Map 缓存
+   * 将 menuList 中的餐牌同步到 map，以 form_record_id 为 key
+   * @private
+   */
+  syncMenuMap() {
+    this.store.map.clear();
+    for (const menu of this.store.menuList) {
+      this.store.map.set(menu.form_record_id, menu);
+    }
+    console.log(`[Menu] Map 缓存已同步，共 ${this.store.map.size} 个餐牌`);
+  }
+  /**
+   * 清空缓存
+   */
+  async clear() {
+    this.store.menuList = [];
+    this.store.map.clear();
+    this.store.currentMenu = void 0;
+    if (this.dbManager) {
+      try {
+        await this.dbManager.clear(INDEXDB_STORE_NAME);
+        console.log("[Menu] IndexDB 缓存已清空");
+      } catch (error) {
+        console.error("[Menu] 清空 IndexDB 缓存失败:", error);
+      }
+    }
+    console.log("[Menu] 缓存已清空");
+  }
+  /**
+   * 从 IndexDB 加载餐牌数据
+   * @private
+   */
+  async loadMenuFromIndexDB() {
+    if (!this.dbManager) {
+      return [];
+    }
+    try {
+      const menuList = await this.dbManager.getAll(INDEXDB_STORE_NAME);
+      return menuList || [];
+    } catch (error) {
+      console.error("[Menu] 从 IndexDB 读取数据失败:", error);
+      return [];
+    }
+  }
+  /**
+   * 保存餐牌数据到 IndexDB
+   * @private
+   */
+  async saveMenuToIndexDB(menuList) {
+    if (!this.dbManager) {
+      return;
+    }
+    try {
+      await this.dbManager.clear(INDEXDB_STORE_NAME);
+      const savePromises = menuList.map(
+        (menu) => this.dbManager.add(INDEXDB_STORE_NAME, menu)
+      );
+      await Promise.all(savePromises);
+      console.log(`[Menu] 已将 ${menuList.length} 条餐牌数据保存到 IndexDB`);
+    } catch (error) {
+      console.error("[Menu] 保存数据到 IndexDB 失败:", error);
+    }
+  }
+  /**
+   * 预加载模块数据（统一接口）
+   * 在模块注册后自动调用
+   */
+  async preload() {
+    console.log("[Menu] 开始预加载数据...");
+    try {
+      const cachedData = await this.loadMenuFromIndexDB();
+      if (cachedData && cachedData.length > 0) {
+        console.log(`[Menu] 从 IndexDB 加载了 ${cachedData.length} 条餐牌数据`);
+        this.store.menuList = (0, import_lodash_es.cloneDeep)(cachedData);
+        this.syncMenuMap();
+        this.core.effects.emit(import_types.MenuHooks.onMenuChanged, this.store.menuList);
+        return;
+      }
+      console.log("[Menu] IndexDB 中没有缓存数据，从服务器加载...");
+    } catch (error) {
+      console.warn("[Menu] 从 IndexDB 加载数据失败:", error);
+    }
+    const menuList = await this.loadMenuList();
+    if (menuList && menuList.length > 0) {
+      await this.saveMenuToIndexDB(menuList);
+      this.store.menuList = (0, import_lodash_es.cloneDeep)(menuList);
+      this.syncMenuMap();
+      this.core.effects.emit(import_types.MenuHooks.onMenuChanged, this.store.menuList);
+    }
+  }
+  /**
+   * 获取模块的路由定义
+   * 返回该模块需要注册的 API 路由
+   */
+  getRoutes() {
+    return [
+      // GET /api/menu - 获取所有餐牌
+      {
+        method: "get",
+        path: "/api/menu",
+        handler: async () => {
+          const menuList = this.getMenuList();
+          return {
+            success: true,
+            data: menuList,
+            total: menuList.length
+          };
+        }
+      }
+    ];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MenuModule
+});

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

@@ -0,0 +1,68 @@
+/**
+ * 餐牌模块状态
+ */
+export interface MenuState {
+    /** 餐牌列表 */
+    menuList: MenuData[];
+    /** 餐牌 Map 缓存（以 form_record_id 为 key，加速查询） */
+    map: Map<number, MenuData>;
+    /** 当前生效的餐牌 */
+    currentMenu?: MenuData;
+}
+type ProductItemType = {
+    /** 商品集合 ID */
+    product_collection_id: number;
+    /** 商品 ID */
+    product_id: number;
+    /** 商品规格 ID */
+    product_variant_id: number;
+};
+/**
+ * 餐牌数据结构
+ */
+export interface MenuData {
+    /** 餐牌名称 */
+    name: string;
+    /** 副标题 */
+    subtitle: string;
+    /** 媒体资源 */
+    media: any[];
+    /** 描述 */
+    description: string;
+    /** 状态 */
+    status: 'valid' | 'invalid';
+    /** 绑定的日程 ID 列表 */
+    schedule: number[];
+    /** 商品配置 */
+    partyroom_package: {
+        /** 类型：product_all 表示所有商品，product_ids 表示指定商品，product_collection 表示商品集合 */
+        type: 'product_all' | 'products' | 'product_collection';
+        /** 指定的商品 或 商品集合 */
+        products: ProductItemType[];
+        filter?: number;
+    };
+    /** 表单标签 */
+    form_tag: string;
+    /** 商品字段 */
+    products: string;
+    /** 容量 */
+    capacity: number;
+    /** 表单记录 ID */
+    form_record_id: number;
+    /** 表单 ID */
+    form_id: number;
+    /** 主字段 */
+    main_field: string;
+    /** 过期时间 */
+    expired_at: string | null;
+    /** 创建时间 */
+    created_at: string;
+}
+/**
+ * 餐牌模块钩子
+ */
+export declare enum MenuHooks {
+    onMenuLoaded = "menu:onMenuLoaded",
+    onMenuChanged = "menu:onMenuChanged"
+}
+export {};

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

@@ -0,0 +1,33 @@
+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/menu/types.ts
+var types_exports = {};
+__export(types_exports, {
+  MenuHooks: () => MenuHooks
+});
+module.exports = __toCommonJS(types_exports);
+var MenuHooks = /* @__PURE__ */ ((MenuHooks2) => {
+  MenuHooks2["onMenuLoaded"] = "menu:onMenuLoaded";
+  MenuHooks2["onMenuChanged"] = "menu:onMenuChanged";
+  return MenuHooks2;
+})(MenuHooks || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MenuHooks
+});

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

@@ -0,0 +1,141 @@
+import { Module, PisellCore } from '../../../types';
+import { BaseModule } from '../../../modules/BaseModule';
+import { ProductData } from '../../../modules/Product/types';
+import type { RouteDefinition } from '../../types';
+import { ProductFormatter, ProductFormatterContext } from './types';
+/**
+ * Products 模块 - 用于获取和管理完整的商品详细数据
+ * 相比 ProductList 模块，Products 会获取所有详细信息并缓存
+ */
+export declare class ProductsModule extends BaseModule implements Module {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    private store;
+    private request;
+    private dbManager;
+    private otherParams;
+    private productsPriceCache;
+    private readonly CACHE_MAX_DAYS;
+    private formatters;
+    private isPriceFormatterRegistered;
+    constructor(name?: string, version?: string);
+    initialize(core: PisellCore, options: any): Promise<void>;
+    /**
+     * 加载商品价格（原始方法，不带缓存）
+     * @private
+     */
+    private loadProductsPrice;
+    /**
+     * 获取应用了价格的商品列表（带缓存）
+     * 使用日期作为缓存 key，同一天的商品价格会被缓存
+     * 缓存的是已经应用了价格的完整商品列表，避免重复转换
+     * @param schedule_date 日期
+     * @param extraContext 额外的上下文数据（可选，由 Server 层传入）
+     * @returns 应用了价格的商品列表
+     */
+    getProductsWithPrice(schedule_date: string, extraContext?: Partial<ProductFormatterContext>): Promise<ProductData[]>;
+    /**
+     * 准备带价格的商品数据（通过格式化器流程处理）
+     * @param schedule_date 日期
+     * @param extraContext 额外的上下文数据（可选）
+     * @returns 完整处理后的商品列表
+     * @private
+     */
+    private prepareProductsWithPrice;
+    /**
+     * 应用所有已注册的格式化器
+     * @param products 商品列表
+     * @param context 上下文信息
+     * @returns 格式化后的商品列表
+     * @private
+     */
+    private applyFormatters;
+    /**
+     * 注册内置的价格格式化器
+     * 这个格式化器负责将价格数据应用到商品上
+     * @private
+     */
+    private registerBuiltinPriceFormatter;
+    /**
+     * 注册商品格式化器
+     * 格式化器会按注册顺序依次执行（内置价格格式化器始终是第一个）
+     * @param formatter 格式化函数
+     * @param prepend 是否插入到队列开头（默认 false，追加到末尾）
+     * @example
+     * ```ts
+     * productsModule.registerFormatter((products, context) => {
+     *   return products.map(p => ({
+     *     ...p,
+     *     custom_field: 'custom_value'
+     *   }));
+     * });
+     * ```
+     */
+    registerFormatter(formatter: ProductFormatter, prepend?: boolean): void;
+    /**
+     * 清空所有格式化器（包括内置价格格式化器）
+     * @param keepBuiltin 是否保留内置价格格式化器（默认 true）
+     */
+    clearFormatters(keepBuiltin?: boolean): void;
+    /**
+     * 清理过期的价格缓存
+     * 当缓存数量超过限制时，删除最老的缓存
+     * @private
+     */
+    private cleanExpiredPriceCache;
+    /**
+     * 清空商品价格缓存
+     * 可用于手动刷新价格数据
+     */
+    clearPriceCache(): void;
+    /**
+     * 加载完整商品列表通过接口（包含所有详细数据）
+     * @param params 查询参数
+     */
+    loadProductsByServer(params?: {
+        category_ids?: number[];
+        product_ids?: number[];
+        collection?: number | string[];
+        customer_id?: number;
+        cacheId?: string;
+    }): Promise<any>;
+    /**
+     * 获取商品列表（从缓存）
+     */
+    getProducts(): Promise<ProductData[]>;
+    /**
+     * 根据ID获取单个商品（从内存缓存）
+     * 使用 Map 快速查询，时间复杂度 O(1)
+     */
+    getProductById(id: number): Promise<ProductData | undefined>;
+    /**
+     * 清空缓存
+     */
+    clear(): Promise<void>;
+    /**
+     * 从 IndexDB 加载商品数据
+     * @private
+     */
+    private loadProductsFromIndexDB;
+    /**
+     * 保存商品数据到 IndexDB（平铺存储）
+     * @private
+     */
+    private saveProductsToIndexDB;
+    /**
+     * 同步更新商品 Map 缓存
+     * 将 list 中的商品同步到 map，以 id 为 key
+     * @private
+     */
+    private syncProductsMap;
+    /**
+     * 预加载模块数据（统一接口）
+     * 在模块注册后自动调用
+     */
+    preload(): Promise<void>;
+    /**
+     * 获取模块的路由定义
+     * Products 模块暂不提供路由，由 Server 层统一处理
+     */
+    getRoutes(): RouteDefinition[];
+}