Kamixitong/app/api/order.py

from flask import request, jsonify, current_app
from . import api_bp
from ..models import Order, Product
from .. import db
from .decorators import require_admin
from datetime import datetime

@api_bp.route('/orders', methods=['GET'])
@require_admin
def get_orders():
    """获取订单列表（管理员）"""
    try:
        # 获取查询参数
        page = request.args.get('page', 1, type=int)
        per_page = request.args.get('per_page', 10, type=int)
        keyword = request.args.get('keyword', '').strip()
        status = request.args.get('status', type=int)
        product_id = request.args.get('product_id')
        date_range = request.args.get('date_range')
        
        # 构建查询
        query = Order.query
        
        # 关键词搜索
        if keyword:
            query = query.filter(
                db.or_(
                    Order.order_number.contains(keyword),
                    Order.contact_person.contains(keyword),
                    Order.phone.contains(keyword)
                )
            )
        
        # 状态筛选
        if status is not None:
            query = query.filter(Order.status == status)
        
        # 产品筛选
        if product_id:
            query = query.filter(Order.product_id == product_id)
        
        # 日期范围筛选
        if date_range:
            # 解析日期范围（格式：YYYY-MM-DD to YYYY-MM-DD）
            try:
                start_date_str, end_date_str = date_range.split(' to ')
                start_date = datetime.strptime(start_date_str, '%Y-%m-%d')
                end_date = datetime.strptime(end_date_str, '%Y-%m-%d')
                # 设置结束时间为当天23:59:59
                end_date = end_date.replace(hour=23, minute=59, second=59)
                query = query.filter(Order.create_time.between(start_date, end_date))
            except Exception as e:
                current_app.logger.warning(f"日期范围解析失败: {str(e)}")
        
        # 排序
        query = query.order_by(Order.create_time.desc())
        
        # 分页
        pagination = query.paginate(
            page=page, per_page=per_page, error_out=False
        )
        
        orders = pagination.items
        
        return jsonify({
            'success': True,
            'data': {
                'orders': [order.to_dict() for order in orders],
                'pagination': {
                    'current_page': pagination.page,
                    'per_page': pagination.per_page,
                    'total_pages': pagination.pages,
                    'total_items': pagination.total
                }
            }
        })
        
    except Exception as e:
        current_app.logger.error(f"获取订单列表失败: {str(e)}")
        return jsonify({
            'success': False,
            'message': '服务器内部错误'
        }), 500


@api_bp.route('/orders/<int:order_id>', methods=['GET'])
@require_admin
def get_order(order_id):
    """获取订单详情（管理员）"""
    try:
        order = Order.query.get_or_404(order_id)
        return jsonify({
            'success': True,
            'data': order.to_dict()
        })
        
    except Exception as e:
        current_app.logger.error(f"获取订单详情失败: {str(e)}")
        return jsonify({
            'success': False,
            'message': '服务器内部错误'
        }), 500


@api_bp.route('/orders/<int:order_id>/confirm-payment', methods=['POST'])
@require_admin
def confirm_order_payment(order_id):
    """确认订单支付（管理员）"""
    try:
        order = Order.query.get_or_404(order_id)
        
        if order.status != 0:  # 只有待支付的订单可以确认支付
            return jsonify({
                'success': False,
                'message': '订单状态不允许此操作'
            }), 400
        
        # 更新订单状态
        order.status = 1  # 已支付
        order.payment_time = datetime.utcnow()
        order.payment_method = 'manual'  # 手动确认
        
        db.session.commit()
        
        return jsonify({
            'success': True,
            'message': '订单支付确认成功'
        })
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"确认订单支付失败: {str(e)}")
        return jsonify({
            'success': False,
            'message': '服务器内部错误'
        }), 500


@api_bp.route('/orders/<int:order_id>/complete', methods=['POST'])
@require_admin
def complete_order(order_id):
    """完成订单（管理员）"""
    try:
        order = Order.query.get_or_404(order_id)
        
        if order.status != 1:  # 只有已支付的订单可以完成
            return jsonify({
                'success': False,
                'message': '订单状态不允许此操作'
            }), 400
        
        # 更新订单状态
        order.status = 3  # 已完成
        order.update_time = datetime.utcnow()
        
        db.session.commit()
        
        return jsonify({
            'success': True,
            'message': '订单完成操作成功'
        })
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"完成订单失败: {str(e)}")
        return jsonify({
            'success': False,
            'message': '服务器内部错误'
        }), 500


@api_bp.route('/orders/<int:order_id>/cancel', methods=['POST'])
@require_admin
def cancel_order(order_id):
    """取消订单（管理员）"""
    try:
        order = Order.query.get_or_404(order_id)
        
        if order.status not in [0, 1]:  # 只有待支付和已支付的订单可以取消
            return jsonify({
                'success': False,
                'message': '订单状态不允许此操作'
            }), 400
        
        # 更新订单状态
        order.status = 2  # 已取消
        order.update_time = datetime.utcnow()
        
        db.session.commit()
        
        return jsonify({
            'success': True,
            'message': '订单取消操作成功'
        })
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"取消订单失败: {str(e)}")
        return jsonify({
            'success': False,
            'message': '服务器内部错误'
        }), 500