| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611 |
- # 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
- # 确定货币种类 (优先从请求中获取,其次取商品指导币种,默认CNY)
- req_currency = getattr(data, "currency", None)
- order_currency = req_currency.strip().upper() if (req_currency and req_currency.strip()) else (product.price_currency or "CNY")
- 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=order_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=order_currency,
- amount=final_amount,
- currency=order_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")
- # 允许在登记实收时更新或指定货币代码 (如 EUR, USD, CNY)
- if getattr(payload, "currency", None) and payload.currency.strip():
- order.base_currency = payload.currency.strip().upper()
- # 检查中介底价拦截
- 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:
- sym = "¥" if order.base_currency in ("CNY", "RMB") else f"{order.base_currency} "
- raise BizLogicError(
- f"Registered amount ({sym}{payload.amount/100:.2f}) is below agency minimum floor settlement price ({sym}{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
|