@pisell/pisellos 2.1.41 → 2.2.2

package/lib/server/index.js

@@ -0,0 +1,555 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  default: () => server_default
+});
+module.exports = __toCommonJS(server_exports);
+var import_products = require("./modules/products");
+var import_menu = require("./modules/menu");
+var import_quotation = require("./modules/quotation");
+var import_schedule = require("./modules/schedule");
+var import_schedule2 = require("./utils/schedule");
+__reExport(server_exports, require("./modules"), module.exports);
+var Server = class {
+  constructor(core) {
+    // 路由注册表
+    this.router = {
+      get: {},
+      post: {},
+      put: {},
+      remove: {}
+    };
+    // 模块注册表 - 定义所有可用的模块配置
+    this.moduleRegistry = {
+      products: {
+        name: "products",
+        moduleClass: import_products.ProductsModule,
+        moduleName: "server_products",
+        version: "1.0.0",
+        defaultStore: {
+          list: [],
+          selectProducts: []
+        }
+      },
+      menu: {
+        name: "menu",
+        moduleClass: import_menu.MenuModule,
+        moduleName: "server_menu",
+        version: "1.0.0",
+        defaultStore: {
+          menuList: []
+        }
+      },
+      quotation: {
+        name: "quotation",
+        moduleClass: import_quotation.QuotationModule,
+        moduleName: "server_quotation",
+        version: "1.0.0",
+        defaultStore: {
+          quotationList: []
+        }
+      },
+      schedule: {
+        name: "schedule",
+        moduleClass: import_schedule.ScheduleModuleEx,
+        moduleName: "server_schedule",
+        version: "1.1.0",
+        defaultStore: {
+          scheduleList: [],
+          availabilityDateList: [],
+          otherProductsIds: []
+        }
+      }
+    };
+    /**
+     * 处理商品查询请求（编排 Products、Menu、Schedule 模块）
+     * 这是一个业务编排方法，协调多个模块完成复杂的业务需求
+     */
+    this.handleProductQuery = async ({ url, method, data, config }) => {
+      console.log("[Server] handleProductQuery:", url, method, data, config);
+      const { menu_list_ids, schedule_datetime, schedule_date } = data;
+      if (!this.products) {
+        console.error("[Server] Products 模块未注册");
+        return {
+          message: "Products 模块未注册",
+          data: { list: [], count: 0 }
+        };
+      }
+      if (!this.menu) {
+        console.error("[Server] Menu 模块未注册");
+        return {
+          message: "Menu 模块未注册",
+          data: { list: [], count: 0 }
+        };
+      }
+      if (!this.schedule) {
+        console.error("[Server] Schedule 模块未注册");
+        return {
+          message: "Schedule 模块未注册",
+          data: { list: [], count: 0 }
+        };
+      }
+      let activeMenuList = [];
+      if (menu_list_ids && Array.isArray(menu_list_ids) && menu_list_ids.length > 0) {
+        console.log("[Server] 获取餐牌详情，IDs:", menu_list_ids);
+        const menuList = this.menu.getMenuByIds(menu_list_ids);
+        activeMenuList = menuList.filter((menu) => {
+          var _a;
+          return ((_a = this.schedule) == null ? void 0 : _a.getDateIsInSchedule(schedule_datetime, menu.schedule)) || false;
+        });
+      }
+      console.log(activeMenuList, "activeMenuList");
+      const allProductsWithPrice = await this.products.getProductsWithPrice(data.schedule_date, {
+        scheduleModule: this.getSchedule()
+      });
+      console.log(allProductsWithPrice, "allProductsWithPrice");
+      let filteredProducts = this.filterProductsByMenuConfig(allProductsWithPrice, activeMenuList);
+      filteredProducts = filteredProducts.sort((a, b) => {
+        const sortDiff = Number(b.sort) - Number(a.sort);
+        if (sortDiff !== 0) {
+          return sortDiff;
+        }
+        return (a.title || "").localeCompare(b.title || "");
+      });
+      console.log("[Server] 原始商品数量:", allProductsWithPrice.length);
+      console.log("[Server] 过滤后商品数量:", filteredProducts.length);
+      console.log(filteredProducts, "filteredProducts");
+      return {
+        code: 200,
+        data: {
+          list: filteredProducts,
+          count: filteredProducts.length
+        },
+        message: "",
+        status: true
+      };
+    };
+    /**
+     * 处理获取日程时间段点的请求
+     * 通过餐牌ID列表获取所有相关日程的时间段点
+     */
+    this.handleGetScheduleTimePoints = async ({ url, method, data, config }) => {
+      console.log("[Server] handleGetScheduleTimePoints:", url, method, data, config);
+      const { menu_list_ids } = data;
+      if (!this.menu) {
+        console.error("[Server] Menu 模块未注册");
+        return {
+          code: 500,
+          message: "Menu 模块未注册",
+          data: [],
+          status: false
+        };
+      }
+      if (!this.schedule) {
+        console.error("[Server] Schedule 模块未注册");
+        return {
+          code: 500,
+          message: "Schedule 模块未注册",
+          data: [],
+          status: false
+        };
+      }
+      if (!menu_list_ids || !Array.isArray(menu_list_ids) || menu_list_ids.length === 0) {
+        console.error("[Server] menu_list_ids 参数无效");
+        return {
+          code: 400,
+          message: "menu_list_ids 参数无效",
+          data: [],
+          status: false
+        };
+      }
+      try {
+        const menuList = this.menu.getMenuByIds(menu_list_ids);
+        console.log(`[Server] 找到 ${menuList.length} 个餐牌`);
+        const scheduleIds = (0, import_schedule2.extractScheduleIdsFromMenus)(menuList);
+        console.log(`[Server] 提取到 ${scheduleIds.length} 个日程ID:`, scheduleIds);
+        if (scheduleIds.length === 0) {
+          return {
+            code: 200,
+            message: "没有找到相关日程",
+            data: [],
+            status: true
+          };
+        }
+        const scheduleList = this.schedule.getScheduleByIds(scheduleIds);
+        console.log(`[Server] 找到 ${scheduleList.length} 个日程`);
+        const timePoints = (0, import_schedule2.extractTimePointsFromSchedules)(scheduleList);
+        console.log(`[Server] 提取到 ${timePoints.length} 个时间点:`, timePoints);
+        return {
+          code: 200,
+          message: "获取成功",
+          data: timePoints,
+          status: true
+        };
+      } catch (error) {
+        console.error("[Server] 获取日程时间点失败:", error);
+        return {
+          code: 500,
+          message: `获取失败: ${error instanceof Error ? error.message : "未知错误"}`,
+          data: [],
+          status: false
+        };
+      }
+    };
+    this.core = core;
+    console.log("[Server] Server 初始化");
+  }
+  /**
+   * 注册路由
+   * @param routes 路由定义数组
+   */
+  registerRoutes(routes) {
+    routes.forEach((route) => {
+      const { method, path, handler } = route;
+      if (!this.router[method]) {
+        console.warn(`[Server] 不支持的 HTTP 方法: ${method}`);
+        return;
+      }
+      if (this.router[method][path]) {
+        console.warn(`[Server] 路由已存在，将被覆盖: ${method.toUpperCase()} ${path}`);
+      }
+      this.router[method][path] = handler;
+      console.log(`[Server] 📝 注册路由: ${method.toUpperCase()} ${path}`);
+    });
+  }
+  /**
+   * 注册单个模块并自动注册其路由
+   * @param module 模块实例
+   * @param options 模块配置
+   * @param moduleName 模块名称（用于日志）
+   */
+  async registerModuleWithRoutes(module2, options, moduleName) {
+    await this.core.registerModule(module2, options);
+    console.log(`[Server] ✅ ${moduleName} 模块已注册`);
+    if (typeof module2.getRoutes === "function") {
+      const routes = module2.getRoutes();
+      if (routes && routes.length > 0) {
+        this.registerRoutes(routes);
+      }
+    }
+  }
+  /**
+   * 根据模块名称注册单个模块
+   * @param moduleConfig 模块配置（可以是字符串或配置对象）
+   */
+  async registerModuleByName(moduleConfig) {
+    const moduleName = typeof moduleConfig === "string" ? moduleConfig : moduleConfig.name;
+    const shouldPreload = typeof moduleConfig === "object" ? moduleConfig.preload !== false : true;
+    const customConfig = typeof moduleConfig === "object" ? moduleConfig.config : {};
+    const registryConfig = this.moduleRegistry[moduleName];
+    if (!registryConfig) {
+      throw new Error(`[Server] 未找到模块配置: ${moduleName}`);
+    }
+    const ModuleClass = registryConfig.moduleClass;
+    const moduleInstance = new ModuleClass(registryConfig.moduleName, registryConfig.version);
+    const moduleOptions = {
+      store: { ...registryConfig.defaultStore },
+      ...customConfig
+    };
+    await this.registerModuleWithRoutes(
+      moduleInstance,
+      moduleOptions,
+      moduleName.charAt(0).toUpperCase() + moduleName.slice(1)
+    );
+    this[moduleName] = moduleInstance;
+    return { module: moduleInstance, config: registryConfig, shouldPreload };
+  }
+  /**
+   * 注册指定的服务端模块
+   * @param moduleConfigs 要注册的模块配置数组（模块名称或配置对象）
+   */
+  async registerModules(moduleConfigs) {
+    console.log("[Server] 开始注册模块...");
+    const configs = moduleConfigs || Object.keys(this.moduleRegistry);
+    const registeredModules = [];
+    for (const config of configs) {
+      try {
+        const result = await this.registerModuleByName(config);
+        registeredModules.push(result);
+      } catch (error) {
+        console.error(`[Server] 模块注册失败:`, error);
+        throw error;
+      }
+    }
+    console.log("[Server] ✅ 所有模块注册完成");
+    return registeredModules;
+  }
+  /**
+   * 预加载指定模块的数据
+   * @param registeredModules 已注册的模块信息
+   */
+  async preloadModulesData(registeredModules, options) {
+    var _a, _b;
+    console.log("[Server] 开始预加载模块数据...");
+    for (const { module: module2, config, shouldPreload } of registeredModules) {
+      if (!shouldPreload) {
+        console.log(`[Server] ⏭️ 跳过 ${config.name} 模块预加载`);
+        continue;
+      }
+      if (typeof module2.preload === "function") {
+        try {
+          (_a = options == null ? void 0 : options.onModuleLoad) == null ? void 0 : _a.call(options, config.name);
+          await module2.preload();
+          (_b = options == null ? void 0 : options.onModuleLoadComplete) == null ? void 0 : _b.call(options, config.name);
+          console.log(`[Server] ✅ ${config.name} 模块数据已预加载`);
+        } catch (error) {
+          console.error(`[Server] ❌ ${config.name} 模块预加载失败:`, error);
+        }
+      } else {
+        console.log(`[Server] ⚠️ ${config.name} 模块未实现 preload() 方法`);
+      }
+    }
+    console.log("[Server] ✅ 所有模块数据预加载完成");
+  }
+  /**
+   * 初始化 Server（注册模块并预加载数据）
+   * @param moduleConfigs 要注册的模块配置
+   * @param autoPreload 是否自动预加载数据
+   */
+  async initialize(moduleConfigs, autoPreload = true, options) {
+    this.registerServerRoutes();
+    const registeredModules = await this.registerModules(moduleConfigs);
+    if (autoPreload) {
+      await this.preloadModulesData(registeredModules, options);
+    }
+    return registeredModules;
+  }
+  /**
+   * 获取 Products 模块实例
+   */
+  getProducts() {
+    return this.products;
+  }
+  /**
+   * 获取 Menu 模块实例
+   */
+  getMenu() {
+    return this.menu;
+  }
+  /**
+   * 获取 Quotation 模块实例
+   */
+  getQuotation() {
+    return this.quotation;
+  }
+  /**
+   * 获取 Schedule 模块实例
+   */
+  getSchedule() {
+    return this.schedule;
+  }
+  /**
+   * 获取所有已注册的模块列表
+   */
+  getRegisteredModules() {
+    const modules = [];
+    if (this.products)
+      modules.push("products");
+    if (this.menu)
+      modules.push("menu");
+    if (this.quotation)
+      modules.push("quotation");
+    if (this.schedule)
+      modules.push("schedule");
+    return modules;
+  }
+  /**
+   * 清空所有server模块的IndexedDB缓存
+   * @returns Promise<void>
+   */
+  async clearAllIndexDB() {
+    console.log("[Server] 开始清空所有模块的IndexedDB缓存...");
+    const clearTasks = [];
+    const moduleNames = [];
+    if (this.products) {
+      clearTasks.push(this.products.clear());
+      moduleNames.push("Products");
+    }
+    if (this.menu) {
+      clearTasks.push(this.menu.clear());
+      moduleNames.push("Menu");
+    }
+    if (this.quotation) {
+      clearTasks.push(this.quotation.clear());
+      moduleNames.push("Quotation");
+    }
+    if (this.schedule) {
+      clearTasks.push(this.schedule.clear());
+      moduleNames.push("Schedule");
+    }
+    if (clearTasks.length === 0) {
+      console.warn("[Server] 没有找到已注册的模块，无需清空");
+      return;
+    }
+    try {
+      await Promise.all(clearTasks);
+      console.log(`[Server] ✅ 已成功清空所有模块的IndexedDB缓存: ${moduleNames.join(", ")}`);
+    } catch (error) {
+      console.error("[Server] ❌ 清空IndexedDB缓存时发生错误:", error);
+      throw error;
+    }
+  }
+  /**
+   * 获取所有注册的路由
+   */
+  getRoutes() {
+    return this.router;
+  }
+  /**
+   * 根据方法和路径获取路由处理函数
+   * @param method HTTP 方法
+   * @param path 路径
+   */
+  getRouteHandler(method, path) {
+    var _a;
+    return (_a = this.router[method]) == null ? void 0 : _a[path];
+  }
+  /**
+   * 检查路由是否存在
+   * @param method HTTP 方法
+   * @param path 路径
+   */
+  hasRoute(method, path) {
+    var _a;
+    console.log(method, path, "method, path");
+    return !!((_a = this.router[method]) == null ? void 0 : _a[path]);
+  }
+  /**
+   * 执行路由处理函数
+   * @param method HTTP 方法
+   * @param path 路径
+   * @param params 请求参数
+   */
+  async handleRoute(method, path, params) {
+    console.log(method, path, params, "method, path, params");
+    const handler = this.getRouteHandler(method, path);
+    if (!handler) {
+      throw new Error(`Route not found: ${method.toUpperCase()} ${path}`);
+    }
+    try {
+      return await handler(params);
+    } catch (error) {
+      console.error(`[Server] 路由处理错误: ${method.toUpperCase()} ${path}`, error);
+      throw error;
+    }
+  }
+  /**
+   * 获取所有路由列表（用于调试和文档）
+   */
+  getAllRoutes() {
+    const routes = [];
+    ["get", "post", "put", "remove"].forEach((method) => {
+      Object.keys(this.router[method]).forEach((path) => {
+        routes.push({ method, path });
+      });
+    });
+    return routes;
+  }
+  /**
+   * 注册 Server 层的业务路由
+   * 这些路由需要编排多个模块的数据
+   * @private
+   */
+  registerServerRoutes() {
+    console.log("[Server] 注册 Server 层业务路由...");
+    this.registerRoutes([
+      {
+        method: "post",
+        path: "/shop/product/query",
+        handler: this.handleProductQuery.bind(this)
+      },
+      {
+        method: "post",
+        path: "/shop/menu/schedule-time-points",
+        handler: this.handleGetScheduleTimePoints.bind(this)
+      }
+    ]);
+  }
+  /**
+   * 根据餐牌配置过滤商品
+   * @param products 所有商品列表
+   * @param activeMenuList 生效的餐牌列表
+   * @returns 过滤后的商品列表
+   * @private
+   */
+  filterProductsByMenuConfig(products, activeMenuList) {
+    if (!activeMenuList || activeMenuList.length === 0) {
+      console.log("[Server] 没有生效的餐牌，返回空数组");
+      return [];
+    }
+    let allowedProductIds = /* @__PURE__ */ new Set();
+    let allowedCollectionIds = /* @__PURE__ */ new Set();
+    let hasProductAll = false;
+    for (const menu of activeMenuList) {
+      const config = menu.partyroom_package;
+      if (!config) {
+        console.warn("[Server] 餐牌缺少 partyroom_package 配置:", menu);
+        continue;
+      }
+      if (config.type === "product_all") {
+        console.log("[Server] 餐牌允许所有商品:", menu.name);
+        hasProductAll = true;
+        break;
+      }
+      if (config.type === "products" && Array.isArray(config.products)) {
+        const productIds = config.products.map((item) => item.product_id);
+        productIds.forEach((id) => id && allowedProductIds.add(id));
+        console.log("[Server] 餐牌允许指定商品 (product_ids):", menu.name, productIds);
+      }
+      if (config.type === "product_collection" && Array.isArray(config.products)) {
+        const collectionIds = config.products.map((item) => item.product_collection_id);
+        collectionIds.forEach((id) => id && allowedCollectionIds.add(id));
+        console.log("[Server] 餐牌允许商品集合 (product_collection):", menu.name, collectionIds);
+      }
+    }
+    if (hasProductAll) {
+      return products;
+    }
+    if (allowedProductIds.size === 0 && allowedCollectionIds.size === 0) {
+      console.log("[Server] 没有允许的商品和集合");
+      return [];
+    }
+    console.log("[Server] 允许的商品 IDs:", Array.from(allowedProductIds));
+    console.log("[Server] 允许的集合 IDs:", Array.from(allowedCollectionIds));
+    const filteredProducts = products.filter((product) => {
+      if (allowedProductIds.has(product.id)) {
+        return true;
+      }
+      if (allowedCollectionIds.size > 0 && Array.isArray(product.collection)) {
+        const hasMatchingCollection = product.collection.some(
+          (col) => allowedCollectionIds.has(col.id)
+        );
+        if (hasMatchingCollection) {
+          return true;
+        }
+      }
+      return false;
+    });
+    console.log("[Server] 过滤结果: 原始 %d 个，过滤后 %d 个", products.length, filteredProducts.length);
+    return filteredProducts;
+  }
+};
+var server_default = Server;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./modules")
+});

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

@@ -0,0 +1,16 @@
+/**
+ * Server 模块导出
+ * 包含新增的 Products、Menu、Quotation 和扩展的 Schedule 模块
+ */
+export { ProductsModule } from './products';
+export type { ProductsState } from './products/types';
+export { ProductsHooks } from './products/types';
+export { MenuModule } from './menu';
+export type { MenuState, MenuData } from './menu/types';
+export { MenuHooks } from './menu/types';
+export { QuotationModule } from './quotation';
+export type { QuotationState, QuotationData, QuotationProductPrice } from './quotation/types';
+export { QuotationHooks } from './quotation/types';
+export { ScheduleModuleEx } from './schedule';
+export type { ScheduleState, ScheduleItem } from './schedule/types';
+export type { RouteHandler, HttpMethod, RouteDefinition, Router, ModuleRegistryConfig, } from '../types';

package/lib/server/modules/index.js

@@ -0,0 +1,47 @@
+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/index.ts
+var modules_exports = {};
+__export(modules_exports, {
+  MenuHooks: () => import_types2.MenuHooks,
+  MenuModule: () => import_menu.MenuModule,
+  ProductsHooks: () => import_types.ProductsHooks,
+  ProductsModule: () => import_products.ProductsModule,
+  QuotationHooks: () => import_types3.QuotationHooks,
+  QuotationModule: () => import_quotation.QuotationModule,
+  ScheduleModuleEx: () => import_schedule.ScheduleModuleEx
+});
+module.exports = __toCommonJS(modules_exports);
+var import_products = require("./products");
+var import_types = require("./products/types");
+var import_menu = require("./menu");
+var import_types2 = require("./menu/types");
+var import_quotation = require("./quotation");
+var import_types3 = require("./quotation/types");
+var import_schedule = require("./schedule");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MenuHooks,
+  MenuModule,
+  ProductsHooks,
+  ProductsModule,
+  QuotationHooks,
+  QuotationModule,
+  ScheduleModuleEx
+});

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

@@ -0,0 +1,63 @@
+import { Module, PisellCore, ModuleOptions } from '../../../types';
+import { BaseModule } from '../../../modules/BaseModule';
+import type { RouteDefinition } from '../../types';
+import { MenuData } from './types';
+/**
+ * 餐牌模块 - 用于管理餐牌数据和根据餐牌过滤商品
+ */
+export declare class MenuModule 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>;
+    /**
+     * 加载餐牌列表（从服务器）
+     */
+    loadMenuList(): Promise<MenuData[]>;
+    /**
+     * 设置餐牌列表
+     */
+    setMenuList(menuList: MenuData[]): Promise<void>;
+    /**
+     * 获取餐牌列表
+     */
+    getMenuList(): MenuData[];
+    /**
+     * 根据 form_record_id 数组获取餐牌详情
+     * 使用 Map 快速查询，时间复杂度 O(m)，m 为 ids 数量
+     */
+    getMenuByIds(ids: number[]): MenuData[];
+    /**
+     * 同步更新餐牌 Map 缓存
+     * 将 menuList 中的餐牌同步到 map，以 form_record_id 为 key
+     * @private
+     */
+    private syncMenuMap;
+    /**
+     * 清空缓存
+     */
+    clear(): Promise<void>;
+    /**
+     * 从 IndexDB 加载餐牌数据
+     * @private
+     */
+    private loadMenuFromIndexDB;
+    /**
+     * 保存餐牌数据到 IndexDB
+     * @private
+     */
+    private saveMenuToIndexDB;
+    /**
+     * 预加载模块数据（统一接口）
+     * 在模块注册后自动调用
+     */
+    preload(): Promise<void>;
+    /**
+     * 获取模块的路由定义
+     * 返回该模块需要注册的 API 路由
+     */
+    getRoutes(): RouteDefinition[];
+}