deliveryman-api/app/api/endpoints/order_additional_fee.py

from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session
from app.models.order_additional_fee import (
    OrderAdditionalFeeDB,
    OrderAdditionalFeeCreate,
    OrderAdditionalFeeUpdate,
    OrderAdditionalFeeInfo,
    AdditionalFeeResult
)
from app.models.order import ShippingOrderDB, OrderStatus
from app.models.database import get_db
from app.api.deps import get_current_user, get_deliveryman_user
from app.models.user import UserDB
from app.core.response import success_response, error_response, ResponseModel
from typing import List, Optional
from datetime import datetime
import aiohttp
from app.core.config import settings

router = APIRouter()

@router.post("", response_model=ResponseModel)
async def create_additional_fee_request(
    fee_request: OrderAdditionalFeeCreate,
    db: Session = Depends(get_db),
    deliveryman: UserDB = Depends(get_deliveryman_user)
):
    """创建加价请求（配送员）"""
    # 检查订单是否存在
    order = db.query(ShippingOrderDB).filter(
        ShippingOrderDB.orderid == fee_request.orderid
    ).first()
    
    if not order:
        return error_response(code=404, message="订单不存在")
    
    # 检查是否是该订单的配送员
    if order.deliveryman_user_id != deliveryman.userid:
        return error_response(code=403, message="您不是该订单的配送员")
    
    # 检查是否已经有未处理的加价请求
    existing_request = db.query(OrderAdditionalFeeDB).filter(
        OrderAdditionalFeeDB.orderid == fee_request.orderid
    ).first()
    
    if existing_request:
        return error_response(code=400, message="该订单已有未处理的加价请求")
    
    # 创建加价请求
    db_fee_request = OrderAdditionalFeeDB(
        orderid=fee_request.orderid,
        order_user_id=order.userid,
        deliveryman_id=deliveryman.userid,
        reason=fee_request.reason,
        photo_urls=fee_request.photo_urls,
        additional_fee_amount=fee_request.additional_fee_amount,
        result=AdditionalFeeResult.PENDING
    )
    
    db.add(db_fee_request)
    
    try:
        db.commit()
        db.refresh(db_fee_request)
        
        # TODO: 发送通知给用户
        
        return success_response(data=OrderAdditionalFeeInfo.model_validate(db_fee_request))
    except Exception as e:
        db.rollback()
        return error_response(code=500, message=f"创建加价请求失败: {str(e)}")

@router.get("/order/{orderid}", response_model=ResponseModel)
async def get_order_additional_fees(
    orderid: str,
    db: Session = Depends(get_db),
    current_user: UserDB = Depends(get_current_user)
):
    """获取订单的加价请求列表"""
    # 检查订单是否存在
    request = db.query(OrderAdditionalFeeDB).filter(
        OrderAdditionalFeeDB.orderid == orderid,
        OrderAdditionalFeeDB.result == AdditionalFeeResult.PENDING
    ).first()
    
    if not request:
        return error_response(code=404, message="加价请求不存在")
    
    # 检查是否是订单相关人员
    if request.order_user_id != current_user.userid and request.deliveryman_id != current_user.userid:
        return error_response(code=403, message="您无权查看该订单的加价请求")
    
    result = OrderAdditionalFeeInfo.model_validate(request).model_dump()

    if result.get("deliveryman_id"):
        deliveryman = db.query(UserDB).filter(
            UserDB.userid == result.get("deliveryman_id")
        ).first()

        result.update({
            "deliveryman_name": deliveryman.nickname,
            "deliveryman_avatar": deliveryman.avatar,
            "deliveryman_phone": deliveryman.phone
        })
    
    return success_response(data=result)

@router.put("/{request_id}/accept", response_model=ResponseModel)
async def accept_additional_fee(
    request_id: int,
    db: Session = Depends(get_db),
    current_user: UserDB = Depends(get_current_user)
):
    """接受加价请求（用户）"""
    # 获取加价请求
    fee_request = db.query(OrderAdditionalFeeDB).filter(
        OrderAdditionalFeeDB.id == request_id
    ).first()
    
    if not fee_request:
        return error_response(code=404, message="加价请求不存在")
    
    # 检查是否是订单用户
    if fee_request.order_user_id != current_user.userid:
        return error_response(code=403, message="您无权处理该加价请求")
    
    # 检查请求状态
    if fee_request.result != AdditionalFeeResult.PENDING:
        return error_response(code=400, message="该加价请求已处理")
    
    # 更新请求状态
    fee_request.result = AdditionalFeeResult.ACCEPTED
    
    # 更新订单金额
    order = db.query(ShippingOrderDB).filter(
        ShippingOrderDB.orderid == fee_request.orderid
    ).first()
    
    if order:
        order.additional_fee_amount += float(fee_request.additional_fee_amount)
        order.final_amount += float(fee_request.additional_fee_amount)
    
    try:
        db.commit()
        
        # TODO: 发送通知给配送员
        
        return success_response(message="已接受加价请求")
    except Exception as e:
        db.rollback()
        return error_response(code=500, message=f"处理加价请求失败: {str(e)}")
    
# 更新加价请求
@router.put("/{request_id}", response_model=ResponseModel)
async def update_additional_fee(
    request_id: int,
    new_fee_request: OrderAdditionalFeeUpdate,
    db: Session = Depends(get_db),
    current_user: UserDB = Depends(get_deliveryman_user)
):
    """更新加价请求"""
    # 获取加价请求
    old_fee_request = db.query(OrderAdditionalFeeDB).filter(
        OrderAdditionalFeeDB.id == request_id,
        OrderAdditionalFeeDB.result == AdditionalFeeResult.PENDING
    ).first()
    
    if not old_fee_request:
        return error_response(code=404, message="加价请求不存在")
    
    # 检查是否是订单用户
    if old_fee_request.deliveryman_id != current_user.userid:
        return error_response(code=403, message="您无权处理该加价请求")
    
    # 更新加价请求
    old_fee_request.reason = new_fee_request.reason
    old_fee_request.photo_urls = new_fee_request.photo_urls
    old_fee_request.additional_fee_amount = new_fee_request.additional_fee_amount
    
    try:
        db.commit()
        db.refresh(old_fee_request)
        return success_response(data=OrderAdditionalFeeInfo.model_validate(old_fee_request))
    except Exception as e:
        db.rollback()
        return error_response(code=500, message=f"更新加价请求失败: {str(e)}")