"""产品管理服务层。 负责产品分类和产品主档（含规格明细）的增删改查业务逻辑。 依赖 ProductRepository 进行数据持久化，依赖 audit_service 记录操作审计日志。 产品采用"产品名称 + 规格"的二级结构，同一产品名称下可有多条规格记录。 """ from sqlalchemy.exc import SQLAlchemyError from sqlalchemy.orm import Session from backend.app.core.cache import cache_delete_pattern, cache_get, cache_set, make_cache_key from backend.app.core.error_codes import ErrorCode from backend.app.core.exceptions import AppException from backend.app.repositories.product_repository import ProductRepository from backend.app.services.audit_service import audit_service class ProductService: """产品服务，封装产品分类和产品规格的 CRUD 业务逻辑。 依赖: ProductRepository - 产品数据访问 audit_service - 操作审计日志 """ def __init__(self) -> None: self.repository = ProductRepository() def list_categories(self, session: Session | None = None, filters: dict | None = None) -> dict: """查询产品分类列表。 Args: session: 数据库会话 filters: 查询过滤条件 Returns: 包含 total、page_no、page_size、list 的分页字典 被调用路由: products.py - GET /products/categories """ if session is None: raise AppException(code=ErrorCode.PARAM_ERROR, message="数据库会话未初始化", status_code=500) try: categories = self.repository.list_categories(session, filters or {}) return { "total": len(categories), "page_no": 1, "page_size": len(categories) or 20, "list": [ { "category_id": category.id, "category_name": category.category_name, "category_code": category.category_code, "sort_no": category.sort_no, "status": category.status, "remark": category.remark, } for category in categories ], } except SQLAlchemyError as exc: raise AppException(code=ErrorCode.SYSTEM_ERROR, message="数据库操作失败", status_code=500) from exc def create_category(self, payload: dict, session: Session | None = None) -> dict: """创建产品分类。 校验分类名称和编码非空，并检查编码唯一性。自动记录审计日志。 Args: payload: 包含 category_name、category_code 的请求体 session: 数据库会话 Returns: 包含 category_id、category_name、category_code、status 的结果字典 被调用路由: products.py - POST /products/categories """ if session is None: raise AppException(code=ErrorCode.PARAM_ERROR, message="数据库会话未初始化", status_code=500) try: if not payload["category_name"].strip(): raise AppException(code=ErrorCode.PARAM_ERROR, message="分类名称不能为空", status_code=400) if not payload["category_code"].strip(): raise AppException(code=ErrorCode.PARAM_ERROR, message="分类编码不能为空", status_code=400) existed = self.repository.get_category_by_code(session, payload["category_code"]) if existed is not None: raise AppException(code=ErrorCode.DUPLICATE, message="分类编码已存在", status_code=400) category = self.repository.create_category(session, payload) audit_service.write_log( session, { "operate_type": "product_category_create", "biz_type": "product_category", "biz_id": category.id, "before_value": None, "after_value": {"category_name": category.category_name, "category_code": category.category_code}, "remark": f"新增产品分类 {category.category_name}", }, ) session.commit() cache_delete_pattern("product:*") return { "category_id": category.id, "category_name": category.category_name, "category_code": category.category_code, "status": category.status, } except AppException: session.rollback() raise except SQLAlchemyError as exc: session.rollback() raise AppException(code=ErrorCode.SYSTEM_ERROR, message="数据库操作失败", status_code=500) from exc def update_category(self, category_id: int, payload: dict, session: Session | None = None) -> dict: """更新产品分类。 校验分类编码唯一性（排除自身）。 Args: category_id: 分类 ID payload: 包含更新字段的请求体 session: 数据库会话 Returns: 更新结果字典 被调用路由: products.py - PUT /products/categories/{category_id} """ if session is None: raise AppException(code=ErrorCode.PARAM_ERROR, message="数据库会话未初始化", status_code=500) try: if not payload["category_name"].strip(): raise AppException(code=ErrorCode.PARAM_ERROR, message="分类名称不能为空", status_code=400) if not payload["category_code"].strip(): raise AppException(code=ErrorCode.PARAM_ERROR, message="分类编码不能为空", status_code=400) category = self.repository.get_category(session, category_id) if category is None: raise AppException(code=ErrorCode.NOT_FOUND, message="产品分类不存在", status_code=404) existed = self.repository.get_category_by_code(session, payload["category_code"]) if existed is not None and existed.id != category_id: raise AppException(code=ErrorCode.DUPLICATE, message="分类编码已存在", status_code=400) self.repository.update_category(session, category, payload) session.commit() cache_delete_pattern("product:*") return {"category_id": category_id, "updated": True} except AppException: session.rollback() raise except SQLAlchemyError as exc: session.rollback() raise AppException(code=ErrorCode.SYSTEM_ERROR, message="数据库操作失败", status_code=500) from exc def _group_products(self, products: list, categories: dict[int, object]) -> list[dict]: """将产品规格列表按产品名称分组。 同一产品名称下的多条规格记录合并为一条，规格列表放在 specifications 字段中。 自动将第一条规格标记为默认（若无显式默认）。 Args: products: 产品 ORM 对象列表 categories: 分类 ID 到分类 ORM 对象的映射 Returns: 按产品名称分组后的产品列表 """ grouped: dict[str, dict] = {} for product in products: key = product.product_name category_name = categories[product.category_id].category_name if product.category_id in categories else (product.category or "") entry = grouped.setdefault( key, { "product_name": product.product_name, "product_id": product.id, "category_id": product.category_id, "category_name": category_name, "status": product.status, "remark": product.remark, "specifications": [], }, ) entry["specifications"].append( { "product_id": product.id, "specification": product.specification, "unit": product.unit, "cost_price": float(product.cost_price or 0), "sale_price": float(product.sale_price or 0), "status": product.status, "remark": product.remark, "is_default": bool(getattr(product, "is_default", 0)), } ) for entry in grouped.values(): if entry["specifications"] and not any(spec["is_default"] for spec in entry["specifications"]): entry["specifications"][0]["is_default"] = True return list(grouped.values()) def list_products(self, filters: dict | None = None, session: Session | None = None) -> dict: """查询产品列表（按名称分组）。 先查询所有产品规格，再按产品名称分组聚合。 Args: filters: 查询过滤条件 session: 数据库会话 Returns: 包含 total、page_no、page_size、list 的分页字典 被调用路由: products.py - GET /products """ if session is None: raise AppException(code=ErrorCode.PARAM_ERROR, message="数据库会话未初始化", status_code=500) cache_key = make_cache_key("product:list", **(filters or {})) cached = cache_get(cache_key) if cached is not None: return cached try: products = self.repository.list_products(session, filters or {}) categories = {category.id: category for category in self.repository.list_categories(session, {})} grouped_list = self._group_products(products, categories) result = { "total": len(grouped_list), "page_no": 1, "page_size": len(grouped_list) or 20, "list": grouped_list, } cache_set(cache_key, result, ttl=120) return result except SQLAlchemyError as exc: raise AppException(code=ErrorCode.SYSTEM_ERROR, message="数据库操作失败", status_code=500) from exc def update_product(self, product_id: int, payload: dict, session: Session | None = None) -> dict: """更新产品主档信息（名称、分类、状态等）。 仅更新产品级别的公共字段，不影响规格明细。 Args: product_id: 产品 ID payload: 包含更新字段的请求体 session: 数据库会话 Returns: 更新结果字典 被调用路由: products.py - PUT /products/{product_id} """ if session is None: raise AppException(code=ErrorCode.PARAM_ERROR, message="数据库会话未初始化", status_code=500) try: product = self.repository.get_product(session, product_id) if product is None: raise AppException(code=ErrorCode.NOT_FOUND, message="产品主档不存在", status_code=404) if not payload["product_name"].strip(): raise AppException(code=ErrorCode.PARAM_ERROR, message="产品名称不能为空", status_code=400) category = None if payload.get("category_id") is not None: category = self.repository.get_category(session, payload["category_id"]) if category is None or category.status != 1: raise AppException(code=ErrorCode.NOT_FOUND, message="产品分类不存在或已停用", status_code=404) product.product_name = payload["product_name"] product.category_id = payload.get("category_id") product.category = category.category_name if category else None product.status = payload.get("status", product.status) product.remark = payload.get("remark", product.remark) session.add(product) session.commit() cache_delete_pattern("product:*") return {"product_id": product.id, "product_name": product.product_name, "updated": True} except AppException: session.rollback() raise except SQLAlchemyError as exc: session.rollback() raise AppException(code=ErrorCode.SYSTEM_ERROR, message="数据库操作失败", status_code=500) from exc def update_product_specification(self, product_id: int, payload: dict, session: Session | None = None) -> dict: """更新产品规格明细。 校验规格在同一产品下唯一，可修改规格名称、单位、价格等。 Args: product_id: 产品（规格） ID payload: 包含 specification、unit、cost_price、sale_price 等的请求体 session: 数据库会话 Returns: 更新结果字典 被调用路由: products.py - PUT /products/{product_id}/specification """ if session is None: raise AppException(code=ErrorCode.PARAM_ERROR, message="数据库会话未初始化", status_code=500) try: product = self.repository.get_product(session, product_id) if product is None: raise AppException(code=ErrorCode.NOT_FOUND, message="产品规格不存在", status_code=404) if not payload["specification"].strip(): raise AppException(code=ErrorCode.PARAM_ERROR, message="产品规格不能为空", status_code=400) if not payload["unit"].strip(): raise AppException(code=ErrorCode.PARAM_ERROR, message="产品单位不能为空", status_code=400) existed = self.repository.get_product_by_name_and_specification(session, product.product_name, payload["specification"]) if existed is not None and existed.id != product_id: raise AppException(code=ErrorCode.DUPLICATE, message="同一产品下的规格不能重复", status_code=400) category = None if payload.get("category_id") is not None: category = self.repository.get_category(session, payload["category_id"]) if category is None or category.status != 1: raise AppException(code=ErrorCode.NOT_FOUND, message="产品分类不存在或已停用", status_code=404) product.specification = payload["specification"] product.unit = payload["unit"] product.category_id = payload.get("category_id") product.category = category.category_name if category else product.category product.cost_price = payload.get("cost_price", product.cost_price) product.sale_price = payload.get("sale_price", product.sale_price) product.status = payload.get("status", product.status) product.remark = payload.get("remark", product.remark) session.add(product) session.commit() cache_delete_pattern("product:*") return {"product_id": product.id, "product_name": product.product_name, "updated": True} except AppException: session.rollback() raise except SQLAlchemyError as exc: session.rollback() raise AppException(code=ErrorCode.SYSTEM_ERROR, message="数据库操作失败", status_code=500) from exc def add_specification(self, product_id: int, payload: dict, session: Session | None = None) -> dict: """给已有产品追加一条规格明细。 根据 product_id 找到所属产品，校验规格名不重复后创建新规格记录。 Args: product_id: 产品组中任一规格的 ID payload: 包含 specification、unit、cost_price、sale_price 等的请求体 session: 数据库会话 Returns: 创建结果字典 被调用路由: products.py - POST /products/{product_id}/specifications """ if session is None: raise AppException(code=ErrorCode.PARAM_ERROR, message="数据库会话未初始化", status_code=500) try: product = self.repository.get_product(session, product_id) if product is None: raise AppException(code=ErrorCode.NOT_FOUND, message="产品不存在", status_code=404) if not payload.get("specification", "").strip(): raise AppException(code=ErrorCode.PARAM_ERROR, message="产品规格不能为空", status_code=400) if not payload.get("unit", "").strip(): raise AppException(code=ErrorCode.PARAM_ERROR, message="产品单位不能为空", status_code=400) existed = self.repository.get_product_by_name_and_specification( session, product.product_name, payload["specification"] ) if existed is not None: raise AppException(code=ErrorCode.DUPLICATE, message="同一产品下的规格不能重复", status_code=400) category = None if payload.get("category_id") is not None: category = self.repository.get_category(session, payload["category_id"]) new_spec = self.repository.create_product(session, { "product_name": product.product_name, "specification": payload["specification"], "unit": payload["unit"], "category_id": payload.get("category_id") or product.category_id, "category": category.category_name if category else product.category, "cost_price": payload.get("cost_price", 0), "sale_price": payload.get("sale_price", 0), "status": payload.get("status", 1), "remark": payload.get("remark"), }) audit_service.write_log(session, { "operate_type": "product_spec_add", "biz_type": "product", "biz_id": new_spec.id, "after_value": {"product_name": product.product_name, "specification": payload["specification"]}, "remark": f"给产品 {product.product_name} 新增规格 {payload['specification']}", }) cache_delete_pattern("product:*") return {"product_id": new_spec.id, "product_name": product.product_name, "specification": new_spec.specification} except AppException: session.rollback() raise except SQLAlchemyError as exc: session.rollback() raise AppException(code=ErrorCode.SYSTEM_ERROR, message="数据库操作失败", status_code=500) from exc def set_default_specification(self, product_id: int, session: Session | None = None) -> dict: """设置产品默认规格。 将指定规格标记为默认，同名产品下的其他规格清除默认标记。 Args: product_id: 产品（规格） ID session: 数据库会话 Returns: 设置结果字典 被调用路由: products.py - POST /products/{product_id}/set-default """ if session is None: raise AppException(code=ErrorCode.PARAM_ERROR, message="数据库会话未初始化", status_code=500) try: product = self.repository.get_product(session, product_id) if product is None: raise AppException(code=ErrorCode.NOT_FOUND, message="产品规格不存在", status_code=404) siblings = self.repository.list_products(session, {"product_name": product.product_name}) for sibling in siblings: sibling.is_default = 1 if sibling.id == product.id else 0 session.add(sibling) session.flush() session.commit() cache_delete_pattern("product:*") return {"product_id": product.id, "product_name": product.product_name, "is_default": True} except AppException: session.rollback() raise except SQLAlchemyError as exc: session.rollback() raise AppException(code=ErrorCode.SYSTEM_ERROR, message="数据库操作失败", status_code=500) from exc def create_product(self, payload: dict, session: Session | None = None) -> dict: """创建新产品（含规格明细）。 产品名称为公共字段，每条规格明细单独创建一条数据库记录。 同一产品下的规格名称不可重复。自动记录审计日志。 Args: payload: 包含 product_name、category_id、specifications 列表的请求体 session: 数据库会话 Returns: 创建结果字典，包含产品名称和所有规格明细 被调用路由: products.py - POST /products """ if session is None: raise AppException(code=ErrorCode.PARAM_ERROR, message="数据库会话未初始化", status_code=500) try: if not payload["product_name"].strip(): raise AppException(code=ErrorCode.PARAM_ERROR, message="产品名称不能为空", status_code=400) specifications = payload.get("specifications") or [] if not specifications: raise AppException(code=ErrorCode.PARAM_ERROR, message="请至少填写一个规格明细", status_code=400) category = None if payload.get("category_id") is not None: category = self.repository.get_category(session, payload["category_id"]) if category is None or category.status != 1: raise AppException(code=ErrorCode.NOT_FOUND, message="产品分类不存在或已停用", status_code=404) created_specs = [] for spec in specifications: if not spec["specification"].strip(): raise AppException(code=ErrorCode.PARAM_ERROR, message="产品规格不能为空", status_code=400) if not spec["unit"].strip(): raise AppException(code=ErrorCode.PARAM_ERROR, message="产品单位不能为空", status_code=400) existed = self.repository.get_product_by_name_and_specification( session, payload["product_name"], spec["specification"], ) if existed is not None: raise AppException(code=ErrorCode.DUPLICATE, message="同一产品下的规格不能重复", status_code=400) product = self.repository.create_product( session, { "product_name": payload["product_name"], "specification": spec["specification"], "unit": spec["unit"], "category_id": spec.get("category_id") or payload.get("category_id"), "category": category.category_name if category else None, "cost_price": spec.get("cost_price", 0), "sale_price": spec.get("sale_price", 0), "status": spec.get("status", payload.get("status", 1)), "remark": spec.get("remark") or payload.get("remark"), }, ) created_specs.append(product) audit_service.write_log( session, { "operate_type": "product_create", "biz_type": "product", "biz_id": created_specs[0].id if created_specs else 0, "before_value": None, "after_value": { "product_name": payload["product_name"], "spec_count": len(created_specs), "category_id": payload.get("category_id"), }, "remark": f"新增产品 {payload['product_name']}，共 {len(created_specs)} 个规格", }, ) session.commit() cache_delete_pattern("product:*") return { "product_name": payload["product_name"], "product_id": created_specs[0].id if created_specs else None, "specifications": [ { "product_id": item.id, "specification": item.specification, "unit": item.unit, "cost_price": float(item.cost_price or 0), "sale_price": float(item.sale_price or 0), "status": item.status, "remark": item.remark, "is_default": index == 0, } for index, item in enumerate(created_specs) ], } except AppException: session.rollback() raise except SQLAlchemyError as exc: session.rollback() raise AppException(code=ErrorCode.SYSTEM_ERROR, message="数据库操作失败", status_code=500) from exc def get_product(self, product_id: int, session: Session | None = None) -> dict: """查询单个产品详情（含所有规格明细）。 通过产品名称查询同名所有规格，再按分组逻辑返回完整产品信息。 Args: product_id: 产品（规格） ID session: 数据库会话 Returns: 产品详情字典（含 specifications 列表） 被调用路由: products.py - GET /products/{product_id} """ if session is None: raise AppException(code=ErrorCode.PARAM_ERROR, message="数据库会话未初始化", status_code=500) cache_key = f"product:detail:{product_id}" cached = cache_get(cache_key) if cached is not None: return cached try: product = self.repository.get_product(session, product_id) if product is None: raise AppException(code=ErrorCode.NOT_FOUND, message="产品不存在", status_code=404) products = self.repository.list_products(session, {"product_name": product.product_name}) categories = {category.id: category for category in self.repository.list_categories(session, {})} grouped = self._group_products(products, categories) if grouped: cache_set(cache_key, grouped[0], ttl=120) return grouped[0] raise AppException(code=ErrorCode.NOT_FOUND, message="产品不存在", status_code=404) except AppException: raise except SQLAlchemyError as exc: raise AppException(code=ErrorCode.SYSTEM_ERROR, message="数据库操作失败", status_code=500) from exc product_service = ProductService()