feat: 移除PDI和订单号字段，新增设备巡检模块

- 从物料跟踪页面移除订单号列和表单字段 - 从导航菜单移除PDI管理，添加设备巡检 - 新增InspectionLocation和InspectionRecord后端模型和API - 新增设备巡检前端页面（左侧点位列表，右侧设备和历史记录）
2026-05-27 16:38:40 +08:00
commit 193da0018f
86 changed files with 11379 additions and 0 deletions
--- a/backend/app/api/init.py
+++ b/backend/app/api/init.py
@@ -0,0 +1,17 @@
+from fastapi import APIRouter
+from app.api import auth, material, production, plan, downtime, equipment, message, dashboard
+from app.api import prediction, pdi, quality, inspection
+
+router = APIRouter()
+router.include_router(auth.router,        prefix="/auth",       tags=["认证"])
+router.include_router(dashboard.router,   prefix="/dashboard",  tags=["看板"])
+router.include_router(material.router,    prefix="/material",   tags=["物料跟踪"])
+router.include_router(production.router,  prefix="/production", tags=["实绩管理"])
+router.include_router(plan.router,        prefix="/plan",       tags=["计划管理"])
+router.include_router(downtime.router,    prefix="/downtime",   tags=["停机管理"])
+router.include_router(equipment.router,   prefix="/equipment",  tags=["设备管理"])
+router.include_router(message.router,     prefix="/message",    tags=["报文管理"])
+router.include_router(prediction.router,  prefix="/prediction", tags=["工艺预测模型"])
+router.include_router(pdi.router,         prefix="/pdi",        tags=["PDI管理"])
+router.include_router(quality.router,     prefix="/quality",    tags=["质量管理"])
+router.include_router(inspection.router,  prefix="/inspection", tags=["设备巡检"])
--- a/backend/app/api/auth.py
+++ b/backend/app/api/auth.py
@@ -0,0 +1,48 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from app.database import get_db
+from app.models.user import User
+from app.schemas.user import LoginRequest, Token, UserCreate, UserOut
+from app.schemas.common import Response
+from app.services.auth_service import (
+    authenticate_user, create_access_token, hash_password,
+    get_current_user, require_roles
+)
+
+router = APIRouter()
+
+
+@router.post("/login", response_model=Response[Token])
+async def login(body: LoginRequest, db: AsyncSession = Depends(get_db)):
+    user = await authenticate_user(db, body.username, body.password)
+    if not user:
+        raise HTTPException(status_code=401, detail="用户名或密码错误")
+    token = create_access_token({"sub": user.username})
+    return Response.ok(Token(access_token=token, username=user.username, role=user.role))
+
+
+@router.get("/me", response_model=Response[UserOut])
+async def get_me(current_user: User = Depends(get_current_user)):
+    return Response.ok(UserOut.model_validate(current_user))
+
+
+@router.post("/users", response_model=Response[UserOut])
+async def create_user(
+    body: UserCreate,
+    db: AsyncSession = Depends(get_db),
+    _: User = Depends(require_roles("admin")),
+):
+    result = await db.execute(select(User).where(User.username == body.username))
+    if result.scalar_one_or_none():
+        raise HTTPException(status_code=400, detail="用户名已存在")
+    user = User(
+        username=body.username,
+        full_name=body.full_name,
+        hashed_password=hash_password(body.password),
+        role=body.role,
+    )
+    db.add(user)
+    await db.flush()
+    return Response.ok(UserOut.model_validate(user))
--- a/backend/app/api/dashboard.py
+++ b/backend/app/api/dashboard.py
@@ -0,0 +1,55 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func
+from datetime import datetime, date
+
+from app.database import get_db
+from app.models.material import Coil, CoilStatus
+from app.models.production import ProductionRecord
+from app.models.downtime import DowntimeRecord
+from app.models.equipment import Equipment, EquipmentStatus
+from app.schemas.common import Response
+from app.services.auth_service import get_current_user
+
+router = APIRouter()
+
+
+@router.get("/summary", response_model=Response[dict])
+async def get_summary(db: AsyncSession = Depends(get_db), _ = Depends(get_current_user)):
+    today = datetime.combine(date.today(), datetime.min.time())
+
+    # 今日产量
+    prod_result = await db.execute(
+        select(func.count(), func.sum(ProductionRecord.process_weight))
+        .where(ProductionRecord.start_time >= today)
+    )
+    prod_count, prod_weight = prod_result.one()
+
+    # 在线钢卷数
+    online_result = await db.execute(
+        select(func.count()).where(Coil.status == CoilStatus.ON_LINE)
+    )
+    online_coils = online_result.scalar()
+
+    # 今日停机时长
+    downtime_result = await db.execute(
+        select(func.sum(DowntimeRecord.duration))
+        .where(DowntimeRecord.start_time >= today)
+    )
+    total_downtime = downtime_result.scalar() or 0
+
+    # 设备状态统计
+    equip_result = await db.execute(
+        select(Equipment.status, func.count()).group_by(Equipment.status)
+    )
+    equip_stats = {str(row[0]): row[1] for row in equip_result}
+
+    return Response.ok({
+        "today_production": {
+            "coil_count": prod_count or 0,
+            "weight_kg": float(prod_weight or 0),
+        },
+        "online_coils": online_coils or 0,
+        "today_downtime_min": float(total_downtime),
+        "equipment_status": equip_stats,
+    })
--- a/backend/app/api/downtime.py
+++ b/backend/app/api/downtime.py
@@ -0,0 +1,108 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func, desc
+from typing import Optional
+from datetime import datetime
+
+from app.database import get_db
+from app.models.downtime import DowntimeRecord, DowntimeCategory
+from app.schemas.downtime import (
+    DowntimeCreate, DowntimeUpdate, DowntimeOut,
+    CategoryCreate, CategoryOut
+)
+from app.schemas.common import Response, PageResponse
+from app.services.auth_service import get_current_user
+
+router = APIRouter()
+
+
+def _parse_dt(s):
+    if not s:
+        return None
+    try:
+        return datetime.fromisoformat(s.replace('Z', ''))
+    except Exception:
+        return None
+
+
+@router.get("/categories", response_model=Response[list[CategoryOut]])
+async def list_categories(db: AsyncSession = Depends(get_db), _ = Depends(get_current_user)):
+    result = await db.execute(select(DowntimeCategory).where(DowntimeCategory.is_active == 1))
+    return Response.ok([CategoryOut.model_validate(c) for c in result.scalars()])
+
+
+@router.post("/categories", response_model=Response[CategoryOut])
+async def create_category(
+    body: CategoryCreate,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    cat = DowntimeCategory(**body.model_dump())
+    db.add(cat)
+    await db.flush()
+    return Response.ok(CategoryOut.model_validate(cat))
+
+
+@router.get("/", response_model=Response[PageResponse[DowntimeOut]])
+async def list_downtime(
+    page: int = 1,
+    page_size: int = 20,
+    category_code: Optional[str] = None,
+    shift: Optional[str] = None,
+    start_date: Optional[str] = Query(None),
+    end_date: Optional[str] = Query(None),
+    is_planned: Optional[int] = None,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    query = select(DowntimeRecord).order_by(desc(DowntimeRecord.start_time))
+    if category_code:
+        query = query.where(DowntimeRecord.category_code == category_code)
+    if shift:
+        query = query.where(DowntimeRecord.shift == shift)
+    _sd = _parse_dt(start_date)
+    if _sd:
+        query = query.where(DowntimeRecord.start_time >= _sd)
+    _ed = _parse_dt(end_date)
+    if _ed:
+        query = query.where(DowntimeRecord.start_time <= _ed)
+    if is_planned is not None:
+        query = query.where(DowntimeRecord.is_planned == is_planned)
+
+    total = (await db.execute(select(func.count()).select_from(query.subquery()))).scalar()
+    result = await db.execute(query.offset((page - 1) * page_size).limit(page_size))
+    items = [DowntimeOut.model_validate(r) for r in result.scalars()]
+    return Response.ok(PageResponse(total=total, page=page, page_size=page_size, items=items))
+
+
+@router.post("/", response_model=Response[DowntimeOut])
+async def create_downtime(
+    body: DowntimeCreate,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    record = DowntimeRecord(**body.model_dump())
+    db.add(record)
+    await db.flush()
+    return Response.ok(DowntimeOut.model_validate(record))
+
+
+@router.put("/{record_id}", response_model=Response[DowntimeOut])
+async def update_downtime(
+    record_id: int,
+    body: DowntimeUpdate,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    result = await db.execute(select(DowntimeRecord).where(DowntimeRecord.id == record_id))
+    record = result.scalar_one_or_none()
+    if not record:
+        raise HTTPException(status_code=404, detail="停机记录不存在")
+    update_data = body.model_dump(exclude_none=True)
+    for k, v in update_data.items():
+        setattr(record, k, v)
+    if record.end_time and record.start_time:
+        delta = (record.end_time - record.start_time).total_seconds() / 60
+        record.duration = round(delta, 2)
+    await db.flush()
+    return Response.ok(DowntimeOut.model_validate(record))
--- a/backend/app/api/equipment.py
+++ b/backend/app/api/equipment.py
@@ -0,0 +1,112 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func, desc
+from typing import Optional
+
+from app.database import get_db
+from app.models.equipment import Equipment, EquipmentMaintenance, EquipmentStatus
+from app.schemas.equipment import (
+    EquipmentCreate, EquipmentUpdate, EquipmentOut,
+    MaintenanceCreate, MaintenanceOut
+)
+from app.schemas.common import Response, PageResponse
+from app.services.auth_service import get_current_user
+
+router = APIRouter()
+
+
+@router.get("/", response_model=Response[PageResponse[EquipmentOut]])
+async def list_equipment(
+    page: int = 1,
+    page_size: int = 20,
+    name: Optional[str] = None,
+    status: Optional[str] = None,
+    category: Optional[str] = None,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    query = select(Equipment).order_by(Equipment.code)
+    if name:
+        query = query.where(Equipment.name.ilike(f"%{name}%"))
+    if status:
+        try:
+            query = query.where(Equipment.status == EquipmentStatus(status))
+        except ValueError:
+            pass
+    if category:
+        query = query.where(Equipment.category == category)
+
+    total = (await db.execute(select(func.count()).select_from(query.subquery()))).scalar()
+    result = await db.execute(query.offset((page - 1) * page_size).limit(page_size))
+    items = [EquipmentOut.model_validate(e) for e in result.scalars()]
+    return Response.ok(PageResponse(total=total, page=page, page_size=page_size, items=items))
+
+
+@router.post("/", response_model=Response[EquipmentOut])
+async def create_equipment(
+    body: EquipmentCreate,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    existing = await db.execute(select(Equipment).where(Equipment.code == body.code))
+    if existing.scalar_one_or_none():
+        raise HTTPException(status_code=400, detail="设备编号已存在")
+    equip = Equipment(**body.model_dump())
+    db.add(equip)
+    await db.flush()
+    return Response.ok(EquipmentOut.model_validate(equip))
+
+
+@router.get("/{equip_id}", response_model=Response[EquipmentOut])
+async def get_equipment(equip_id: int, db: AsyncSession = Depends(get_db), _ = Depends(get_current_user)):
+    result = await db.execute(select(Equipment).where(Equipment.id == equip_id))
+    equip = result.scalar_one_or_none()
+    if not equip:
+        raise HTTPException(status_code=404, detail="设备不存在")
+    return Response.ok(EquipmentOut.model_validate(equip))
+
+
+@router.put("/{equip_id}", response_model=Response[EquipmentOut])
+async def update_equipment(
+    equip_id: int,
+    body: EquipmentUpdate,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    result = await db.execute(select(Equipment).where(Equipment.id == equip_id))
+    equip = result.scalar_one_or_none()
+    if not equip:
+        raise HTTPException(status_code=404, detail="设备不存在")
+    for k, v in body.model_dump(exclude_none=True).items():
+        setattr(equip, k, v)
+    await db.flush()
+    return Response.ok(EquipmentOut.model_validate(equip))
+
+
+@router.get("/{equip_id}/maintenance", response_model=Response[PageResponse[MaintenanceOut]])
+async def list_maintenance(
+    equip_id: int,
+    page: int = 1,
+    page_size: int = 20,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    query = select(EquipmentMaintenance).where(
+        EquipmentMaintenance.equipment_id == equip_id
+    ).order_by(desc(EquipmentMaintenance.start_time))
+    total = (await db.execute(select(func.count()).select_from(query.subquery()))).scalar()
+    result = await db.execute(query.offset((page - 1) * page_size).limit(page_size))
+    items = [MaintenanceOut.model_validate(m) for m in result.scalars()]
+    return Response.ok(PageResponse(total=total, page=page, page_size=page_size, items=items))
+
+
+@router.post("/maintenance", response_model=Response[MaintenanceOut])
+async def create_maintenance(
+    body: MaintenanceCreate,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    record = EquipmentMaintenance(**body.model_dump())
+    db.add(record)
+    await db.flush()
+    return Response.ok(MaintenanceOut.model_validate(record))
--- a/backend/app/api/inspection.py
+++ b/backend/app/api/inspection.py
@@ -0,0 +1,75 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func, desc
+from typing import Optional
+
+from app.database import get_db
+from app.models.inspection import InspectionLocation, InspectionRecord
+from app.schemas.inspection import (
+    InspectionLocationCreate, InspectionLocationOut,
+    InspectionRecordCreate, InspectionRecordOut,
+)
+from app.schemas.common import Response, PageResponse
+from app.services.auth_service import get_current_user
+
+router = APIRouter()
+
+
+@router.get("/locations", response_model=Response[list[InspectionLocationOut]])
+async def list_locations(
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    result = await db.execute(
+        select(InspectionLocation).order_by(InspectionLocation.sort_order, InspectionLocation.id)
+    )
+    items = [InspectionLocationOut.model_validate(r) for r in result.scalars()]
+    return Response.ok(items)
+
+
+@router.post("/locations", response_model=Response[InspectionLocationOut])
+async def create_location(
+    body: InspectionLocationCreate,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    loc = InspectionLocation(**body.model_dump())
+    db.add(loc)
+    await db.flush()
+    return Response.ok(InspectionLocationOut.model_validate(loc))
+
+
+@router.get("/records", response_model=Response[PageResponse[InspectionRecordOut]])
+async def list_records(
+    page: int = 1,
+    page_size: int = 30,
+    location_id: Optional[int] = None,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    query = select(InspectionRecord).order_by(desc(InspectionRecord.created_at))
+    if location_id:
+        query = query.where(InspectionRecord.location_id == location_id)
+    total = (await db.execute(select(func.count()).select_from(query.subquery()))).scalar()
+    result = await db.execute(query.offset((page - 1) * page_size).limit(page_size))
+    items = [InspectionRecordOut.model_validate(r) for r in result.scalars()]
+    return Response.ok(PageResponse(total=total, page=page, page_size=page_size, items=items))
+
+
+@router.post("/records", response_model=Response[InspectionRecordOut])
+async def create_record(
+    body: InspectionRecordCreate,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    loc_result = await db.execute(
+        select(InspectionLocation).where(InspectionLocation.id == body.location_id)
+    )
+    loc = loc_result.scalar_one_or_none()
+    record = InspectionRecord(
+        **body.model_dump(),
+        location_name=loc.name if loc else None,
+    )
+    db.add(record)
+    await db.flush()
+    return Response.ok(InspectionRecordOut.model_validate(record))
--- a/backend/app/api/material.py
+++ b/backend/app/api/material.py
@@ -0,0 +1,102 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func, desc
+from typing import Optional
+
+from app.database import get_db
+from app.models.material import Coil, MaterialTracking, CoilStatus
+from app.schemas.material import CoilCreate, CoilUpdate, CoilOut, TrackingCreate, TrackingOut
+from app.schemas.common import Response, PageResponse
+from app.services.auth_service import get_current_user
+
+router = APIRouter()
+
+
+@router.get("/coils", response_model=Response[PageResponse[CoilOut]])
+async def list_coils(
+    page: int = 1,
+    page_size: int = 20,
+    coil_no: Optional[str] = None,
+    status: Optional[str] = None,
+    steel_grade: Optional[str] = None,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    query = select(Coil).order_by(desc(Coil.created_at))
+    if coil_no:
+        query = query.where(Coil.coil_no.ilike(f"%{coil_no}%"))
+    if status:
+        try:
+            query = query.where(Coil.status == CoilStatus(status))
+        except ValueError:
+            pass
+    if steel_grade:
+        query = query.where(Coil.steel_grade == steel_grade)
+
+    total_result = await db.execute(select(func.count()).select_from(query.subquery()))
+    total = total_result.scalar()
+
+    result = await db.execute(query.offset((page - 1) * page_size).limit(page_size))
+    items = [CoilOut.model_validate(c) for c in result.scalars()]
+
+    return Response.ok(PageResponse(total=total, page=page, page_size=page_size, items=items))
+
+
+@router.post("/coils", response_model=Response[CoilOut])
+async def create_coil(
+    body: CoilCreate,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    existing = await db.execute(select(Coil).where(Coil.coil_no == body.coil_no))
+    if existing.scalar_one_or_none():
+        raise HTTPException(status_code=400, detail="卷号已存在")
+    coil = Coil(**body.model_dump())
+    db.add(coil)
+    await db.flush()
+    return Response.ok(CoilOut.model_validate(coil))
+
+
+@router.get("/coils/{coil_no}", response_model=Response[CoilOut])
+async def get_coil(coil_no: str, db: AsyncSession = Depends(get_db), _ = Depends(get_current_user)):
+    result = await db.execute(select(Coil).where(Coil.coil_no == coil_no))
+    coil = result.scalar_one_or_none()
+    if not coil:
+        raise HTTPException(status_code=404, detail="钢卷不存在")
+    return Response.ok(CoilOut.model_validate(coil))
+
+
+@router.put("/coils/{coil_no}", response_model=Response[CoilOut])
+async def update_coil(
+    coil_no: str,
+    body: CoilUpdate,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    result = await db.execute(select(Coil).where(Coil.coil_no == coil_no))
+    coil = result.scalar_one_or_none()
+    if not coil:
+        raise HTTPException(status_code=404, detail="钢卷不存在")
+    for k, v in body.model_dump(exclude_none=True).items():
+        setattr(coil, k, v)
+    await db.flush()
+    return Response.ok(CoilOut.model_validate(coil))
+
+
+@router.get("/tracking", response_model=Response[PageResponse[TrackingOut]])
+async def list_tracking(
+    coil_no: Optional[str] = None,
+    page: int = 1,
+    page_size: int = 50,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    query = select(MaterialTracking).order_by(desc(MaterialTracking.event_time))
+    if coil_no:
+        query = query.where(MaterialTracking.coil_no == coil_no)
+
+    total_result = await db.execute(select(func.count()).select_from(query.subquery()))
+    total = total_result.scalar()
+    result = await db.execute(query.offset((page - 1) * page_size).limit(page_size))
+    items = [TrackingOut.model_validate(t) for t in result.scalars()]
+    return Response.ok(PageResponse(total=total, page=page, page_size=page_size, items=items))
--- a/backend/app/api/message.py
+++ b/backend/app/api/message.py
@@ -0,0 +1,82 @@
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func, desc
+from typing import Optional
+from datetime import datetime
+
+from app.database import get_db
+from app.models.message import MessageLog
+from app.schemas.common import Response, PageResponse
+from app.services.auth_service import get_current_user
+
+router = APIRouter()
+
+
+def _parse_dt(s):
+    if not s:
+        return None
+    try:
+        return datetime.fromisoformat(s.replace('Z', ''))
+    except Exception:
+        return None
+
+
+@router.get("/logs", response_model=Response[PageResponse[dict]])
+async def list_message_logs(
+    page: int = 1,
+    page_size: int = 50,
+    msg_type: Optional[str] = None,
+    direction: Optional[str] = None,
+    status: Optional[str] = None,
+    start_time: Optional[str] = Query(None),
+    end_time: Optional[str] = Query(None),
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    query = select(MessageLog).order_by(desc(MessageLog.received_at))
+    if msg_type:
+        query = query.where(MessageLog.msg_type == msg_type)
+    if direction:
+        query = query.where(MessageLog.direction == direction)
+    if status:
+        query = query.where(MessageLog.status == status)
+    _sd = _parse_dt(start_time)
+    if _sd:
+        query = query.where(MessageLog.received_at >= _sd)
+    _ed = _parse_dt(end_time)
+    if _ed:
+        query = query.where(MessageLog.received_at <= _ed)
+
+    total = (await db.execute(select(func.count()).select_from(query.subquery()))).scalar()
+    result = await db.execute(query.offset((page - 1) * page_size).limit(page_size))
+    items = []
+    for log in result.scalars():
+        items.append({
+            "id": log.id,
+            "msg_id": log.msg_id,
+            "msg_type": log.msg_type,
+            "direction": log.direction,
+            "source": log.source,
+            "status": log.status,
+            "error_msg": log.error_msg,
+            "process_time": log.process_time,
+            "received_at": log.received_at,
+        })
+    return Response.ok(PageResponse(total=total, page=page, page_size=page_size, items=items))
+
+
+@router.get("/logs/{log_id}", response_model=Response[dict])
+async def get_message_log(log_id: int, db: AsyncSession = Depends(get_db), _ = Depends(get_current_user)):
+    result = await db.execute(select(MessageLog).where(MessageLog.id == log_id))
+    log = result.scalar_one_or_none()
+    if not log:
+        return Response.error("报文记录不存在", code=404)
+    return Response.ok({
+        "id": log.id,
+        "msg_type": log.msg_type,
+        "direction": log.direction,
+        "raw_data": log.raw_data,
+        "parsed_data": log.parsed_data,
+        "status": log.status,
+        "received_at": log.received_at,
+    })
--- a/backend/app/api/pdi.py
+++ b/backend/app/api/pdi.py
@@ -0,0 +1,112 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func, desc
+from typing import Optional
+from datetime import datetime
+
+from app.database import get_db
+from app.models.pdi import PDIRecord, L3Status, L2Status
+from app.schemas.pdi import PDIRecordCreate, PDIRecordUpdate, PDIRecordOut
+from app.schemas.common import Response, PageResponse
+from app.services.auth_service import get_current_user
+
+router = APIRouter()
+
+
+@router.get("/stats", response_model=Response[dict])
+async def get_pdi_stats(
+    db: AsyncSession = Depends(get_db),
+    _=Depends(get_current_user),
+):
+    """各状态PDI数量统计"""
+    total_q   = await db.execute(select(func.count()).select_from(PDIRecord))
+    pending_q = await db.execute(
+        select(func.count()).select_from(PDIRecord).where(PDIRecord.l2_status == L2Status.pending)
+    )
+    proc_q    = await db.execute(
+        select(func.count()).select_from(PDIRecord).where(PDIRecord.l2_status == L2Status.processing)
+    )
+    done_q    = await db.execute(
+        select(func.count()).select_from(PDIRecord).where(PDIRecord.l2_status == L2Status.done)
+    )
+    confirmed_q = await db.execute(
+        select(func.count()).select_from(PDIRecord).where(PDIRecord.l3_status == L3Status.confirmed)
+    )
+
+    return Response.ok({
+        "total":     total_q.scalar(),
+        "pending":   pending_q.scalar(),
+        "processing": proc_q.scalar(),
+        "done":      done_q.scalar(),
+        "confirmed": confirmed_q.scalar(),
+    })
+
+
+@router.get("/", response_model=Response[PageResponse[PDIRecordOut]])
+async def list_pdi(
+    page:       int = 1,
+    page_size:  int = 20,
+    coil_no:    Optional[str] = None,
+    l3_status:  Optional[str] = None,
+    l2_status:  Optional[str] = None,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(get_current_user),
+):
+    query = select(PDIRecord).order_by(desc(PDIRecord.created_at))
+    if coil_no:
+        query = query.where(PDIRecord.coil_no.ilike(f"%{coil_no}%"))
+    if l3_status:
+        query = query.where(PDIRecord.l3_status == l3_status)
+    if l2_status:
+        query = query.where(PDIRecord.l2_status == l2_status)
+
+    total  = (await db.execute(select(func.count()).select_from(query.subquery()))).scalar()
+    result = await db.execute(query.offset((page - 1) * page_size).limit(page_size))
+    items  = [PDIRecordOut.model_validate(r) for r in result.scalars()]
+    return Response.ok(PageResponse(total=total, page=page, page_size=page_size, items=items))
+
+
+@router.post("/", response_model=Response[PDIRecordOut])
+async def create_pdi(
+    body: PDIRecordCreate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(get_current_user),
+):
+    record = PDIRecord(**body.model_dump())
+    db.add(record)
+    await db.flush()
+    return Response.ok(PDIRecordOut.model_validate(record))
+
+
+@router.put("/{pdi_id}", response_model=Response[PDIRecordOut])
+async def update_pdi(
+    pdi_id: int,
+    body: PDIRecordUpdate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(get_current_user),
+):
+    result = await db.execute(select(PDIRecord).where(PDIRecord.id == pdi_id))
+    record = result.scalar_one_or_none()
+    if not record:
+        raise HTTPException(status_code=404, detail="PDI记录不存在")
+    for k, v in body.model_dump(exclude_none=True).items():
+        setattr(record, k, v)
+    await db.flush()
+    return Response.ok(PDIRecordOut.model_validate(record))
+
+
+@router.patch("/{pdi_id}/confirm", response_model=Response[PDIRecordOut])
+async def confirm_pdi(
+    pdi_id: int,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(get_current_user),
+):
+    """L2确认PDI，将状态设置为processing"""
+    result = await db.execute(select(PDIRecord).where(PDIRecord.id == pdi_id))
+    record = result.scalar_one_or_none()
+    if not record:
+        raise HTTPException(status_code=404, detail="PDI记录不存在")
+    record.l2_status    = L2Status.processing
+    record.confirm_time = datetime.utcnow()
+    await db.flush()
+    return Response.ok(PDIRecordOut.model_validate(record))
--- a/backend/app/api/plan.py
+++ b/backend/app/api/plan.py
@@ -0,0 +1,103 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func, desc
+from typing import Optional
+from datetime import datetime
+
+from app.database import get_db
+from app.models.plan import ProductionPlan, PlanStatus
+from app.schemas.plan import PlanCreate, PlanUpdate, PlanOut
+from app.schemas.common import Response, PageResponse
+from app.services.auth_service import get_current_user
+
+router = APIRouter()
+
+
+def _parse_dt(s):
+    if not s:
+        return None
+    try:
+        return datetime.fromisoformat(s.replace('Z', ''))
+    except Exception:
+        return None
+
+
+@router.get("/", response_model=Response[PageResponse[PlanOut]])
+async def list_plans(
+    page: int = 1,
+    page_size: int = 20,
+    status: Optional[str] = None,
+    start_date: Optional[str] = Query(None),
+    end_date: Optional[str] = Query(None),
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    query = select(ProductionPlan).order_by(desc(ProductionPlan.plan_date))
+    if status:
+        try:
+            query = query.where(ProductionPlan.status == PlanStatus(status))
+        except ValueError:
+            pass
+    _sd = _parse_dt(start_date)
+    if _sd:
+        query = query.where(ProductionPlan.plan_date >= _sd)
+    _ed = _parse_dt(end_date)
+    if _ed:
+        query = query.where(ProductionPlan.plan_date <= _ed)
+
+    total = (await db.execute(select(func.count()).select_from(query.subquery()))).scalar()
+    result = await db.execute(query.offset((page - 1) * page_size).limit(page_size))
+    items = [PlanOut.model_validate(p) for p in result.scalars()]
+    return Response.ok(PageResponse(total=total, page=page, page_size=page_size, items=items))
+
+
+@router.post("/", response_model=Response[PlanOut])
+async def create_plan(
+    body: PlanCreate,
+    db: AsyncSession = Depends(get_db),
+    current_user = Depends(get_current_user),
+):
+    existing = await db.execute(select(ProductionPlan).where(ProductionPlan.plan_no == body.plan_no))
+    if existing.scalar_one_or_none():
+        raise HTTPException(status_code=400, detail="计划号已存在")
+    plan = ProductionPlan(**body.model_dump(), created_by=current_user.username)
+    db.add(plan)
+    await db.flush()
+    return Response.ok(PlanOut.model_validate(plan))
+
+
+@router.get("/{plan_id}", response_model=Response[PlanOut])
+async def get_plan(plan_id: int, db: AsyncSession = Depends(get_db), _ = Depends(get_current_user)):
+    result = await db.execute(select(ProductionPlan).where(ProductionPlan.id == plan_id))
+    plan = result.scalar_one_or_none()
+    if not plan:
+        raise HTTPException(status_code=404, detail="计划不存在")
+    return Response.ok(PlanOut.model_validate(plan))
+
+
+@router.put("/{plan_id}", response_model=Response[PlanOut])
+async def update_plan(
+    plan_id: int,
+    body: PlanUpdate,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    result = await db.execute(select(ProductionPlan).where(ProductionPlan.id == plan_id))
+    plan = result.scalar_one_or_none()
+    if not plan:
+        raise HTTPException(status_code=404, detail="计划不存在")
+    for k, v in body.model_dump(exclude_none=True).items():
+        setattr(plan, k, v)
+    await db.flush()
+    return Response.ok(PlanOut.model_validate(plan))
+
+
+@router.patch("/{plan_id}/confirm", response_model=Response[PlanOut])
+async def confirm_plan(plan_id: int, db: AsyncSession = Depends(get_db), _ = Depends(get_current_user)):
+    result = await db.execute(select(ProductionPlan).where(ProductionPlan.id == plan_id))
+    plan = result.scalar_one_or_none()
+    if not plan:
+        raise HTTPException(status_code=404, detail="计划不存在")
+    plan.status = PlanStatus.CONFIRMED
+    await db.flush()
+    return Response.ok(PlanOut.model_validate(plan))
--- a/backend/app/api/prediction.py
+++ b/backend/app/api/prediction.py
@@ -0,0 +1,294 @@
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field
+from typing import List, Optional
+from datetime import datetime
+
+from app.schemas.common import Response
+from app.services.auth_service import get_current_user
+from app.services.prediction import (
+    AcidSpeedModel,
+    TensionModel,
+    QualityPredictionModel,
+    AcidConsumptionModel,
+    _load_cal,
+    _save_cal,
+)
+
+router = APIRouter()
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Prediction request schemas
+# ─────────────────────────────────────────────────────────────────────────────
+
+class AcidSpeedRequest(BaseModel):
+    thickness:      float = Field(..., gt=0)
+    width:          float = Field(..., gt=0)
+    steel_grade:    str
+    acid_conc_list: List[float]
+    acid_temp_list: List[float]
+    scale_weight:   Optional[float] = 8.5
+    target_pi:      Optional[float] = 95.0
+
+
+class TensionRequest(BaseModel):
+    thickness:      float = Field(..., gt=0)
+    width:          float = Field(..., gt=0)
+    yield_strength: float = Field(..., gt=0)
+    tension_coef:   Optional[float] = 0.25
+
+
+class QualityRequest(BaseModel):
+    thickness:      float = Field(..., gt=0)
+    avg_speed:      float = Field(..., gt=0)
+    acid_conc_avg:  float = Field(..., gt=0)
+    acid_temp_avg:  float = Field(..., gt=0)
+    scale_weight:   Optional[float] = 8.5
+
+
+class ConsumptionRequest(BaseModel):
+    thickness:         float = Field(..., gt=0)
+    width:             float = Field(..., gt=0)
+    coil_weight_kg:    float = Field(..., gt=0)
+    has_regen_station: Optional[bool] = True
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Calibration request schemas
+# ─────────────────────────────────────────────────────────────────────────────
+
+class AcidCalibRequest(BaseModel):
+    # 需要重建模型实例的上下文参数
+    thickness:      float = Field(..., gt=0)
+    width:          float = Field(..., gt=0)
+    steel_grade:    str
+    acid_conc_list: List[float]
+    acid_temp_list: List[float]
+    scale_weight:   Optional[float] = 8.5
+    # 校准输入
+    actual_max_speed:   float = Field(..., gt=0, description="实测质量合格时的最高速度 m/min")
+    actual_quality_ok:  bool  = Field(..., description="该速度下质量是否合格")
+    note:               Optional[str] = None
+
+
+class TensionCalibRequest(BaseModel):
+    thickness:      float = Field(..., gt=0)
+    width:          float = Field(..., gt=0)
+    yield_strength: float = Field(..., gt=0)
+    tension_coef:   Optional[float] = 0.25
+    zone:           str   = Field(..., description="测量位置，如 s1_roller")
+    measured_kn:    float = Field(..., gt=0, description="实测张力 kN")
+    note:           Optional[str] = None
+
+
+class QualityCalibRequest(BaseModel):
+    thickness:      float = Field(..., gt=0)
+    avg_speed:      float = Field(..., gt=0)
+    acid_conc_avg:  float = Field(..., gt=0)
+    acid_temp_avg:  float = Field(..., gt=0)
+    scale_weight:   Optional[float] = 8.5
+    actual_grade:   str   = Field(..., description="实际质检等级 A1/A2/B1/B2/C")
+    note:           Optional[str] = None
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Helper: append calibration history
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _append_history(model_key: str, k_before: float, k_after: float,
+                    input_data: dict, note: str = ""):
+    cal = _load_cal()
+    history = cal.get("history", [])
+    history.insert(0, {
+        "ts":       datetime.now().isoformat(timespec="seconds"),
+        "model":    model_key,
+        "k_before": k_before,
+        "k_after":  k_after,
+        "input":    input_data,
+        "note":     note or "",
+    })
+    cal["history"] = history[:100]
+    _save_cal(cal)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Prediction endpoints
+# ─────────────────────────────────────────────────────────────────────────────
+
+@router.post("/acid-speed", response_model=Response[dict])
+async def predict_acid_speed(body: AcidSpeedRequest, _=Depends(get_current_user)):
+    try:
+        model = AcidSpeedModel(
+            thickness=body.thickness, width=body.width,
+            steel_grade=body.steel_grade,
+            acid_conc_list=body.acid_conc_list,
+            acid_temp_list=body.acid_temp_list,
+            scale_weight=body.scale_weight, target_pi=body.target_pi,
+        )
+        result = model.calculate()
+    except ValueError as e:
+        raise HTTPException(status_code=422, detail=str(e))
+    return Response.ok(result)
+
+
+@router.post("/tension", response_model=Response[dict])
+async def predict_tension(body: TensionRequest, _=Depends(get_current_user)):
+    model = TensionModel(
+        thickness=body.thickness, width=body.width,
+        yield_strength=body.yield_strength, tension_coef=body.tension_coef,
+    )
+    return Response.ok(model.calculate())
+
+
+@router.post("/quality", response_model=Response[dict])
+async def predict_quality(body: QualityRequest, _=Depends(get_current_user)):
+    model = QualityPredictionModel(
+        thickness=body.thickness, avg_speed=body.avg_speed,
+        acid_conc_avg=body.acid_conc_avg, acid_temp_avg=body.acid_temp_avg,
+        scale_weight=body.scale_weight,
+    )
+    return Response.ok(model.calculate())
+
+
+@router.post("/consumption", response_model=Response[dict])
+async def predict_consumption(body: ConsumptionRequest, _=Depends(get_current_user)):
+    model = AcidConsumptionModel(
+        thickness=body.thickness, width=body.width,
+        coil_weight_kg=body.coil_weight_kg,
+        has_regen_station=body.has_regen_station,
+    )
+    return Response.ok(model.calculate())
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Calibration endpoints
+# ─────────────────────────────────────────────────────────────────────────────
+
+TENSION_ZONES = ["inlet","s1_roller","acid_entry","acid1","acid2","acid3","rinse","leveler","s2_roller","outlet"]
+
+
+@router.get("/calibration", response_model=Response[dict])
+async def get_calibration(_=Depends(get_current_user)):
+    """返回各模型当前校准系数和历史记录"""
+    cal = _load_cal()
+    tension_zone_kcal = {
+        z: cal.get(f"tension_zone_{z}", 1.0) for z in TENSION_ZONES
+    }
+    return Response.ok({
+        "acid_speed_kcal":   cal.get("acid_speed_kcal", 1.0),
+        "tension_zone_kcal": tension_zone_kcal,
+        "quality_kcal":      cal.get("quality_kcal", 1.0),
+        "history":           cal.get("history", []),
+    })
+
+
+@router.post("/calibration/acid-speed", response_model=Response[dict])
+async def calibrate_acid_speed(body: AcidCalibRequest, _=Depends(get_current_user)):
+    """录入实测数据，更新酸洗速度模型校准系数"""
+    try:
+        model = AcidSpeedModel(
+            thickness=body.thickness, width=body.width,
+            steel_grade=body.steel_grade,
+            acid_conc_list=body.acid_conc_list,
+            acid_temp_list=body.acid_temp_list,
+            scale_weight=body.scale_weight,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=422, detail=str(e))
+
+    k_before = model.K_cal
+    predicted_speed = model.calculate()["max_speed"]
+    k_after = model.calibrate(
+        actual_max_speed=body.actual_max_speed,
+        actual_quality_ok=body.actual_quality_ok,
+    )
+    _append_history(
+        "acid_speed", k_before, k_after,
+        {"actual_speed": body.actual_max_speed,
+         "quality_ok": body.actual_quality_ok,
+         "predicted_speed": predicted_speed},
+        body.note or "",
+    )
+    return Response.ok({
+        "k_before": k_before,
+        "k_after":  k_after,
+        "predicted_speed": predicted_speed,
+        "adjustment": round((k_after / k_before - 1) * 100, 2),
+    })
+
+
+@router.post("/calibration/tension", response_model=Response[dict])
+async def calibrate_tension(body: TensionCalibRequest, _=Depends(get_current_user)):
+    """录入实测张力，仅更新指定区段的校准系数"""
+    model = TensionModel(
+        thickness=body.thickness, width=body.width,
+        yield_strength=body.yield_strength, tension_coef=body.tension_coef,
+    )
+    calc = model.calculate()
+    predicted_kn = calc["zones"].get(body.zone, {}).get("tension_kN", 0)
+    k_before = model.zone_kcal.get(body.zone, 1.0)
+    new_zone_kcal = model.calibrate(zone=body.zone, measured_kn=body.measured_kn)
+    k_after = new_zone_kcal.get(body.zone, 1.0)
+    _append_history(
+        "tension", k_before, k_after,
+        {"zone": body.zone,
+         "measured_kn": body.measured_kn,
+         "predicted_kn": predicted_kn},
+        body.note or "",
+    )
+    return Response.ok({
+        "zone":          body.zone,
+        "k_before":      k_before,
+        "k_after":       k_after,
+        "predicted_kn":  predicted_kn,
+        "measured_kn":   body.measured_kn,
+        "adjustment":    round((k_after / k_before - 1) * 100, 2),
+        "zone_kcal":     new_zone_kcal,
+    })
+
+
+@router.post("/calibration/quality", response_model=Response[dict])
+async def calibrate_quality(body: QualityCalibRequest, _=Depends(get_current_user)):
+    """录入实际质检等级，更新质量模型校准系数"""
+    model = QualityPredictionModel(
+        thickness=body.thickness, avg_speed=body.avg_speed,
+        acid_conc_avg=body.acid_conc_avg, acid_temp_avg=body.acid_temp_avg,
+        scale_weight=body.scale_weight,
+    )
+    k_before = model.K_cal
+    calc = model.calculate()
+    predicted_grade = calc["overall_grade"]
+    k_after = model.calibrate(actual_grade=body.actual_grade)
+    _append_history(
+        "quality", k_before, k_after,
+        {"actual_grade": body.actual_grade,
+         "predicted_grade": predicted_grade},
+        body.note or "",
+    )
+    return Response.ok({
+        "k_before":        k_before,
+        "k_after":         k_after,
+        "predicted_grade": predicted_grade,
+        "actual_grade":    body.actual_grade,
+        "adjustment":      round((k_after / k_before - 1) * 100, 2),
+    })
+
+
+@router.post("/calibration/reset/{model_key}", response_model=Response[dict])
+async def reset_calibration(model_key: str, _=Depends(get_current_user)):
+    """将指定模型的校准系数全部重置为 1.0"""
+    cal = _load_cal()
+    if model_key == "tension":
+        # 重置所有区段
+        for z in TENSION_ZONES:
+            cal[f"tension_zone_{z}"] = 1.0
+        _append_history("tension", None, 1.0, {"action": "reset_all_zones"})
+    elif model_key in ("acid_speed", "quality"):
+        key = f"{model_key}_kcal"
+        k_before = cal.get(key, 1.0)
+        cal[key] = 1.0
+        _append_history(model_key, k_before, 1.0, {"action": "reset"})
+    else:
+        raise HTTPException(status_code=404, detail="未知模型")
+    _save_cal(cal)
+    return Response.ok({"model": model_key, "reset": True})
--- a/backend/app/api/production.py
+++ b/backend/app/api/production.py
@@ -0,0 +1,89 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func, desc
+from typing import Optional
+from datetime import datetime
+
+from app.database import get_db
+from app.models.production import ProductionRecord
+from app.schemas.production import ProductionRecordCreate, ProductionRecordUpdate, ProductionRecordOut
+from app.schemas.common import Response, PageResponse
+from app.services.auth_service import get_current_user
+
+router = APIRouter()
+
+
+def _parse_dt(s):
+    if not s:
+        return None
+    try:
+        return datetime.fromisoformat(s.replace('Z', ''))
+    except Exception:
+        return None
+
+
+@router.get("/", response_model=Response[PageResponse[ProductionRecordOut]])
+async def list_records(
+    page: int = 1,
+    page_size: int = 20,
+    coil_no: Optional[str] = None,
+    shift: Optional[str] = None,
+    start_date: Optional[str] = Query(None),
+    end_date: Optional[str] = Query(None),
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    query = select(ProductionRecord).order_by(desc(ProductionRecord.start_time))
+    if coil_no:
+        query = query.where(ProductionRecord.coil_no.ilike(f"%{coil_no}%"))
+    if shift:
+        query = query.where(ProductionRecord.shift == shift)
+    _sd = _parse_dt(start_date)
+    if _sd:
+        query = query.where(ProductionRecord.start_time >= _sd)
+    _ed = _parse_dt(end_date)
+    if _ed:
+        query = query.where(ProductionRecord.start_time <= _ed)
+
+    total = (await db.execute(select(func.count()).select_from(query.subquery()))).scalar()
+    result = await db.execute(query.offset((page - 1) * page_size).limit(page_size))
+    items = [ProductionRecordOut.model_validate(r) for r in result.scalars()]
+    return Response.ok(PageResponse(total=total, page=page, page_size=page_size, items=items))
+
+
+@router.post("/", response_model=Response[ProductionRecordOut])
+async def create_record(
+    body: ProductionRecordCreate,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    record = ProductionRecord(**body.model_dump())
+    db.add(record)
+    await db.flush()
+    return Response.ok(ProductionRecordOut.model_validate(record))
+
+
+@router.get("/{record_id}", response_model=Response[ProductionRecordOut])
+async def get_record(record_id: int, db: AsyncSession = Depends(get_db), _ = Depends(get_current_user)):
+    result = await db.execute(select(ProductionRecord).where(ProductionRecord.id == record_id))
+    record = result.scalar_one_or_none()
+    if not record:
+        raise HTTPException(status_code=404, detail="实绩记录不存在")
+    return Response.ok(ProductionRecordOut.model_validate(record))
+
+
+@router.put("/{record_id}", response_model=Response[ProductionRecordOut])
+async def update_record(
+    record_id: int,
+    body: ProductionRecordUpdate,
+    db: AsyncSession = Depends(get_db),
+    _ = Depends(get_current_user),
+):
+    result = await db.execute(select(ProductionRecord).where(ProductionRecord.id == record_id))
+    record = result.scalar_one_or_none()
+    if not record:
+        raise HTTPException(status_code=404, detail="实绩记录不存在")
+    for k, v in body.model_dump(exclude_none=True).items():
+        setattr(record, k, v)
+    await db.flush()
+    return Response.ok(ProductionRecordOut.model_validate(record))
--- a/backend/app/api/quality.py
+++ b/backend/app/api/quality.py
@@ -0,0 +1,134 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func, desc
+from typing import Optional
+from datetime import datetime
+
+from app.database import get_db
+from app.models.quality import QualityRecord
+from app.schemas.quality import QualityRecordCreate, QualityRecordUpdate, QualityRecordOut
+from app.schemas.common import Response, PageResponse
+from app.services.auth_service import get_current_user
+from app.services.prediction import QualityPredictionModel
+
+router = APIRouter()
+
+
+@router.get("/summary", response_model=Response[dict])
+async def quality_summary(
+    db: AsyncSession = Depends(get_db),
+    _=Depends(get_current_user),
+):
+    """合格率、平均评分、班次分组统计"""
+    total_q   = await db.execute(select(func.count()).select_from(QualityRecord))
+    passed_q  = await db.execute(
+        select(func.count()).select_from(QualityRecord).where(QualityRecord.is_passed == True)
+    )
+    avg_pi_q  = await db.execute(select(func.avg(QualityRecord.pi_score)).select_from(QualityRecord))
+    avg_suf_q = await db.execute(select(func.avg(QualityRecord.surface_score)).select_from(QualityRecord))
+
+    # Grade distribution
+    grade_counts: dict = {}
+    for grade in ["A1", "A2", "B1", "B2", "C"]:
+        cnt_q = await db.execute(
+            select(func.count()).select_from(QualityRecord).where(QualityRecord.overall_grade == grade)
+        )
+        grade_counts[grade] = cnt_q.scalar() or 0
+
+    total  = total_q.scalar() or 0
+    passed = passed_q.scalar() or 0
+    pass_rate = round(passed / total * 100, 1) if total > 0 else 0.0
+
+    return Response.ok({
+        "total":         total,
+        "passed":        passed,
+        "pass_rate":     pass_rate,
+        "avg_pi_score":  round(avg_pi_q.scalar() or 0, 1),
+        "avg_surface_score": round(avg_suf_q.scalar() or 0, 1),
+        "grade_distribution": grade_counts,
+    })
+
+
+@router.get("/", response_model=Response[PageResponse[QualityRecordOut]])
+async def list_quality(
+    page:         int = 1,
+    page_size:    int = 20,
+    coil_no:      Optional[str] = None,
+    overall_grade: Optional[str] = None,
+    start_date:   Optional[datetime] = None,
+    end_date:     Optional[datetime] = None,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(get_current_user),
+):
+    query = select(QualityRecord).order_by(desc(QualityRecord.created_at))
+    if coil_no:
+        query = query.where(QualityRecord.coil_no.ilike(f"%{coil_no}%"))
+    if overall_grade:
+        query = query.where(QualityRecord.overall_grade == overall_grade)
+    _sd = _parse_dt(start_date)
+    if _sd:
+        query = query.where(QualityRecord.created_at >= _sd)
+    _ed = _parse_dt(end_date)
+    if _ed:
+        query = query.where(QualityRecord.created_at <= _ed)
+
+    total  = (await db.execute(select(func.count()).select_from(query.subquery()))).scalar()
+    result = await db.execute(query.offset((page - 1) * page_size).limit(page_size))
+    items  = [QualityRecordOut.model_validate(r) for r in result.scalars()]
+    return Response.ok(PageResponse(total=total, page=page, page_size=page_size, items=items))
+
+
+@router.post("/", response_model=Response[QualityRecordOut])
+async def create_quality(
+    body: QualityRecordCreate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(get_current_user),
+):
+    """
+    创建质量记录。若未提供 pi_score / surface_score / overall_grade，
+    则尝试用 QualityPredictionModel 自动填充（需要thickness_actual和相关参数）。
+    """
+    data = body.model_dump()
+
+    if (
+        data.get("pi_score") is None
+        and data.get("thickness_actual") is not None
+    ):
+        # Use default avg values for auto-prediction when detailed params are absent
+        avg_speed    = 100.0   # m/min default
+        acid_conc_avg = 160.0  # g/L default
+        acid_temp_avg = 75.0   # °C default
+        try:
+            pred = QualityPredictionModel(
+                thickness=data["thickness_actual"],
+                avg_speed=avg_speed,
+                acid_conc_avg=acid_conc_avg,
+                acid_temp_avg=acid_temp_avg,
+            ).calculate()
+            data["pi_score"]      = pred["pi_score"]
+            data["surface_score"] = pred["surface_score"]
+            data["overall_grade"] = pred["overall_grade"]
+        except Exception:
+            pass  # best-effort, do not block creation
+
+    record = QualityRecord(**data)
+    db.add(record)
+    await db.flush()
+    return Response.ok(QualityRecordOut.model_validate(record))
+
+
+@router.put("/{quality_id}", response_model=Response[QualityRecordOut])
+async def update_quality(
+    quality_id: int,
+    body: QualityRecordUpdate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(get_current_user),
+):
+    result = await db.execute(select(QualityRecord).where(QualityRecord.id == quality_id))
+    record = result.scalar_one_or_none()
+    if not record:
+        raise HTTPException(status_code=404, detail="质量记录不存在")
+    for k, v in body.model_dump(exclude_none=True).items():
+        setattr(record, k, v)
+    await db.flush()
+    return Response.ok(QualityRecordOut.model_validate(record))