sqxp/backend/app/crud/inquiry.py

"""询价单CRUD"""
from typing import Optional, List
from datetime import datetime
from sqlalchemy.orm import Session
from sqlalchemy import and_, func

from app.models.models import BizInquiry, BizInquiryItem, BizInquiryItemHis, BizInquiryHis
from app.crud.base import CRUDBase
from app.core.utils import generate_id


class InquiryCRUD(CRUDBase[BizInquiry]):
    """询价单CRUD操作"""

    def get_by_region(
        self,
        db: Session,
        region_id: str,
        status: str = None,
        skip: int = 0,
        limit: int = 20
    ) -> List[BizInquiry]:
        """根据区域获取询价单列表"""
        query = db.query(BizInquiry).filter(
            and_(
                BizInquiry.region_id == region_id,
                BizInquiry.is_del == 0
            )
        )
        if status:
            query = query.filter(BizInquiry.status == status)
        return query.order_by(BizInquiry.create_at.desc()).offset(skip).limit(limit).all()

    def get_published_by_region(
        self,
        db: Session,
        region_id: str,
        skip: int = 0,
        limit: int = 20
    ) -> List[BizInquiry]:
        """获取区域已发布的询价单列表"""
        return self.get_by_region(db, region_id, status="published", skip=skip, limit=limit)

    def get_multi_with_filters(
        self,
        db: Session,
        region_id: str = None,
        status: str = None,
        keyword: str = None,
        skip: int = 0,
        limit: int = 10
    ) -> tuple[List[BizInquiry], int]:
        """多条件查询询价单"""
        query = db.query(BizInquiry).filter(BizInquiry.is_del == 0)

        if region_id:
            query = query.filter(BizInquiry.region_id == region_id)
        if status:
            query = query.filter(BizInquiry.status == status)
        if keyword:
            query = query.filter(BizInquiry.title.like(f"%{keyword}%"))

        total = query.count()
        inquiries = query.order_by(BizInquiry.create_at.desc()).offset(skip).limit(limit).all()
        return inquiries, total

    def publish(self, db: Session, id: str) -> Optional[BizInquiry]:
        """发布询价单"""
        inquiry = self.get(db, id)
        if inquiry and inquiry.status == "draft":
            inquiry.status = "published"
            inquiry.publish_time = datetime.now()
            db.commit()
            db.refresh(inquiry)
        return inquiry

    def unpublish(self, db: Session, id: str) -> Optional[BizInquiry]:
        """取消发布询价单（published -> draft）"""
        inquiry = self.get(db, id)
        if inquiry and inquiry.status == "published":
            inquiry.status = "draft"
            # 保留 publish_time 作为历史痕迹；如需清空可在这里置 None
            db.commit()
            db.refresh(inquiry)
        return inquiry

    def get_current_published_by_region(self, db: Session, region_id: str) -> Optional[BizInquiry]:
        """获取区域当前发布中的询价单（最多1条，业务上应保证互斥）"""
        return db.query(BizInquiry).filter(
            and_(
                BizInquiry.region_id == region_id,
                BizInquiry.status == "published",
                BizInquiry.is_del == 0
            )
        ).order_by(BizInquiry.publish_time.desc(), BizInquiry.create_at.desc()).first()

    def close(self, db: Session, id: str) -> Optional[BizInquiry]:
        """关闭询价单"""
        inquiry = self.get(db, id)
        if inquiry and inquiry.status == "published":
            inquiry.status = "closed"
            inquiry.close_time = datetime.now()
            db.commit()
            db.refresh(inquiry)
        return inquiry

    def update_with_history(self, db: Session, id: str, obj_in: dict, updater: dict = None) -> Optional[BizInquiry]:
        """更新询价单并记录历史"""
        original = self.get(db, id)
        if not original:
            return None

        his_data = {
            "id": original.id,
            "region_id": original.region_id,
            "title": original.title,
            "status": original.status,
            "publish_time": original.publish_time,
            "close_time": original.close_time,
            "remark": original.remark,
            "create_at": original.create_at,
            "create_by": original.create_by,
            "create_name": original.create_name,
            "update_at": original.update_at,
            "update_by": original.update_by,
        }
        his = BizInquiryHis(**his_data)
        db.add(his)

        return self.update(db, id, obj_in, updater)

    def soft_delete_with_history(self, db: Session, id: str) -> bool:
        """删除询价单并记录历史"""
        original = self.get(db, id)
        if not original:
            return False

        his_data = {
            "id": original.id,
            "region_id": original.region_id,
            "title": original.title,
            "status": original.status,
            "publish_time": original.publish_time,
            "close_time": original.close_time,
            "remark": original.remark,
            "create_at": original.create_at,
            "create_by": original.create_by,
            "create_name": original.create_name,
            "update_at": original.update_at,
            "update_by": original.update_by,
        }
        his = BizInquiryHis(**his_data)
        db.add(his)

        return self.delete(db, id)


class InquiryItemCRUD(CRUDBase[BizInquiryItem]):
    """询价单项CRUD操作"""

    def get_by_inquiry(self, db: Session, inquiry_id: str) -> List[BizInquiryItem]:
        """获取询价单的所有询价项"""
        return db.query(BizInquiryItem).filter(
            and_(
                BizInquiryItem.inquiry_id == inquiry_id,
                BizInquiryItem.is_del == 0
            )
        ).all()

    def get_multi_with_inquiry_ids(
        self,
        db: Session,
        inquiry_ids: List[str]
    ) -> List[BizInquiryItem]:
        """根据多个询价单ID获取询价项"""
        return db.query(BizInquiryItem).filter(
            and_(
                BizInquiryItem.inquiry_id.in_(inquiry_ids),
                BizInquiryItem.is_del == 0
            )
        ).all()

    def create_items(
        self,
        db: Session,
        inquiry_id: str,
        product_ids: List[str],
        creator: dict = None
    ) -> List[BizInquiryItem]:
        """批量创建询价项"""
        items = []
        for product_id in product_ids:
            item = BizInquiryItem(
                id=generate_id(),
                inquiry_id=inquiry_id,
                product_id=product_id,
                create_by=creator.get("user_id") if creator else None,
                create_name=creator.get("real_name") if creator else None
            )
            db.add(item)
            items.append(item)
        db.commit()
        for item in items:
            db.refresh(item)
        return items

    def update_items(
        self,
        db: Session,
        inquiry_id: str,
        product_ids: List[str],
        creator: dict = None
    ) -> List[BizInquiryItem]:
        """更新询价项（先删除旧的，再创建新的）"""
        existing_items = self.get_by_inquiry(db, inquiry_id)
        for item in existing_items:
            item.is_del = 1

        return self.create_items(db, inquiry_id, product_ids, creator)

    def delete_by_inquiry(self, db: Session, inquiry_id: str) -> bool:
        """删除询价单的所有询价项"""
        items = self.get_by_inquiry(db, inquiry_id)
        for item in items:
            item.is_del = 1
        db.commit()
        return True


inquiry_crud = InquiryCRUD(BizInquiry)
inquiry_item_crud = InquiryItemCRUD(BizInquiryItem)