# app/services/order_service.py import uuid import json from datetime import datetime, timedelta from typing import List, Optional from redis.asyncio import Redis from sqlalchemy.ext.asyncio import AsyncSession from sqlalchemy import select, delete, or_ from app.core.logger import logger from app.utils.search import apply_keyword_search_stmt from app.utils.pagination import paginate from app.core.biz_exception import NotFoundError, BizLogicError, PermissionDeniedError from app.models.user import VasUser from app.models.order import VasOrder from app.models.vas_task import VasTask from app.models.product import VasProduct from app.models.payment import VasPayment from app.models.payment_confirmation import VasPaymentConfirmation from app.models.payment_event import VasPaymentEvent from app.models.order_event import VasOrderEvent from app.models.ticket import VasTicket from app.models.ticket_message import VasTicketMessage from app.models.fault import VasFaultCompensation from app.models.settlement import VasSettlementDetail from app.models.agency import VasAgency from app.schemas.order import VasOrderCreate, VasOrderCreateAdmin, VasOrderAdjustPrice, VasOrderPatchUserInputs, VasOrderUpdate, VasOrderRegisterPayment from app.services.webhook_service import WebhookService from app.services.agency_service import AgencyService class OrderService: @staticmethod async def create( db: AsyncSession, data: VasOrderCreate, product: VasProduct, auth_user: VasUser, redis_client: Redis, ) -> VasOrder: """ 前台散客自主下单 (公海订单) """ if not auth_user.email: raise BizLogicError( "Your account must be linked to an email address before you can place an order." ) order_id = f"ORD-{datetime.utcnow():%Y%m%d%H%M%S}-{uuid.uuid4().hex[:8]}" safe_product_name = (product.title[:100]) if product.title else "" order = VasOrder( id=order_id, **data.dict(), product_name=safe_product_name, base_amount=product.price_amount, base_currency=product.price_currency, adjustment_delta=0, final_amount=product.price_amount, user_id=auth_user.id, channel_type='website', # 官网公海 handler_id=None, # 无专人对接,销售提成甲乙双方对半平分 developer_id=None, # 订单不硬绑开发者ID,由商品绑定插件动态解析技术分成归属 settlement_status='unsettled', ) db.add(order) await db.commit() await db.refresh(order) logger.info(f"📦 [ORDER] Created website order: id={order.id} product={product.id} user={auth_user.id} amount={order.final_amount} {order.base_currency}") return order @staticmethod async def create_by_admin( db: AsyncSession, data: VasOrderCreateAdmin, product: VasProduct, auth_user: VasUser ) -> VasOrder: """ 后台管理员/客服代客录单 (支持社交自收直客 与 中介渠道同行单) """ channel_type = data.channel_type or "direct" agency_id = data.agency_id if channel_type == "agency" else None # 确定金额与收款时机 final_amount = data.final_amount if (data.final_amount is not None and data.final_amount > 0) else product.price_amount timing = getattr(data, "payment_timing", "pay_later") or "pay_later" is_paid_now = (timing == "paid_now") initial_status = "paid" if is_paid_now else "pending" # 渠道判定与底价拦截 if channel_type == "agency": if not agency_id: raise BizLogicError("Agency channel orders must specify agency_id") agency = await AgencyService.get(db, agency_id) if not agency: raise BizLogicError(f"Agency not found: {agency_id}") if agency.status != 1: raise BizLogicError(f"Agency '{agency.name}' is currently suspended") # 专属对接人绑定 (中介拓展人独享40%提成) handler_id = agency.owner_id # 底价校验 effective_floor = agency.min_floor_price if agency.min_floor_price > 0 else (getattr(product, 'min_floor_price', 0) or 0) if effective_floor > 0 and final_amount < effective_floor: raise BizLogicError(f"Agency order amount ({final_amount/100:.2f}) cannot be lower than the minimum floor price ({effective_floor/100:.2f})") else: # 社交账号自收直客单 (小红书/微信私域): 默认录单人自己,亦可指定团队接单人 handler_id = data.handler_id or auth_user.id order_id = f"ORD-{datetime.utcnow():%Y%m%d%H%M%S}-{uuid.uuid4().hex[:8]}" safe_product_name = (product.title[:100]) if product.title else "" order = VasOrder( id=order_id, product_id=data.product_id, user_inputs=data.user_inputs, status=initial_status, product_name=safe_product_name, base_amount=product.price_amount, base_currency=product.price_currency, adjustment_delta=final_amount - product.price_amount, final_amount=final_amount, user_id=auth_user.id, channel_type=channel_type, agency_id=agency_id, handler_id=handler_id, developer_id=None, # 订单不硬绑开发者ID,由商品绑定插件动态解析技术分成归属 settlement_status='unsettled', ) # ===== user_inputs 安全修复与审计 ===== raw_inputs = order.user_inputs if isinstance(raw_inputs, str): try: order.user_inputs = json.loads(raw_inputs) except Exception: order.user_inputs = {} elif raw_inputs is None or not isinstance(raw_inputs, dict): order.user_inputs = {} order.user_inputs["_admin_bypass"] = { "enabled": True, "by": auth_user.id, "at": datetime.utcnow().isoformat(), "reason": "admin manual order", "channel_type": channel_type, "handler_id": handler_id, "payment_timing": timing, } db.add(order) # 若当场全款已付,则同步生成核销入账流水 if is_paid_now: provider = data.payment_method or "offline" payment = VasPayment( order_id=order.id, provider=provider, channel="admin_manual", payment_intent_id=f"MANUAL-{datetime.utcnow():%Y%m%d%H%M%S}-{uuid.uuid4().hex[:6]}", external_trade_no=data.external_trade_no, status="succeeded", base_amount=product.price_amount, adjustment_delta=final_amount - product.price_amount, final_amount=final_amount, base_currency=product.price_currency, amount=final_amount, currency=product.price_currency, random_offset=0, exchange_rate=1.0, provider_payload={ "timing": "paid_now", "note": data.payment_note or "代客录单当场全款结清", "voucher_url": data.voucher_url, "registered_by": auth_user.id, "registered_by_name": getattr(auth_user, "name", auth_user.id), "registered_at": datetime.utcnow().isoformat(), }, ) db.add(payment) # 记录收款凭证审计记录至订单 user_inputs user_inputs = dict(order.user_inputs or {}) history = list(user_inputs.get("_payments_history", [])) history.append({ "amount": final_amount, "provider": provider, "external_trade_no": data.external_trade_no, "voucher_url": data.voucher_url, "note": data.payment_note or "代客录单当场全款结清", "by": auth_user.id, "at": datetime.utcnow().isoformat(), }) user_inputs["_payments_history"] = history order.user_inputs = user_inputs # 无论先办后付还是当场现结,抢单任务均立即入队调度! await WebhookService._create_task_if_not_exists(db, order) await db.commit() await db.refresh(order) logger.info(f"👑 [ORDER] Admin created order: id={order.id} product={product.id} channel={channel_type} timing={timing} status={initial_status} amount={final_amount}") return order @staticmethod async def register_payment( db: AsyncSession, payload: VasOrderRegisterPayment, current_user: VasUser, ) -> VasOrder: """ 管理员/客服对订单进行实收金额登记与核销入账 (适用于先办后付尾款或线下补款) """ stmt = select(VasOrder).where(VasOrder.id == payload.order_id) order = (await db.execute(stmt)).scalar_one_or_none() if not order: raise NotFoundError(f"Order not found: {payload.order_id}") if payload.amount <= 0: raise BizLogicError("Payment amount must be greater than 0") # 检查中介底价拦截 if order.channel_type == "agency" and order.agency_id: agency = await AgencyService.get(db, order.agency_id) if agency and agency.min_floor_price > 0 and payload.amount < agency.min_floor_price: raise BizLogicError( f"Registered amount (¥{payload.amount/100:.2f}) is below agency minimum floor settlement price (¥{agency.min_floor_price/100:.2f})" ) order.final_amount = payload.amount order.adjustment_delta = payload.amount - order.base_amount # 状态流转: 若原先为 pending 待付款,直接转为 paid if order.status == "pending": order.status = "paid" # 若订单已是 completed 状态,且此前未进入 eligible,更新为 eligible if order.status == "completed" and order.settlement_status == "unsettled": order.settlement_status = "eligible" # 生成成功支付流水记录 payment = VasPayment( order_id=order.id, provider=payload.payment_method or "offline", channel="admin_manual", payment_intent_id=f"MANUAL-{datetime.utcnow():%Y%m%d%H%M%S}-{uuid.uuid4().hex[:6]}", external_trade_no=payload.external_trade_no, status="succeeded", base_amount=order.base_amount, adjustment_delta=order.adjustment_delta, final_amount=payload.amount, base_currency=order.base_currency, amount=payload.amount, currency=order.base_currency, random_offset=0, exchange_rate=1.0, provider_payload={ "timing": "post_pay_registered", "note": payload.note or "代客下单后置收款登记", "voucher_url": payload.voucher_url, "registered_by": current_user.id, "registered_by_name": getattr(current_user, "name", current_user.id), "registered_at": datetime.utcnow().isoformat(), }, ) db.add(payment) # 审计日志追加 user_inputs = order.user_inputs or {} if not isinstance(user_inputs, dict): try: user_inputs = json.loads(user_inputs) except Exception: user_inputs = {} history = user_inputs.get("_payments_history", []) history.append({ "amount": payload.amount, "provider": payload.payment_method, "external_trade_no": payload.external_trade_no, "voucher_url": payload.voucher_url, "note": payload.note, "by": current_user.id, "at": datetime.utcnow().isoformat(), }) user_inputs["_payments_history"] = history order.user_inputs = user_inputs await db.commit() await db.refresh(order) logger.info( f"💰 [ORDER] Registered payment for order {order.id}: " f"amount={payload.amount} method={payload.payment_method} by={current_user.id}" ) return order @staticmethod async def cancel( db: AsyncSession, order_id: str, ) -> VasOrder: stmt = select(VasOrder).where(VasOrder.id == order_id) order = (await db.execute(stmt)).scalar_one_or_none() if not order: raise NotFoundError("Order not exist") order.status = "closed" order.settlement_status = "unsettled" task_res = await db.execute( select(VasTask).where( VasTask.order_id == order.id, VasTask.status.in_(["pending", "grabbed", "running", "pause", "completed"]), ) ) for task in task_res.scalars().all(): task.status = "cancelled" await db.commit() await db.refresh(order) logger.info(f"🚫 [ORDER] Cancelled order: id={order.id} and its associated tasks") return order @staticmethod async def delete_by_admin( db: AsyncSession, order_id: str, current_user: VasUser, ) -> bool: """ 管理员彻底删除订单及关联的所有流水、任务、工单、事件与结算记录 (主要用于测试数据或异常数据清理) """ stmt = select(VasOrder).where(VasOrder.id == order_id) order = (await db.execute(stmt)).scalar_one_or_none() if not order: raise NotFoundError(f"Order not found: {order_id}") # 1. 查找关联的支付流水记录 ID p_stmt = select(VasPayment.id).where(VasPayment.order_id == order_id) payment_ids = list((await db.execute(p_stmt)).scalars().all()) # 2. 查找关联的客户支持工单 ID t_stmt = select(VasTicket.id).where(VasTicket.order_id == order_id) ticket_ids = list((await db.execute(t_stmt)).scalars().all()) # 3. 删除工单沟通消息及工单主体 if ticket_ids: await db.execute(delete(VasTicketMessage).where(VasTicketMessage.ticket_id.in_(ticket_ids))) await db.execute(delete(VasTicket).where(VasTicket.id.in_(ticket_ids))) # 4. 删除支付相关记录 (核销单、网关原始回调事件、支付流水) if payment_ids: await db.execute(delete(VasPaymentConfirmation).where(VasPaymentConfirmation.payment_id.in_(payment_ids))) await db.execute( delete(VasPaymentEvent).where( or_( VasPaymentEvent.matched_order_id == order_id, VasPaymentEvent.matched_payment_id.in_(payment_ids), ) ) ) await db.execute(delete(VasPayment).where(VasPayment.id.in_(payment_ids))) else: await db.execute(delete(VasPaymentEvent).where(VasPaymentEvent.matched_order_id == order_id)) # 5. 删除抓号/抢单自动化执行任务 await db.execute(delete(VasTask).where(VasTask.order_id == order_id)) # 6. 删除订单全生命周期流转事件日志 await db.execute(delete(VasOrderEvent).where(VasOrderEvent.order_no == order_id)) # 7. 删除财务结算分成与故障过失记录 await db.execute(delete(VasSettlementDetail).where(VasSettlementDetail.order_id == order_id)) await db.execute(delete(VasFaultCompensation).where(VasFaultCompensation.order_id == order_id)) # 8. 删除主订单记录 await db.delete(order) await db.commit() logger.warning( f"🗑️ [ORDER DELETE] Admin {current_user.id} permanently deleted order {order_id} " f"(associated payments: {len(payment_ids)}, tickets: {len(ticket_ids)})" ) return True @staticmethod async def mark_completed( db: AsyncSession, order_id: str, risk_days: int = 7 ) -> VasOrder: """ 履约成功完成订单,并自动开启 T+N 退款风险期 """ stmt = select(VasOrder).where(VasOrder.id == order_id) order = (await db.execute(stmt)).scalar_one_or_none() if not order: raise NotFoundError("Order not exist") now = datetime.utcnow() order.status = "completed" order.completed_at = now order.risk_cleared_at = now + timedelta(days=risk_days) order.settlement_status = "eligible" await db.commit() await db.refresh(order) logger.info(f"🎉 [ORDER] Order completed: id={order.id}, risk cleared at: {order.risk_cleared_at}") return order @staticmethod async def adjust_order_price(db: AsyncSession, order_id: str, payload: VasOrderAdjustPrice) -> VasOrder: stmt = select(VasOrder).where(VasOrder.id == order_id) order = (await db.execute(stmt)).scalar_one_or_none() if not order: logger.warning(f"⚠️ [ORDER] Price adjust failed: Order {order_id} not found") raise NotFoundError("Order not exist") if order.status != "pending": logger.warning(f"⚠️ [ORDER] Price adjust failed: Order {order_id} status is {order.status} (expected pending)") raise BizLogicError(message="Order not adjustable") new_final = order.base_amount + payload.adjustment_delta if new_final <= 0: raise BizLogicError(message="final_amount must be > 0") order.adjustment_delta = payload.adjustment_delta order.final_amount = new_final # 是否已有 pending payment stmt = select(VasPayment).where( VasPayment.order_id == order.id, VasPayment.status == "pending", ) active_payment = (await db.execute(stmt)).scalar_one_or_none() if active_payment: active_payment.status = "expired" await db.commit() await db.refresh(order) logger.info(f"💰 [ORDER] Adjusted order price: id={order.id} new={order.final_amount} delta={payload.adjustment_delta}") return order @staticmethod async def get(db: AsyncSession, order_id: str) -> Optional[VasOrder]: stmt = select(VasOrder).where(VasOrder.id == order_id) return (await db.execute(stmt)).scalar_one_or_none() @staticmethod async def get_authorized_order( db: AsyncSession, order_id: str, current_user: VasUser ) -> VasOrder: order = await OrderService.get(db, order_id) if not order: raise NotFoundError("Order not found") if current_user.role != "admin" and str(order.user_id) != str(current_user.id): raise PermissionDeniedError("Permission denied: You do not have access to this order") return order @staticmethod async def list_by_user( db: AsyncSession, user_id: str, page: int = 0, size: int = 10, keyword: Optional[str] = None, ): stmt = select(VasOrder).where(VasOrder.user_id == user_id) stmt = apply_keyword_search_stmt( stmt=stmt, model=VasOrder, keyword=keyword, fields=["id", "user_id", "product_name", "user_inputs"], ).order_by(VasOrder.created_at.desc()) return await paginate(db, stmt, page, size) @staticmethod async def list_all( db: AsyncSession, page: int = 0, size: int = 10, keyword: Optional[str] = None, channel_type: Optional[str] = None, handler_id: Optional[str] = None, settlement_status: Optional[str] = None, ): stmt = select(VasOrder) if channel_type: stmt = stmt.where(VasOrder.channel_type == channel_type) if handler_id: stmt = stmt.where(VasOrder.handler_id == handler_id) if settlement_status: stmt = stmt.where(VasOrder.settlement_status == settlement_status) query = apply_keyword_search_stmt( stmt=stmt, model=VasOrder, keyword=keyword, fields=["id", "user_id", "user_name", "product_name", "user_inputs", "handler_id", "agency_id"], ).order_by(VasOrder.created_at.desc()) return await paginate(db, query, page, size) @staticmethod async def patch_user_inputs( db: AsyncSession, order_id: str, payload: VasOrderPatchUserInputs, ) -> VasOrder: stmt = select(VasOrder).where(VasOrder.id == order_id) order = (await db.execute(stmt)).scalar_one_or_none() if not order: logger.warning(f"⚠️ [ORDER] Patch user_inputs failed: Order {order_id} not found") raise NotFoundError("Order not exist") order.user_inputs = payload.user_inputs # 取消旧任务 task_res = await db.execute( select(VasTask).where( VasTask.order_id == order.id, VasTask.status.in_(["pending", "grabbed", "running", "pause", "completed"]), ) ) for task in task_res.scalars().all(): task.status = "cancelled" await db.flush() await WebhookService._create_task_if_not_exists(db, order) await db.commit() await db.refresh(order) logger.info(f"🔄 [ORDER] Patched user inputs for order {order.id}, recreated tasks") return order @staticmethod async def update_order( db: AsyncSession, order_id: str, data: VasOrderUpdate, ) -> VasOrder: stmt = select(VasOrder).where(VasOrder.id == order_id) order = (await db.execute(stmt)).scalar_one_or_none() if not order: logger.warning(f"⚠️ [ORDER] Update failed: Order {order_id} not found") raise NotFoundError("Order not exist") if data.channel_type is not None: order.channel_type = data.channel_type if data.channel_type == "agency": if data.agency_id is not None: order.agency_id = data.agency_id.strip() if data.agency_id else None if data.handler_id is not None: order.handler_id = data.handler_id.strip() if data.handler_id else None elif order.agency_id: agency = await AgencyService.get(db, order.agency_id) if agency and agency.owner_id: order.handler_id = agency.owner_id elif data.channel_type == "direct": order.agency_id = None if data.handler_id is not None: order.handler_id = data.handler_id.strip() if data.handler_id else None elif data.channel_type == "website": order.agency_id = None if data.handler_id is not None: order.handler_id = data.handler_id.strip() if data.handler_id else None else: if data.agency_id is not None: order.agency_id = data.agency_id.strip() if data.agency_id else None if data.handler_id is not None: order.handler_id = data.handler_id.strip() if data.handler_id else None if data.status is not None: order.status = data.status if data.user_inputs is not None: order.user_inputs = data.user_inputs task_res = await db.execute( select(VasTask).where( VasTask.order_id == order.id, VasTask.status.in_(["pending", "grabbed", "running", "pause", "completed"]), ) ) for task in task_res.scalars().all(): task.status = "cancelled" await db.flush() await WebhookService._create_task_if_not_exists(db, order) await db.commit() await db.refresh(order) logger.info(f"🔄 [ORDER] Admin updated order: id={order.id} channel={order.channel_type} handler={order.handler_id} agency={order.agency_id}") return order