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

from fastapi import APIRouter, Depends, Response, Request
from sqlalchemy.orm import Session
from app.models.database import get_db
from app.models.user import UserInfo,UserDB, PhoneLoginRequest, generate_user_code
from app.models.order import ShippingOrderDB, OrderStatus
from app.core.response import success_response, error_response, ResponseModel
from app.core.wechat import WeChatClient,generate_random_string
from app.core.security import create_access_token
from pydantic import BaseModel, Field
import json
import time
from datetime import datetime, timezone
from app.api.deps import get_current_user
from app.core.config import settings
import random
import string
from app.models.merchant_order import MerchantOrderDB, MerchantOrderStatus
from app.models.merchant_pay_order import MerchantPayOrderDB, MerchantPayOrderStatus
from app.models.merchant import MerchantDB
from app.models.merchant_product import DeliveryType, MerchantProductDB, DeliveryTimeType
import enum
from app.core.point_manager import PointManager
from app.core.point_manager import PointRecordType
from app.core.account import AccountManager
import logging
from app.core.security import get_password_hash
from app.models.order_additional_fee import OrderAdditionalFeeDB, AdditionalFeeResult
from app.api.endpoints.order import calculate_delivery_share
from app.models.wechat_payment import WechatPaymentRecordDB

router = APIRouter()

logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

class PhoneNumberRequest(BaseModel):
    login_code: str  # 登录凭证
    phone_code: str  # 手机号验证码
    referral_code: str = None  # 推荐码（可选）

class WechatPayRequest(BaseModel):
    """微信支付请求"""
    order_id: str

@router.post("/phone-login", response_model=ResponseModel)
async def wechat_phone_login(
    request: PhoneNumberRequest,
    db: Session = Depends(get_db),
    response: Response = None
):
    """通过微信手机号登录/注册"""
    try:
        # 初始化微信客户端 
        wechat = WeChatClient()
        
        # 获取用户 openid
        session_info = await wechat.code2session(request.login_code)
        openid = session_info["openid"]
        unionid = session_info.get("unionid")
        
        # 获取用户手机号
        phone_info = await wechat.get_phone_number(request.phone_code)

        
        if not phone_info:
            return error_response(code=400, message="获取手机号失败")
        
        # 打印调试信息
        print(f"获取到的手机号信息: {phone_info}")
        
        phone = phone_info['phone_number']
        if not phone:
            return error_response(code=400, message="手机号为空")


        # 查找或创建用户
        user = db.query(UserDB).filter(UserDB.openid == openid).first()
        if not user:
            # 生成用户编码
            user_code = generate_user_code(db)
            
            user = UserDB(
                nickname=f"蜜友{phone[-4:]}",
                phone=phone,
                user_code=user_code,
                referral_code=request.referral_code,
                password=get_password_hash("123456"),
                openid=openid,  # 保存 openid
                unionid=unionid  # 保存 unionid
            )
            db.add(user)
            db.flush()
            
            
            db.commit()
            db.refresh(user)
        else:
            # 更新现有用户的 openid 和 unionid
            user.openid = openid
            user.unionid = unionid
            user.phone = phone
            db.commit()
        
        # 创建访问令牌
        access_token = create_access_token(
            data={"phone": user.phone, "userid": user.userid}
        )

        
        return success_response(
            message="登录成功",
            data={
                "user": UserInfo.model_validate(user),
                "access_token": access_token,
                "token_type": "bearer"
            }
        )
    except Exception as e:
        db.rollback()
        logging.exception(f"登录失败: {str(e)}")
        return error_response(code=500, message=f"登录失败: {str(e)}")

@router.post("/create-payment", response_model=ResponseModel)
async def create_payment(
    request: WechatPayRequest,
    db: Session = Depends(get_db),
    current_user: UserDB = Depends(get_current_user)
):
    """创建微信支付订单"""
    try:
        # 根据订单号前缀判断订单类型
        order_prefix = request.order_id[0]
        
        description = ""
        amount = 0
        
        if order_prefix == "D":  # 配送订单
            order = db.query(ShippingOrderDB).filter(
                ShippingOrderDB.orderid == request.order_id
            ).first()
            if not order:
                return error_response(code=404, message="订单不存在")
            description = "蜂快到家-配送费用"
            amount = order.final_amount
        elif order_prefix == "AD":  # 加价订单
            order = db.query(OrderAdditionalFeeDB).filter(
                OrderAdditionalFeeDB.fee_order_id == request.order_id
            ).first()
            if not order:
                logger.error(f"加价订单不存在: {request.order_id}")
                return error_response(code=404, message="订单不存在")
            description = "蜂快到家-加价费用"
            amount = order.additional_fee_amount

        elif order_prefix == "M":  # 商家商品订单
            order = db.query(MerchantOrderDB).filter(
                MerchantOrderDB.order_id == request.order_id
            ).first()
            if not order:
                return error_response(code=404, message="订单不存在")
            description = "蜂快到家-商品购买"
            amount = order.pay_amount
            
        elif order_prefix == "P":  # 商家在线买单
            order = db.query(MerchantPayOrderDB).filter(
                MerchantPayOrderDB.order_id == request.order_id
            ).first()
            if not order:
                return error_response(code=404, message="订单不存在")
            description = "蜂快到家-在线买单"
            amount = order.amount
        else:
            return error_response(code=400, message="无效的订单号")

        # 初始化微信支付客户端
        wechat = WeChatClient()
        
        # 创建支付订单
        result = await wechat.create_jsapi_payment(
            openid=current_user.openid,
            out_trade_no=request.order_id,
            total_amount=int(float(amount) * 100) if not settings.DEBUG else 1,  # 转换为分
            description=description
        )
        
        if not result:
            return error_response(code=500, message="创建支付订单失败")
        
        return success_response(data={
            "prepay_id": result.get("prepay_id"),
            "payment_params": result.get("payment_params")
        })
        
    except Exception as e:
        return error_response(code=500, message=f"创建支付订单失败: {str(e)}")

@router.post("/payment/notify")
async def payment_notify(
    request: Request,
    db: Session = Depends(get_db)
):
    """微信支付回调通知"""
    try:
        # 初始化微信支付客户端
        wechat = WeChatClient()

        data = await wechat.verify_payment_notify(request)
        if not data:
            logger.error(f"回调数据验证失败: {data}")
            return error_response(code=400, message="回调数据验证失败")
        
        logger.info(f"回调数据验证成功: {data}")
        # 获取订单信息
        out_trade_no = data.get("out_trade_no")
        transaction_id = data.get("transaction_id")
        trade_state_desc = data.get("trade_state_desc")
        success_time = data.get("success_time")

        logger.info(f"out_trade_no: {out_trade_no}")
        logger.info(f"transaction_id: {transaction_id}")
        logger.info(f"trade_state_desc: {trade_state_desc}")
        logger.info(f"success_time: {success_time}")
        
        if not all([out_trade_no, transaction_id, trade_state_desc]) or trade_state_desc != "支付成功":
            return error_response(code=400, message="缺少必要的订单信息或支付未成功")
        
        # 判断订单类型并处理
        if out_trade_no.startswith('D'):  # 配送订单
            # 查询配送订单
            order = db.query(ShippingOrderDB).filter(
                ShippingOrderDB.orderid == out_trade_no
            ).first()
            
            if not order:
                return error_response(code=404, message="订单不存在")
            
            if trade_state_desc == "支付成功":
                # 更新订单状态
                if order.deliveryman_user_id:   
                    order.status = OrderStatus.COMPLETED  # 支付成功后状态为已完成
                else:
                    order.status = OrderStatus.CREATED  # 支付成功后状态为已创建

                order.pay_status = True
                order.completed_time = datetime.now()
                order.transaction_id = transaction_id
                order.pay_time = datetime.fromisoformat(success_time.replace('Z', '+00:00'))
        
        elif out_trade_no.startswith("AD"):  # 加价订单
            additon_fee_order = db.query(OrderAdditionalFeeDB).filter(
                OrderAdditionalFeeDB.fee_order_id == out_trade_no
            ).first()
            if not additon_fee_order:
                return error_response(code=404, message="订单不存在")
            
            if trade_state_desc == "支付成功":
                # 更新订单状态
                additon_fee_order.result = AdditionalFeeResult.ACCEPTED
                additon_fee_order.transaction_id = transaction_id

                order = db.query(ShippingOrderDB).filter(
                    ShippingOrderDB.orderid == additon_fee_order.orderid
                ).first()
                if not order:
                    return error_response(code=404, message="订单不存在")
                
                order.additional_fee_amount += float(additon_fee_order.additional_fee_amount)
                order.final_amount += float(additon_fee_order.additional_fee_amount)

                logger.info(f"加价订单支付成功: {additon_fee_order.orderid}")

                # 重新计算配送员配送费用
                order.delivery_share = calculate_delivery_share(order, db)

                
        elif out_trade_no.startswith("M"):  # 商家商品订单
            # 查询商户订单
            order = db.query(MerchantOrderDB).filter(
                MerchantOrderDB.order_id == out_trade_no
            ).first()
            
            if not order:
                return error_response(code=404, message="订单不存在")
            
            if trade_state_desc == "支付成功":
                product = db.query(MerchantProductDB).filter(
                    MerchantProductDB.id == order.merchant_product_id
                ).first()

                # 更新订单状态
                if product.delivery_type == DeliveryType.DELIVERY:
                    if product.delivery_time_type == DeliveryTimeType.IMMEDIATE:
                        order.status = MerchantOrderStatus.PENDING
                    elif product.delivery_time_type == DeliveryTimeType.SCHEDULED:
                        order.status = MerchantOrderStatus.DELIVERING
                elif product.delivery_type == DeliveryType.PICKUP:
                    order.status = MerchantOrderStatus.PICKUP_READY
                else:
                    order.status = MerchantOrderStatus.PENDING
                
                order.pay_status = True
                order.transaction_id = transaction_id
                order.pay_time = datetime.fromisoformat(success_time.replace('Z', '+00:00'))

        elif out_trade_no.startswith("P"):  # 商家在线买单
            order = db.query(MerchantPayOrderDB,MerchantDB).filter(
                MerchantPayOrderDB.order_id == out_trade_no
            ).join(
                MerchantDB,
                MerchantPayOrderDB.merchant_id == MerchantDB.id
            ).first()
            
            if not order:
                return error_response(code=404, message="订单不存在")
            
            if trade_state_desc == "支付成功":
                if order.MerchantPayOrderDB.gift_points > 0:
                    # 添加积分
                    point_manager = PointManager(db)
                    point_manager.add_points(user_id= order.MerchantPayOrderDB.user_id, 
                                             points= order.MerchantPayOrderDB.gift_points, 
                                             description=f"买单订单奖励", 
                                             order_id=order.MerchantPayOrderDB.order_id)

                # 更新订单状态
                order.MerchantPayOrderDB.pay_status = True
                order.MerchantPayOrderDB.status = MerchantPayOrderStatus.PAID
                order.MerchantPayOrderDB.transaction_id = transaction_id
                order.MerchantPayOrderDB.pay_time = datetime.fromisoformat(success_time.replace('Z', '+00:00'))

                # 对商家进行分账计算
                account_manager = AccountManager(db)
                settlement_amount = float(order.MerchantPayOrderDB.amount) * float(order.MerchantDB.pay_share_rate) / 100
                
                if settlement_amount > 0:
                    account_manager.change_balance(
                        user_id=order.MerchantDB.user_id,
                        amount=settlement_amount,
                        description=f"在线买单结算",
                        transaction_id=order.MerchantPayOrderDB.order_id
                    )
        
        else:
            return error_response(code=400, message="未知的订单类型")
        
        # 在支付回调处理中添加记录
        payment_record = WechatPaymentRecordDB(
            out_trade_no=out_trade_no,
            transaction_id=transaction_id,
            trade_state=data.get("trade_state"),
            trade_state_desc=trade_state_desc,
            success_time=datetime.fromisoformat(success_time) if success_time else None,
            total_amount=float(data.get("amount", {}).get("total", 0)) / 100,
            payer_total=float(data.get("amount", {}).get("payer_total", 0)) / 100,
            payer_openid=data.get("payer", {}).get("openid"),
            bank_type=data.get("bank_type"),
            promotion_detail=data.get("promotion_detail"),
            raw_data=data
        )
        db.add(payment_record)
        db.commit()
        
        # 返回成功
        return success_response(message="支付成功")
        
    except Exception as e:
        logger.error(f"处理支付回调失败: {str(e)}")
        db.rollback()
        return error_response(code=500, message=f"处理支付回调失败: {str(e)}")

@router.post("/refund/notify")
async def refund_notify(
    request: Request,
    db: Session = Depends(get_db)
):
    """微信支付退款回调通知"""
    try:
        # 初始化微信支付客户端
        wechat = WeChatClient()

        data = await wechat.verify_payment_notify(request)
        if not data:
            logger.error(f"退款回调数据验证失败: {data}")
            return error_response(code=400, message="回调数据验证失败")
        
        logger.info(f"退款回调数据验证成功: {data}")
        
        # 获取退款信息
        out_trade_no = data.get("out_trade_no")  # 订单号
        status = data.get("refund_status")
        success_time = data.get("success_time")
        
        if not all([out_trade_no, status]) or status != "SUCCESS":
            return error_response(code=400, message="缺少必要的退款信息或退款未成功")
        
        # 根据订单类型处理退款
        if out_trade_no.startswith('M'):  # 商家商品订单
            order = db.query(MerchantOrderDB).filter(
                MerchantOrderDB.order_id == out_trade_no,
                MerchantOrderDB.status == MerchantOrderStatus.REFUNDING
            ).first()
            
            if not order:
                return error_response(code=404, message="订单不存在或状态不正确")
            
            # 更新订单状态
            order.status = MerchantOrderStatus.CANCELLED
            order.refund_transaction_id = data.get("transaction_id")
            order.refund_time = datetime.fromisoformat(success_time.replace('Z', '+00:00'))
        
        elif out_trade_no.startswith('P'):  # 商家在线买单
            order = db.query(MerchantPayOrderDB).filter(
                MerchantPayOrderDB.order_id == out_trade_no,
                MerchantPayOrderDB.status == MerchantPayOrderStatus.REFUNDING
            ).first()
            
            if not order:
                return error_response(code=404, message="订单不存在或状态不正确")
            
            # 更新订单状态
            order.status = MerchantPayOrderStatus.REFUNDED
            
            # 扣除积分
            if order.gift_points > 0:
                point_manager = PointManager(db)
                point_manager.deduct_points(
                    user_id = order.user_id,
                    points = order.gift_points,
                    description = f"订单取消扣除",
                    order_id = order.order_id
                )
        
        else:
            return error_response(code=400, message="不支持的订单类型")
        
        db.commit()
        return success_response(message="退款处理成功")
        
    except Exception as e:
        logger.error(f"处理退款回调失败: {str(e)}")
        db.rollback()
        return error_response(code=500, message=f"处理退款回调失败: {str(e)}")