Pine
632 lines
31 KiB
Python
632 lines
31 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""充值业务服务：下单 / 回调到账 / 对账补单 / 幂等。
|
||
|
||
到账链路（与全平台算力统一口径一致）：
|
||
支付成功 → compute_engine users.quota 增加（1 元 = 1,000,000 微元）→ 平台镜像回写。
|
||
幂等三重保证：Redis SETNX 锁（30s）+ ``mark_paid`` 单向状态机 + 订单终态判定。
|
||
事务边界：引擎到账是跨服务 HTTP，无法与本地 DB 同事务 → 先本地置 paid 终态，
|
||
再引擎加款；引擎失败置 failed，由 status 对账接口补单（不重复加款）。
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import logging
|
||
import secrets
|
||
import time
|
||
from datetime import datetime, timedelta, timezone
|
||
|
||
from .. import config
|
||
from ..infrastructure.repositories import Database, utcnow_iso
|
||
from ..services import compute_client
|
||
from . import config as pay_config
|
||
from . import profitsharing, wxpay
|
||
from .repository import PaymentBindingRepository
|
||
|
||
logger = logging.getLogger("pay.service")
|
||
|
||
# 订单号前缀（回调按前缀分发，为未来其他支付业务留扩展位）
|
||
ORDER_PREFIX = "CR_" # 算力充值
|
||
ORDER_PREFIX_EVENT = "EV_" # 活动报名（课程/沙龙定价，见 event_service）
|
||
|
||
# 套餐缓存（60s：DB 配置优先，env 兜底）
|
||
_pkg_cache: tuple[float, list[dict]] | None = None
|
||
_PKG_TTL = 60.0
|
||
|
||
|
||
def _iso_in(seconds: int) -> str:
|
||
return datetime.fromtimestamp(
|
||
datetime.now(timezone.utc).timestamp() + seconds, tz=timezone.utc,
|
||
).isoformat()
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 套餐
|
||
# ---------------------------------------------------------------------------
|
||
def _normalize_packages(raw) -> list[dict]:
|
||
"""套餐数据清洗：[{id,amount(元),bonus(元),discount(%),enabled,label}]，金额全整数分口径。
|
||
|
||
- discount：充值折扣（默认 100=无折扣），实付 = amount * discount / 100
|
||
- enabled：false 时不下发（运营端可临时下架）
|
||
"""
|
||
items: list[dict] = []
|
||
if not isinstance(raw, list):
|
||
return items
|
||
for it in raw:
|
||
if isinstance(it, dict) and it.get("enabled") is False:
|
||
continue
|
||
try:
|
||
amount = int(round(float(it.get("amount", 0)) * 100))
|
||
bonus = int(round(float(it.get("bonus", 0) or 0) * 100))
|
||
discount = int(it.get("discount", 100) or 100)
|
||
except (TypeError, ValueError):
|
||
continue
|
||
if amount <= 0:
|
||
continue
|
||
discount = max(1, min(100, discount))
|
||
items.append({
|
||
"id": str(it.get("id") or f"p{amount}"),
|
||
"amount": amount, # 分（原价）
|
||
"bonus": bonus, # 分（赠送折算金额）
|
||
"discount": discount, # %（100=原价）
|
||
"pay_fen": amount * discount // 100, # 分（实付）
|
||
"label": str(it.get("label") or f"{amount // 100} 元"),
|
||
})
|
||
return items
|
||
|
||
|
||
async def packages(db: Database) -> dict:
|
||
"""充值套餐（system_configs.recharge_packages 优先，env 兜底，60s 缓存）+ 支付开关。"""
|
||
global _pkg_cache
|
||
now = time.monotonic()
|
||
items: list[dict] | None = None
|
||
if _pkg_cache and now - _pkg_cache[0] < _PKG_TTL:
|
||
items = _pkg_cache[1]
|
||
else:
|
||
try:
|
||
raw = await db.config.get("recharge_packages")
|
||
if raw:
|
||
items = _normalize_packages(json.loads(raw))
|
||
except (ValueError, TypeError): # noqa: PERF203
|
||
items = None
|
||
if not items:
|
||
try:
|
||
items = _normalize_packages(json.loads(pay_config.DEFAULT_PACKAGES_JSON))
|
||
except (ValueError, TypeError):
|
||
items = []
|
||
_pkg_cache = (now, items)
|
||
|
||
enabled = pay_config.pay_enabled()
|
||
return {
|
||
"enabled": enabled,
|
||
"items": [
|
||
{
|
||
"id": p["id"], "amount": p["amount"] // 100, "bonus": p["bonus"] // 100,
|
||
"discount": p["discount"], "pay": p["pay_fen"] // 100,
|
||
"label": p["label"],
|
||
"quota_micro": (p["pay_fen"] + p["bonus"]) // 100 * pay_config.QUOTA_PER_YUAN,
|
||
}
|
||
for p in items
|
||
] if enabled else [],
|
||
"min_yuan": pay_config.RECHARGE_MIN_YUAN,
|
||
"max_yuan": pay_config.RECHARGE_MAX_YUAN,
|
||
}
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 下单
|
||
# ---------------------------------------------------------------------------
|
||
async def create_order(db: Database, user: dict, *, client_type: str,
|
||
package_id: str = "", amount_yuan: float | None = None) -> dict:
|
||
"""创建充值订单。
|
||
|
||
client_type：
|
||
- "mp"（小程序支付，**统一入口**）：不在下单时调微信——桌面端展示小程序码，
|
||
微信扫码自动打开小程序「确认支付」页，由小程序侧按 openid 发起 JSAPI 支付
|
||
（与「小程序扫码登录」同构：桌面出码 → 小程序内确认/支付 → 桌面轮询状态）。
|
||
- "jsapi"（小程序内直充）：下单即返回 wx.requestPayment 参数。
|
||
- "native"（保留：桌面直接出微信收款码，需公众号 appid 绑定商户号）。
|
||
"""
|
||
if client_type not in ("mp", "native", "jsapi"):
|
||
raise ValueError("client_type 仅支持 mp/jsapi/native")
|
||
if not pay_config.pay_enabled():
|
||
raise RuntimeError("支付未配置，暂不可用")
|
||
|
||
# 1) 金额：套餐固定价，或自由金额（整数分口径）
|
||
plist = (await packages(db))["items"]
|
||
if package_id:
|
||
pkg = next((p for p in plist if p["id"] == package_id), None)
|
||
if pkg is None:
|
||
raise ValueError("套餐不存在或已下架")
|
||
# 实付按折扣计算（discount 100=原价）；packages() 返回的 amount/bonus 单位为元
|
||
amount_fen = pkg["amount"] * pkg["discount"] # 元 × % → 分
|
||
bonus_quota_micro = pkg["bonus"] * pay_config.QUOTA_PER_YUAN
|
||
else:
|
||
amount_fen = int(round(float(amount_yuan or 0) * 100))
|
||
bonus_quota_micro = 0
|
||
if amount_fen <= 0:
|
||
raise ValueError("金额必须大于 0")
|
||
min_fen = int(round(pay_config.RECHARGE_MIN_YUAN * 100))
|
||
max_fen = int(round(pay_config.RECHARGE_MAX_YUAN * 100))
|
||
if not (min_fen <= amount_fen <= max_fen):
|
||
raise ValueError(f"金额需在 {pay_config.RECHARGE_MIN_YUAN:g} ~ {pay_config.RECHARGE_MAX_YUAN:g} 元之间")
|
||
|
||
# 2) 复用未过期同金额 pending 单（防重复扫码）
|
||
now_iso = utcnow_iso()
|
||
dup = await db.compute_recharges.find_pending_same_amount(user["id"], amount_fen, now_iso)
|
||
if dup and dup.get("code_url"):
|
||
return _order_view(dup)
|
||
|
||
# 3) 引擎用户（幂等建号）并解析 engine_user_id
|
||
username = user.get("username", "")
|
||
await compute_client.ensure_user(username)
|
||
engine_user_id = await _resolve_engine_user_id(username)
|
||
|
||
# 4) 下单："mp" 只落库（支付由小程序扫码后发起）；native/jsapi 此处即调微信
|
||
order_no = f"{ORDER_PREFIX}{int(time.time())}_{secrets.token_hex(4).upper()}"
|
||
expires_at = _iso_in(pay_config.RECHARGE_EXPIRE_MINUTES * 60)
|
||
|
||
wx_result: dict = {}
|
||
if client_type != "mp":
|
||
try:
|
||
wx_result = await wxpay.create_order(
|
||
client_type=client_type, out_trade_no=order_no, total_fen=amount_fen,
|
||
description=f"算力充值 - {amount_fen // 100} 元", openid=user.get("wx_mini_openid", ""),
|
||
)
|
||
except RuntimeError as exc:
|
||
logger.error("充值下单失败 user=%s: %s", username, exc)
|
||
raise ValueError(f"微信下单失败：{exc}") from exc
|
||
|
||
order = await db.compute_recharges.create({
|
||
"order_no": order_no, "user_id": user["id"], "username": username,
|
||
"engine_user_id": engine_user_id, "package_id": package_id,
|
||
"amount_fen": amount_fen,
|
||
"quota_micro": amount_fen // 100 * pay_config.QUOTA_PER_YUAN,
|
||
"bonus_quota_micro": bonus_quota_micro,
|
||
"client_type": client_type, "appid": wx_result.get("appid", ""),
|
||
"prepay_id": wx_result.get("prepay_id", ""), "code_url": wx_result.get("code_url", ""),
|
||
"expires_at": expires_at,
|
||
})
|
||
view = _order_view(order)
|
||
if client_type == "jsapi":
|
||
view["pay_params"] = wx_result.get("pay_params") # wx.requestPayment 直接参数
|
||
if client_type == "mp":
|
||
# 小程序码：微信扫码自动打开小程序「确认支付」页并携带 scene=order_no
|
||
# （order_no 22 字符，满足 wxacode scene ≤32 限制）
|
||
from ..services import wechat
|
||
try:
|
||
png = await wechat.get_wxacode(order_no, page="pages-extra/pay/index")
|
||
import base64 as _b64
|
||
view["qr_image"] = f"data:image/png;base64,{_b64.b64encode(png).decode('ascii')}"
|
||
except wechat.WechatError as exc:
|
||
logger.error("生成小程序码失败 order=%s: %s", order_no, exc)
|
||
view["qr_image"] = ""
|
||
return view
|
||
|
||
|
||
async def build_pay_params(db: Database, user: dict, order_no: str) -> dict:
|
||
"""小程序扫码进入「确认支付」页：按当前小程序用户 openid 发起 JSAPI 下单，
|
||
返回订单摘要 + wx.requestPayment 参数。支持代付：任意登录用户均可支付，
|
||
余额到账到订单创建者（按订单 user_id）。"""
|
||
order = await db.compute_recharges.get_by_order_no(order_no)
|
||
if order is None:
|
||
raise ValueError("订单不存在")
|
||
if order["status"] != "pending":
|
||
return {"order": _order_view(order), "pay_params": None, "finished": True}
|
||
if order["expires_at"] and order["expires_at"] < utcnow_iso():
|
||
await db.compute_recharges.mark_status(order_no, "closed")
|
||
return {"order": await db.compute_recharges.get_by_order_no(order_no), "pay_params": None, "finished": True}
|
||
openid = user.get("wx_mini_openid", "")
|
||
if not openid:
|
||
raise ValueError("当前账号未绑定小程序微信身份，请先用微信登录小程序")
|
||
try:
|
||
result = await wxpay.create_order(
|
||
client_type="jsapi", out_trade_no=order_no, total_fen=int(order["amount_fen"]),
|
||
description=f"算力充值 - {int(order['amount_fen']) // 100} 元", openid=openid,
|
||
)
|
||
except RuntimeError as exc:
|
||
logger.error("小程序拉起支付失败 order=%s: %s", order_no, exc)
|
||
raise ValueError(f"微信下单失败：{exc}") from exc
|
||
# 记录 prepay/appid（不改变 pending 状态）
|
||
await db.compute_recharges.set_prepay(order_no, result.get("appid", ""), result.get("prepay_id", ""))
|
||
return {
|
||
"order": _order_view(order),
|
||
"pay_params": result.get("pay_params"),
|
||
"finished": False,
|
||
}
|
||
|
||
|
||
def _order_view(order: dict) -> dict:
|
||
"""对外的订单视图（不含内部载荷）。"""
|
||
return {
|
||
"order_no": order["order_no"], "amount_fen": order["amount_fen"],
|
||
"quota_micro": order["quota_micro"], "bonus_quota_micro": order["bonus_quota_micro"],
|
||
"status": order["status"], "code_url": order["code_url"],
|
||
"prepay_id": order.get("prepay_id", ""), "expires_at": order["expires_at"],
|
||
"created_at": order["created_at"], "paid_at": order.get("paid_at", ""),
|
||
}
|
||
|
||
|
||
async def _resolve_engine_user_id(username: str) -> int:
|
||
"""按用户名在引擎侧解析用户 id（失败返回 0，到账时再试）。"""
|
||
try:
|
||
for page in (1, 2):
|
||
for it in await compute_client.list_engine_users(page=page, page_size=100):
|
||
if str(it.get("username") or "") == username:
|
||
return int(it.get("id") or 0)
|
||
except Exception as exc: # noqa: BLE001
|
||
logger.warning("解析引擎用户 id 失败 %s: %s", username, exc)
|
||
return 0
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 回调 / 到账
|
||
# ---------------------------------------------------------------------------
|
||
async def handle_notify(db: Database, result: dict) -> bool:
|
||
"""微信回调分发：CR_=充值到账，EV_=活动报名确认，MK_=市场购买；未知前缀忽略。"""
|
||
out_trade_no = result.get("out_trade_no", "")
|
||
if out_trade_no.startswith(ORDER_PREFIX):
|
||
return await process_paid_order(db, out_trade_no, result)
|
||
if out_trade_no.startswith(ORDER_PREFIX_EVENT):
|
||
from .event_service import process_paid_event_order
|
||
return await process_paid_event_order(db, out_trade_no, result)
|
||
if out_trade_no.startswith("MK_"):
|
||
from ..market import service as market_service
|
||
return await market_service.handle_notify(db, out_trade_no, result)
|
||
logger.warning("未知订单类型回调: %s", out_trade_no)
|
||
return True
|
||
|
||
|
||
async def process_paid_order(db: Database, order_no: str, wechat_data: dict) -> bool:
|
||
"""支付成功 → 引擎加款（幂等）。返回 False = 处理失败（触发微信重试）。"""
|
||
order = await db.compute_recharges.get_by_order_no(order_no)
|
||
if order is None:
|
||
logger.warning("充值订单不存在: %s", order_no)
|
||
return True
|
||
if order["status"] in ("paid", "credited"):
|
||
return True # 已处理（回调重放/并发），幂等成功
|
||
|
||
# 幂等排他：仅 pending → paid 成功者继续到账
|
||
payload_json = json.dumps(wechat_data, ensure_ascii=False)[:8000]
|
||
got = await db.compute_recharges.mark_paid(order_no, wechat_data.get("transaction_id", ""), payload_json)
|
||
if not got:
|
||
return True
|
||
|
||
total_micro = int(order["quota_micro"]) + int(order["bonus_quota_micro"])
|
||
try:
|
||
engine_user_id = int(order["engine_user_id"] or 0)
|
||
if not engine_user_id:
|
||
engine_user_id = await _resolve_engine_user_id(order["username"])
|
||
if not engine_user_id:
|
||
raise RuntimeError(f"引擎用户未解析: {order['username']}")
|
||
await compute_client.adjust_user_quota(engine_user_id, total_micro, "add")
|
||
except Exception as exc: # noqa: BLE001
|
||
logger.error("充值到账失败 order=%s: %s", order_no, exc, exc_info=True)
|
||
await db.compute_recharges.mark_status(order_no, "failed")
|
||
await db.audit.add(action="compute.recharge_failed", resource="compute_recharge_order",
|
||
resource_id=order_no, detail=f"{total_micro} micro: {exc}",
|
||
user_id=order["user_id"])
|
||
return False
|
||
|
||
await db.compute_recharges.mark_credited(order_no)
|
||
await compute_client.sync_user_mirror(db, engine_user_id) # best-effort 镜像回写
|
||
await db.audit.add(action="compute.recharge_credited", resource="compute_recharge_order",
|
||
resource_id=order_no, detail=f"{total_micro} micro, engine_user={engine_user_id}",
|
||
user_id=order["user_id"])
|
||
logger.info("充值到账成功 order=%s user=%s micro=%s", order_no, order["username"], total_micro)
|
||
return True
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 对账 / 过期
|
||
# ---------------------------------------------------------------------------
|
||
async def reconcile(db: Database, order: dict) -> dict:
|
||
"""pending 单对账：查微信侧状态，已支付则补单；超时未付置 closed。"""
|
||
if order["status"] != "pending":
|
||
return order
|
||
if order["expires_at"] and order["expires_at"] < utcnow_iso():
|
||
await db.compute_recharges.mark_status(order["order_no"], "closed")
|
||
return await db.compute_recharges.get_by_order_no(order["order_no"]) or order
|
||
data = await wxpay.query_order(order["order_no"])
|
||
state = (data or {}).get("trade_state", "")
|
||
if state == "SUCCESS":
|
||
if not await process_paid_order(db, order["order_no"], data):
|
||
logger.error("对账补单失败 order=%s", order["order_no"])
|
||
elif state in ("CLOSED", "PAY_ERROR", "REVOKED"):
|
||
await db.compute_recharges.mark_status(order["order_no"], "closed")
|
||
return await db.compute_recharges.get_by_order_no(order["order_no"]) or order
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 分账结果回调（微信服务商分账）
|
||
# ---------------------------------------------------------------------------
|
||
async def handle_profitsharing_notify(db: Database, result: dict) -> bool:
|
||
"""分账回调分发 → 结算服务确认 escrow released（幂等）。"""
|
||
from ..services.settlement_service import SettlementService
|
||
return await SettlementService(db).handle_split_notify(result)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# OPC 收款绑定（个人 openid / 商户子商户号 双路径）
|
||
# ---------------------------------------------------------------------------
|
||
def _bindings(db: Database) -> PaymentBindingRepository:
|
||
return PaymentBindingRepository(db.session)
|
||
|
||
|
||
async def bind_personal(db: Database, user: dict, real_name: str = "") -> dict:
|
||
"""个人绑定：把 OPC 小程序 openid 添加为 PERSONAL_OPENID 分账接收方。
|
||
|
||
前置：用户已用小程序微信登录（users.wx_mini_openid 已存）。
|
||
"""
|
||
openid = user.get("wx_mini_openid", "")
|
||
if not openid:
|
||
raise ValueError("当前账号未绑定小程序微信身份，请先用微信登录小程序")
|
||
if not pay_config.profitsharing_enabled():
|
||
raise RuntimeError("服务商分账未配置，暂不可绑定")
|
||
name = real_name or user.get("nickname", "")
|
||
# 服务商分账添加个人接收方需要"出资特约商户号"；优先取该用户已进件的商户绑定
|
||
rows = await _bindings(db).list_by_user(user["id"])
|
||
payer_sub_mchid = next((b.get("sub_mchid") for b in rows
|
||
if b.get("bind_type") == "merchant" and b.get("sub_mchid")), "")
|
||
try:
|
||
await profitsharing.add_receiver(
|
||
account_type="PERSONAL_OPENID", account=openid, name=name,
|
||
sub_mchid=payer_sub_mchid,
|
||
)
|
||
except RuntimeError as exc:
|
||
raise ValueError(f"微信添加分账接收方失败：{exc}") from exc
|
||
|
||
repo = _bindings(db)
|
||
existing = await repo.get_active(user["id"], "personal")
|
||
if existing is not None:
|
||
return await repo.update(existing["id"], {"real_name": name, "status": "active"})
|
||
return await repo.create({
|
||
"user_id": user["id"], "bind_type": "personal",
|
||
"openid": openid, "real_name": name, "status": "active",
|
||
})
|
||
|
||
|
||
async def bind_merchant(db: Database, user: dict, sub_mchid: str = "",
|
||
applyment_id: str = "") -> dict:
|
||
"""商户绑定：记录特约商户进件（子商户号）并把 sub_mchid 添加为 MERCHANT_ID 接收方。
|
||
|
||
- 进件为异步微信审核：有 applyment_id 时记录 applying，子商户号回填后置 active；
|
||
- 有 sub_mchid 时直接调微信添加接收方并置 active。
|
||
"""
|
||
if not sub_mchid and not applyment_id:
|
||
raise ValueError("sub_mchid 或 applyment_id 至少提供一个")
|
||
repo = _bindings(db)
|
||
binding = await repo.create({
|
||
"user_id": user["id"], "bind_type": "merchant",
|
||
"sub_mchid": sub_mchid, "applyment_id": applyment_id,
|
||
"status": "active" if sub_mchid else "applying",
|
||
})
|
||
if sub_mchid and pay_config.profitsharing_enabled():
|
||
try:
|
||
# 出资方=OPC 自己的特约商户号（与 release_escrow 分账模型一致：资金冻结在 OPC 账户）
|
||
await profitsharing.add_receiver(
|
||
account_type="MERCHANT_ID", account=sub_mchid, sub_mchid=sub_mchid,
|
||
)
|
||
except RuntimeError as exc:
|
||
# 接收方添加失败不影响进件记录；置 failed 待人工处理
|
||
return await repo.set_status(binding["id"], "failed",
|
||
detail=str(exc)[:300])
|
||
return binding
|
||
|
||
|
||
async def update_merchant_applyment(db: Database, user_id: str, applyment_id: str,
|
||
sub_mchid: str) -> dict | None:
|
||
"""进件审核通过后回填子商户号并激活（运营/回调调用）。"""
|
||
repo = _bindings(db)
|
||
rows = await repo.list_by_user(user_id)
|
||
b = next((x for x in rows if x["applyment_id"] == applyment_id), None)
|
||
if b is None:
|
||
return None
|
||
return await repo.update(b["id"], {"sub_mchid": sub_mchid, "status": "active"})
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 特约商户进件（主动进件路径：平台代提交 → 微信审核 → OPC 扫码签约 → 回填激活）
|
||
# ---------------------------------------------------------------------------
|
||
def _already_merchant_applyment(bindings: list[dict]) -> dict | None:
|
||
"""已有进行中（applying/active）的商户绑定则返回，避免重复进件。"""
|
||
return next((b for b in bindings if b["bind_type"] == "merchant"
|
||
and b["status"] in ("applying", "active")), None)
|
||
|
||
|
||
async def create_merchant_applyment(db: Database, user: dict, *, contact_info: dict,
|
||
subject_info: dict, business_info: dict,
|
||
settlement_info: dict, bank_account_info: dict,
|
||
addition_info: dict | None = None) -> dict:
|
||
"""发起特约商户进件（平台以服务商身份代提交）。
|
||
|
||
- 幂等：该 OPC 已有 applying/active 的商户绑定 → 直接返回已有，不重复进件；
|
||
- 敏感资料仅透传微信（wechatpayv3 内部加密），平台只落 applyment_id / status；
|
||
- 返回 {applyment_id, applyment_state, binding}。
|
||
"""
|
||
if not pay_config.profitsharing_enabled():
|
||
raise RuntimeError("服务商分账未配置，暂不可进件")
|
||
repo = _bindings(db)
|
||
rows = await repo.list_by_user(user["id"])
|
||
existing = _already_merchant_applyment(rows)
|
||
if existing is not None:
|
||
return {"applyment_id": existing["applyment_id"], "applyment_state": "EXISTING",
|
||
"binding": existing}
|
||
|
||
# 补充超级管理员 openid（小程序身份；用于进件后微信端签约激活）
|
||
if contact_info.get("openid") in (None, ""):
|
||
openid = user.get("wx_mini_openid", "")
|
||
if openid:
|
||
contact_info = {**contact_info, "openid": openid}
|
||
|
||
business_code = f"AP{int(time.time())}_{secrets.token_hex(4).upper()}"
|
||
try:
|
||
wx = await profitsharing.submit_applyment(
|
||
business_code=business_code, contact_info=contact_info,
|
||
subject_info=subject_info, business_info=business_info,
|
||
settlement_info=settlement_info, bank_account_info=bank_account_info,
|
||
addition_info=addition_info,
|
||
)
|
||
except RuntimeError as exc:
|
||
raise ValueError(f"微信进件提交失败：{exc}") from exc
|
||
|
||
applyment_id = str(wx.get("applyment_id") or "")
|
||
# 提交接口一般只返回 applyment_id；若返回 state 则规范化（去掉 APPLYMENT_STATE_ 前缀）
|
||
state = profitsharing.normalize_applyment_state(wx.get("applyment_state") or "") or "AUDITING"
|
||
if not applyment_id:
|
||
raise ValueError("微信未返回进件申请单号，请稍后重试")
|
||
# 进件提交阶段微信即可能返回 sign_url（超管扫码完成验证+签约的入口）
|
||
sign_url = str(wx.get("sign_url") or "")
|
||
binding = await repo.create({
|
||
"user_id": user["id"], "bind_type": "merchant",
|
||
"applyment_id": applyment_id, "status": "applying",
|
||
"applyment_state": state, "sign_url": sign_url,
|
||
"audit_detail_json": json.dumps({"applyment_state_msg": str(
|
||
wx.get("applyment_state_msg") or "")}, ensure_ascii=False),
|
||
})
|
||
logger.info("发起特约商户进件 user=%s applyment_id=%s state=%s",
|
||
user["id"], applyment_id, state)
|
||
return {"applyment_id": applyment_id, "applyment_state": state,
|
||
"sign_url": sign_url, "binding": binding}
|
||
|
||
|
||
async def query_merchant_applyment(db: Database, user: dict, binding_id: str) -> dict:
|
||
"""查询进件状态；按微信 applyment_state 全量映射并落库。
|
||
|
||
- FINISHED → 回填 sub_mchid，调微信添加 MERCHANT_ID 接收方 → active；
|
||
- TO_BE_SIGNED → 已出 sub_mchid，待超管扫码签约 → 回填 sub_mchid + sign_url（不激活）；
|
||
- TO_BE_CONFIRMED / SIGNING → 落库 sign_url / account_validation，前端展示扫码引导；
|
||
- REJECTED → 置 rejected（落库 audit_detail 驳回原因）；
|
||
- EDITTING / AUDITING / CANCELED → 状态如实返回。
|
||
"""
|
||
repo = _bindings(db)
|
||
b = await repo.get(binding_id)
|
||
if b is None or b["user_id"] != user["id"]:
|
||
raise ValueError("绑定不存在")
|
||
if b["status"] == "active" and b.get("sub_mchid"):
|
||
return {"applyment_id": b["applyment_id"], "applyment_state": "FINISHED",
|
||
"sub_mchid": b["sub_mchid"], "binding": b}
|
||
applyment_id = b.get("applyment_id") or ""
|
||
if not applyment_id:
|
||
return {"applyment_state": "NO_APPLYMENT", "binding": b}
|
||
if not pay_config.profitsharing_enabled():
|
||
return {"applyment_state": "NOT_CONFIGURED", "binding": b}
|
||
|
||
data = await profitsharing.query_applyment(applyment_id=applyment_id)
|
||
if data is None:
|
||
raise RuntimeError("查询进件状态失败，请稍后重试")
|
||
state = data.get("applyment_state") or ""
|
||
sub_mchid = str(data.get("sub_mchid") or "")
|
||
sign_url = str(data.get("sign_url") or "")
|
||
account_validation = data.get("account_validation")
|
||
audit_detail = data.get("audit_detail")
|
||
state_msg = data.get("applyment_state_msg") or ""
|
||
audit_json = {}
|
||
if audit_detail is not None:
|
||
audit_json["audit_detail"] = audit_detail
|
||
if state_msg:
|
||
audit_json["applyment_state_msg"] = state_msg
|
||
valid_json = json.dumps(account_validation or {}, ensure_ascii=False)
|
||
audit_json_str = json.dumps(audit_json, ensure_ascii=False) if audit_json else "{}"
|
||
|
||
def _persist(extra: dict) -> dict:
|
||
fields = {"applyment_state": state, "account_validation_json": valid_json,
|
||
"audit_detail_json": audit_json_str}
|
||
if sign_url:
|
||
fields["sign_url"] = sign_url
|
||
if sub_mchid:
|
||
fields["sub_mchid"] = sub_mchid
|
||
fields.update(extra)
|
||
return repo.update(binding_id, fields)
|
||
|
||
if state == "FINISHED":
|
||
if not sub_mchid:
|
||
raise RuntimeError("进件已通过但未返回子商户号，请稍后重试")
|
||
try:
|
||
# 出资方=OPC 自己的特约商户号；微信允许出资商户作为自身接收方（分账回留/解冻模型）
|
||
await profitsharing.add_receiver(
|
||
account_type="MERCHANT_ID", account=sub_mchid, sub_mchid=sub_mchid,
|
||
)
|
||
b = await _persist({"status": "active", "detail": "进件通过，已添加分账接收方"})
|
||
except RuntimeError as exc:
|
||
msg = str(exc)
|
||
if any(k in msg for k in ("已存在", "EXIST", "RECEIVER", "already")):
|
||
b = await _persist({"status": "active", "detail": "进件通过，接收方已存在"})
|
||
else:
|
||
b = await _persist({"status": "failed", "detail": f"添加接收方失败：{msg[:200]}"})
|
||
logger.info("进件完成回填 user=%s applyment_id=%s sub_mchid=%s state=%s",
|
||
user["id"], applyment_id, sub_mchid, b["status"])
|
||
return {"applyment_id": applyment_id, "applyment_state": state,
|
||
"sub_mchid": sub_mchid, "sign_url": sign_url, "binding": b}
|
||
|
||
if state == "TO_BE_SIGNED":
|
||
# 已下发子商户号，待超管扫码完成签约授权（账户验证 + 签约一体）
|
||
b = await _persist({"status": "applying",
|
||
"detail": state_msg or "待超管扫码完成签约授权（含账户验证）"})
|
||
return {"applyment_id": applyment_id, "applyment_state": state,
|
||
"sub_mchid": sub_mchid, "sign_url": sign_url,
|
||
"account_validation": account_validation, "binding": b}
|
||
|
||
if state in profitsharing.APPLYMENT_ACTION_STATES:
|
||
# TO_BE_CONFIRMED（待账户验证）/ SIGNING（开通权限中）：落库 sign_url 供前端扫码引导
|
||
b = await _persist({"status": "applying", "detail": state_msg or
|
||
profitsharing.APPLYMENT_STATE.get(state, state)})
|
||
return {"applyment_id": applyment_id, "applyment_state": state,
|
||
"sign_url": sign_url, "account_validation": account_validation, "binding": b}
|
||
|
||
if state == "REJECTED":
|
||
reason = ""
|
||
if isinstance(audit_detail, dict):
|
||
reasons = audit_detail.get("reject_reason") or []
|
||
reason = "；".join(str(r) for r in reasons) if reasons else ""
|
||
reason = reason or state_msg or str(audit_detail or "")[:300]
|
||
b = await _persist({"status": "rejected", "detail": reason or "进件被驳回"})
|
||
return {"applyment_id": applyment_id, "applyment_state": state,
|
||
"audit_detail": audit_detail, "binding": b}
|
||
# EDITTING / AUDITING / CANCELED 等：状态如实返回
|
||
b = await _persist({})
|
||
return {"applyment_id": applyment_id, "applyment_state": state,
|
||
"sign_url": sign_url, "binding": b}
|
||
|
||
|
||
async def query_split_permission(db: Database, user: dict, binding_id: str) -> dict:
|
||
"""查询子商户分账授权最大比例（/v3/profitsharing/merchant-configs）。
|
||
|
||
分账授权需子商户在【商户平台 > 产品中心 > 分账】开通分账并设置允许服务商分账的最大比例
|
||
（默认上限 30%，接口无独立开关字段，以能否查到 max_ratio 为准）。
|
||
本接口查询微信侧真实配置回填 payment_bindings.split_max_ratio（万分比），供运营/OPC 确认分账可用性。
|
||
"""
|
||
repo = _bindings(db)
|
||
b = await repo.get(binding_id)
|
||
if b is None or b["user_id"] != user["id"]:
|
||
raise ValueError("绑定不存在")
|
||
if b["bind_type"] != "merchant" or not b.get("sub_mchid"):
|
||
raise ValueError("仅已下放子商户号的商户绑定可查询分账授权")
|
||
cfg = await profitsharing.query_split_config(sub_mchid=b["sub_mchid"])
|
||
if cfg is None:
|
||
# 接口返回非 200（如 403 NO_AUTH）→ 子商户未开通分账或服务商未开通分账权限
|
||
raise RuntimeError("子商户尚未开通分账授权：请子商户在微信商户平台【产品中心>分账】开通，"
|
||
"并设置允许服务商分账的最大比例；同时确认服务商已开通分账权限")
|
||
max_ratio_bp = int(cfg.get("max_ratio") or 0) # 万分比（2000=20%）
|
||
max_ratio_pct = float(cfg.get("max_ratio_percent") or 0) # 百分比
|
||
b = await repo.update(binding_id, {
|
||
"split_allowed": "OPEN" if max_ratio_bp > 0 else "CLOSED",
|
||
"split_max_ratio": max_ratio_bp,
|
||
})
|
||
return {"sub_mchid": b["sub_mchid"], "split_allowed": b["split_allowed"],
|
||
"split_max_ratio": max_ratio_bp, "split_max_ratio_percent": max_ratio_pct,
|
||
"binding": b}
|
||
|
||
|
||
async def list_bindings(db: Database, user: dict) -> list[dict]:
|
||
"""我的收款绑定列表。"""
|
||
return await _bindings(db).list_by_user(user["id"])
|
||
|
||
|
||
async def disable_binding(db: Database, user: dict, binding_id: str) -> dict:
|
||
"""停用绑定（结清后可停用，避免误分账）。"""
|
||
repo = _bindings(db)
|
||
b = await repo.get(binding_id)
|
||
if b is None or b["user_id"] != user["id"]:
|
||
raise ValueError("绑定不存在")
|
||
return await repo.set_status(binding_id, "disabled")
|