x

src/api/inventory/product_routes.py

@@ -11,23 +11,69 @@
 """
 from fastapi import APIRouter, Depends, HTTPException, Query
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, or_
-from typing import Optional, List
+from sqlalchemy import select, or_, func, delete
+from typing import Optional, List, Dict
 
 from database.database import get_db_session
 from services.auth_service import get_current_active_user, get_current_admin_user
-from models.database import User, Product
-from .schemas import ProductCreate, ProductResponse
+from models.database import User, Product, ProductMaterial
+from .schemas import (
+    ProductCreate,
+    ProductResponse,
+    ProductBOMUpdate,
+    ProductBOMResponse,
+    ProductMaterialItemResponse
+)
 
 router = APIRouter(prefix="/products", tags=["产品管理"])
 
 
+async def _calculate_material_cost_map(db_session: AsyncSession, product_ids: List[int]) -> Dict[int, float]:
+    if not product_ids:
+        return {}
+    result = await db_session.execute(
+        select(
+            ProductMaterial.finished_product_id,
+            func.coalesce(
+                func.sum(
+                    Product.cost_price * ProductMaterial.quantity * (1 + ProductMaterial.loss_rate)
+                ),
+                0
+            )
+        )
+        .join(Product, ProductMaterial.material_product_id == Product.id)
+        .where(ProductMaterial.finished_product_id.in_(product_ids))
+        .group_by(ProductMaterial.finished_product_id)
+    )
+    return {row[0]: float(row[1] or 0) for row in result.all()}
+
+
+def _build_product_response(product: Product, material_cost: float = 0) -> ProductResponse:
+    return ProductResponse(
+        id=product.id,
+        sku=product.sku,
+        name=product.name,
+        description=product.description,
+        category=product.category,
+        unit=product.unit,
+        item_type=product.item_type,
+        cost_price=float(product.cost_price or 0),
+        sale_price=float(product.sale_price or 0),
+        min_stock=product.min_stock,
+        max_stock=product.max_stock,
+        material_cost=round(float(material_cost), 4),
+        is_active=product.is_active,
+        created_at=product.created_at,
+    )
+
+
 @router.get("", response_model=List[ProductResponse])
 async def list_products(
     skip: int = Query(0, ge=0),
     limit: int = Query(20, ge=1, le=100),
     search: Optional[str] = None,
     category: Optional[str] = None,
+    item_type: Optional[str] = None,
     db_session: AsyncSession = Depends(get_db_session),
     current_user: User = Depends(get_current_active_user)
 ):
@@ -37,11 +83,15 @@ async def list_products(
         query = query.where(or_(Product.name.ilike(f"%{search}%"), Product.sku.ilike(f"%{search}%")))
     if category:
         query = query.where(Product.category == category)
+    if item_type:
+        query = query.where(Product.item_type == item_type)
     
     query = query.offset(skip).limit(limit).order_by(Product.created_at.desc())
     result = await db_session.execute(query)
     products = result.scalars().all()
-    return [ProductResponse.from_orm(p) for p in products]
+    finished_product_ids = [p.id for p in products if p.item_type == "finished"]
+    material_cost_map = await _calculate_material_cost_map(db_session, finished_product_ids)
+    return [_build_product_response(p, material_cost_map.get(p.id, 0)) for p in products]
 
 
 @router.post("", response_model=ProductResponse, status_code=201)
@@ -50,15 +100,21 @@ async def create_product(
     db_session: AsyncSession = Depends(get_db_session),
     current_user: User = Depends(get_current_active_user)
 ):
+    if product_data.item_type not in ["material", "finished"]:
+        raise HTTPException(status_code=400, detail="item_type 必须为 material 或 finished")
     existing = await db_session.execute(select(Product).where(Product.sku == product_data.sku))
     if existing.scalar_one_or_none():
         raise HTTPException(status_code=400, detail="SKU已存在")
     
-    product = Product(**product_data.dict())
+    product_dict = product_data.dict()
+    if product_data.item_type == "finished":
+        product_dict["min_stock"] = 0
+        product_dict["max_stock"] = 0
+    product = Product(**product_dict)
     db_session.add(product)
     await db_session.commit()
     await db_session.refresh(product)
-    return ProductResponse.from_orm(product)
+    return _build_product_response(product, 0)
 
 
 @router.put("/{product_id}", response_model=ProductResponse)
@@ -72,13 +128,21 @@ async def update_product(
     product = result.scalar_one_or_none()
     if not product:
         raise HTTPException(status_code=404, detail="产品不存在")
+    if product_data.item_type not in ["material", "finished"]:
+        raise HTTPException(status_code=400, detail="item_type 必须为 material 或 finished")
     
-    for key, value in product_data.dict().items():
+    product_dict = product_data.dict()
+    if product_data.item_type == "finished":
+        product_dict["min_stock"] = 0
+        product_dict["max_stock"] = 0
+
+    for key, value in product_dict.items():
         setattr(product, key, value)
     
     await db_session.commit()
     await db_session.refresh(product)
-    return ProductResponse.from_orm(product)
+    material_cost_map = await _calculate_material_cost_map(db_session, [product.id])
+    return _build_product_response(product, material_cost_map.get(product.id, 0))
 
 
 @router.delete("/{product_id}")
@@ -95,3 +159,104 @@ async def delete_product(
     product.is_active = False
     await db_session.commit()
     return {"message": "产品已删除"}
+
+
+@router.get("/{product_id}/materials", response_model=ProductBOMResponse)
+async def get_product_bom(
+    product_id: int,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_current_active_user)
+):
+    product_result = await db_session.execute(
+        select(Product).where(Product.id == product_id, Product.is_active == True)
+    )
+    product = product_result.scalar_one_or_none()
+    if not product:
+        raise HTTPException(status_code=404, detail="产品不存在")
+    if product.item_type != "finished":
+        raise HTTPException(status_code=400, detail="仅成品支持配置物料BOM")
+
+    bom_result = await db_session.execute(
+        select(ProductMaterial, Product)
+        .join(Product, ProductMaterial.material_product_id == Product.id)
+        .where(ProductMaterial.finished_product_id == product_id)
+        .order_by(ProductMaterial.id.asc())
+    )
+
+    items: List[ProductMaterialItemResponse] = []
+    total_material_cost = 0.0
+    for bom, material in bom_result.all():
+        line_cost = float(material.cost_price or 0) * float(bom.quantity) * (1 + float(bom.loss_rate or 0))
+        total_material_cost += line_cost
+        items.append(
+            ProductMaterialItemResponse(
+                material_id=material.id,
+                material_sku=material.sku,
+                material_name=material.name,
+                quantity=round(float(bom.quantity), 4),
+                loss_rate=round(float(bom.loss_rate or 0), 4),
+                unit_cost=round(float(material.cost_price or 0), 4),
+                line_cost=round(float(line_cost), 4),
+            )
+        )
+
+    return ProductBOMResponse(
+        product_id=product.id,
+        product_name=product.name,
+        total_material_cost=round(float(total_material_cost), 4),
+        items=items,
+    )
+
+
+@router.put("/{product_id}/materials", response_model=ProductBOMResponse)
+async def replace_product_bom(
+    product_id: int,
+    payload: ProductBOMUpdate,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_current_active_user)
+):
+    product_result = await db_session.execute(
+        select(Product).where(Product.id == product_id, Product.is_active == True)
+    )
+    product = product_result.scalar_one_or_none()
+    if not product:
+        raise HTTPException(status_code=404, detail="产品不存在")
+    if product.item_type != "finished":
+        raise HTTPException(status_code=400, detail="仅成品支持配置物料BOM")
+
+    material_ids = [item.material_id for item in payload.items]
+    if len(material_ids) != len(set(material_ids)):
+        raise HTTPException(status_code=400, detail="BOM 物料不允许重复")
+
+    if material_ids:
+        material_result = await db_session.execute(
+            select(Product).where(Product.id.in_(material_ids), Product.is_active == True)
+        )
+        materials = material_result.scalars().all()
+        material_map = {m.id: m for m in materials}
+        if len(material_map) != len(material_ids):
+            raise HTTPException(status_code=400, detail="存在无效物料")
+        invalid_materials = [m.name for m in materials if m.item_type != "material"]
+        if invalid_materials:
+            raise HTTPException(status_code=400, detail=f"以下条目不是物料：{', '.join(invalid_materials)}")
+    else:
+        material_map = {}
+
+    await db_session.execute(delete(ProductMaterial).where(ProductMaterial.finished_product_id == product_id))
+
+    for item in payload.items:
+        if item.quantity <= 0:
+            raise HTTPException(status_code=400, detail="物料数量必须大于0")
+        if item.loss_rate < 0:
+            raise HTTPException(status_code=400, detail="损耗率不能为负数")
+        db_session.add(
+            ProductMaterial(
+                finished_product_id=product_id,
+                material_product_id=item.material_id,
+                quantity=item.quantity,
+                loss_rate=item.loss_rate,
+            )
+        )
+
+    await db_session.commit()
+    return await get_product_bom(product_id, db_session, current_user)