# -*- coding: utf-8 -*- """业务层 · 结算/合同/争议/撮合服务。 资金相关规则（佣金、结算、争议联动）在业务层集中，接口层瘦身。 结算（release_escrow）· 验收通过后： 1) 优先走「微信服务商分账」（资金托管）： 接单者 active 收款绑定 + 订单 transaction_id + 服务商配置齐备 → 分账 95% 给接单者 / 5% 佣金给平台服务商商户号 → 等分账回调确认后置 released 2) 降级（未接微信收单 / 无绑定 / 分账未配置）： 仅台账置 released（channel=manual），不阻塞业务，供后续对账补齐。 """ from __future__ import annotations import json import logging import secrets import time from fastapi import HTTPException from ..infrastructure.repositories import Database from ..pay import config as pay_config from ..pay import profitsharing from ..pay.repository import PaymentBindingRepository, SettlementLogRepository # 平台佣金比例 COMMISSION_RATE = 0.05 logger = logging.getLogger("services.settlement") class SettlementService: """结算托管、电子合同、争议、投资撮合。""" def __init__(self, db: Database): self.db = db async def release_escrow(self, task_id: str, *, transaction_id: str = "", payer_sub_mchid: str = "") -> dict: """验收通过后结算：优先微信服务商分账（资金冻结→分账→解冻剩余），不满足条件降级台账结算。 完整资金生命周期（微信服务商分账，出资方=接单者特约商户）： 1. 冻结：订单带 profit_sharing=true 支付成功后资金冻结在出资子商户不可用余额； 业务侧 escrow 置 frozen + 记录 transaction_id / payer_sub_mchid； 2. 查询剩余待分金额（确认可分金额）； 3. 分账：平台佣金 5% 分给服务商商户号（部分分账 unfreeze_unsplit=False）； 4. 查询分账结果（state=FINISHED 且 receivers.result=SUCCESS）； 5. 解冻剩余：调分账完结接口把剩余 95% 解冻回出资方（接单者）账户 → escrow released。 """ task = await self.db.tasks.get(task_id) if task is None or task["status"] != "completed": raise HTTPException(status_code=400, detail="任务未完成，不能结算") escrows = await self.db.escrows.list() esc = next((e for e in escrows if e["task_id"] == task_id), None) if esc is None: amount = max(task.get("budget_min", 0), task.get("budget_max", 0)) commission = int(amount * COMMISSION_RATE) esc = await self.db.escrows.create(task_id, task["title"], amount, commission) # 冻结确认：外部传入微信交易单号 + 出资商户号 → 记录并置 frozen if transaction_id: esc = await self.db.escrows.update_fields(esc["id"], { "channel": "wx_split", "transaction_id": transaction_id, "payer_sub_mchid": payer_sub_mchid, "share_status": "pending", }) if esc["status"] in ("deposited", "released"): esc = await self.db.escrows.set_status(esc["id"], "frozen") await self._log(esc, "wx_split", "托管资金已冻结（微信支付分账冻结）", "initiated", f"tx={transaction_id} payer={payer_sub_mchid}") logger.info("托管资金冻结确认 task=%s tx=%s payer=%s", task_id, transaction_id, payer_sub_mchid) tx_id = esc.get("transaction_id") or "" if not tx_id or not pay_config.profitsharing_enabled(): # 降级：未接微信收单 / 服务商分账未配置 → 台账结算 return await self._manual_release(esc, "未接入微信收单或分账未配置，台账结算", f"no_transaction_id={not tx_id}") receiver, reason = await self._resolve_receiver(task) if receiver is None: return await self._manual_release(esc, "接单者无收款绑定，台账结算", reason) if not (receiver.get("sub_mchid") or ""): return await self._manual_release(esc, "接单者绑定无出资商户号(sub_mchid)，台账结算", f"binding={receiver.get('id')}") return await self._split_lifecycle(esc, receiver) async def _manual_release(self, esc: dict, note: str, detail: str = "") -> dict: """降级台账结算（不碰真金，供对账补齐）。""" esc = await self.db.escrows.update_fields( esc["id"], {"channel": "manual", "share_status": "manual"}) esc = await self.db.escrows.set_status(esc["id"], "released") await self._log(esc, "manual", note, "shared", detail) return esc async def _split_lifecycle(self, esc: dict, receiver: dict) -> dict: """微信服务商分账完整生命周期：剩余待分确认 → 分账 → 结果确认 → 解冻剩余。""" sub_mchid = receiver.get("sub_mchid") or "" tx_id = esc.get("transaction_id") or "" if not tx_id or not sub_mchid: return await self._manual_release(esc, "分账前置缺失（transaction_id/sub_mchid）", f"tx={tx_id} sub_mchid={sub_mchid}") # ── 1) 查询剩余待分金额（确认冻结资金）── remaining = await profitsharing.query_remaining_amount(transaction_id=tx_id) if remaining is None: return await self._manual_release(esc, "查询剩余待分金额失败，台账结算", "amount_query_failed") unsplit_fen = int(remaining.get("unsplit_amount") or 0) total_fen = int(esc["amount"]) * 100 if unsplit_fen <= 0: return await self._manual_release(esc, "订单无可分金额（可能已分账/已解冻）", f"unsplit={unsplit_fen}") # 以微信侧实际可分金额为准（防超分），但不超过台账总额 usable_fen = min(unsplit_fen, total_fen) commission_fen = min(int(esc["commission"]) * 100, usable_fen) opc_remain_fen = usable_fen - commission_fen # ── 2) 发起分账：平台佣金 5% 分给服务商商户号（部分分账，剩余保留待解冻）── share_no = f"PS_{int(time.time())}_{secrets.token_hex(4).upper()}" split_receivers = [ { "type": "MERCHANT_ID", "account": pay_config.WECHATPAY_SP_MCHID, "amount": max(commission_fen, 0), "description": "平台服务费(分账)", }, ] try: await profitsharing.create_split( transaction_id=tx_id, out_order_no=share_no, receivers=split_receivers, sub_mchid=sub_mchid, unfreeze_unsplit=False, ) except RuntimeError as exc: esc = await self.db.escrows.update_fields(esc["id"], { "channel": "wx_split", "share_order_no": share_no, "share_status": "failed", "receiver_binding_id": receiver["id"], "split_detail": json.dumps({"step": "split_request", "error": str(exc)[:300]}, ensure_ascii=False), }) await self._log(esc, "wx_split", "分账发起失败", "failed", str(exc)[:300], split_receivers) raise HTTPException(status_code=502, detail=f"分账发起失败：{exc}") from exc esc = await self.db.escrows.update_fields(esc["id"], { "channel": "wx_split", "share_order_no": share_no, "share_status": "sharing", "receiver_binding_id": receiver["id"], "split_detail": json.dumps({ "step": "split_initiated", "unsplit_fen": unsplit_fen, "commission_fen": commission_fen, "opc_remain_fen": opc_remain_fen, }, ensure_ascii=False), }) await self._log(esc, "wx_split", "分账已发起（平台佣金5%），等待结果", "initiated", f"share={share_no}", split_receivers) # ── 3) 查询分账结果（微信异步：PROCESSING → FINISHED）── split_result = await profitsharing.query_split( transaction_id=tx_id, out_order_no=share_no, sub_mchid=sub_mchid) ok, fail_reason = profitsharing.split_finished(split_result) if split_result else (False, "无分账结果") if not ok: # PROCESSING：等微信回调（handle_split_notify）或后续轮询；不置终态 logger.info("分账处理中/未确认 task=%s share=%s reason=%s", esc["task_id"], share_no, fail_reason) return esc # ── 4) 分账成功 → 解冻剩余资金回出资方（接单者），完结分账 ── unfreeze_no = f"UF_{int(time.time())}_{secrets.token_hex(4).upper()}" try: await profitsharing.unfreeze_remaining( transaction_id=tx_id, out_order_no=unfreeze_no, sub_mchid=sub_mchid, description="任务验收通过，解冻剩余资金", ) except RuntimeError as exc: esc = await self.db.escrows.update_fields(esc["id"], { "share_status": "failed", "split_detail": json.dumps({"step": "unfreeze", "error": str(exc)[:300]}, ensure_ascii=False), }) await self._log(esc, "wx_split", "分账成功但解冻剩余失败", "failed", str(exc)[:300]) raise HTTPException(status_code=502, detail=f"解冻剩余资金失败：{exc}") from exc esc = await self.db.escrows.update_fields(esc["id"], { "share_status": "shared", "split_detail": json.dumps({ "step": "completed", "share_no": share_no, "unfreeze_no": unfreeze_no, "commission_fen": commission_fen, "opc_remain_fen": opc_remain_fen, "wx_split_result": split_result.get("order_id", ""), }, ensure_ascii=False), }) esc = await self.db.escrows.set_status(esc["id"], "released") await self._log(esc, "wx_split", "分账完成+解冻剩余，资金已结算", "shared", f"share={share_no} unfreeze={unfreeze_no}", split_receivers) logger.info("分账生命周期完成 task=%s share=%s unfreeze=%s", esc["task_id"], share_no, unfreeze_no) return esc async def query_split_lifecycle(self, task_id: str) -> dict: """查询任务分账生命周期状态（供前端/轮询展示：冻结→分账→解冻）。""" escrows = await self.db.escrows.list() esc = next((e for e in escrows if e["task_id"] == task_id), None) if esc is None: return {"exists": False} detail = {} try: detail = json.loads(esc.get("split_detail") or "{}") except (ValueError, TypeError): detail = {} out = {"exists": True, "escrow_id": esc["id"], "task_id": task_id, "amount": esc["amount"], "commission": esc["commission"], "status": esc["status"], "channel": esc["channel"], "transaction_id": esc.get("transaction_id", ""), "payer_sub_mchid": esc.get("payer_sub_mchid", ""), "share_order_no": esc.get("share_order_no", ""), "share_status": esc.get("share_status", ""), "split_detail": detail} # 分账处理中时主动查询微信侧最新结果（供轮询收敛） if esc["status"] == "frozen" and esc.get("share_order_no") and esc.get("transaction_id"): wx = await profitsharing.query_split( transaction_id=esc["transaction_id"], out_order_no=esc["share_order_no"], sub_mchid=esc.get("payer_sub_mchid", ""), ) if wx: ok, reason = profitsharing.split_finished(wx) out["wx_split_state"] = wx.get("state", "") out["wx_split_finished"] = ok out["wx_split_reason"] = reason out["wx_split_receivers"] = wx.get("receivers", []) return out async def handle_split_notify(self, result: dict) -> bool: """分账结果回调：微信确认分账成功 → escrow released + 流水 shared（幂等）。""" share_no = result.get("out_order_no", "") if not share_no: logger.warning("分账回调缺少 out_order_no") return True repo = SettlementLogRepository(self.db.session) log = await repo.get_by_share_order_no(share_no) if log is None: logger.warning("分账回调无对应流水: %s", share_no) return True if log["status"] == "shared": return True # 已确认（回调重放） esc = await self.db.escrows.get(log["escrow_id"]) if esc is not None: await self.db.escrows.update_fields(esc["id"], {"share_status": "shared"}) await self.db.escrows.set_status(esc["id"], "released") await repo.set_status(log["id"], "shared", "微信分账回调确认") await self.db.audit.add(action="escrow.released_wx", resource="escrow", resource_id=log["escrow_id"], detail=f"share={share_no}", user_id="") logger.info("分账回调确认 share=%s escrow=%s", share_no, log["escrow_id"]) return True async def _resolve_receiver(self, task: dict) -> tuple[dict | None, str]: """接单者（claimed_by）的可用收款绑定；无则返回 (None, 原因)。""" claimer = task.get("claimed_by") if not claimer: return None, "任务无接单者(claimed_by 为空)" repo = PaymentBindingRepository(self.db.session) binding = await repo.get_active(claimer) if binding is None: return None, f"接单者无 active 收款绑定(user={claimer})" return binding, "" async def _log(self, esc: dict, channel: str, note: str, status: str, detail: str = "", receivers_json: list | None = None) -> dict: """写分账流水镜像（金额统一为分，与微信口径一致）。""" repo = SettlementLogRepository(self.db.session) return await repo.create({ "escrow_id": esc.get("id", ""), "task_id": esc.get("task_id", ""), "share_order_no": esc.get("share_order_no", ""), "channel": channel, "amount": int(esc.get("amount", 0)) * 100, "commission": int(esc.get("commission", 0)) * 100, "receivers_json": json.dumps(receivers_json or [], ensure_ascii=False), "status": status, "detail": detail or note, }) async def sign_contract(self, task_id: str, actor: dict, opc_id: str | None = None) -> dict: """签订电子合同（幂等：已签返回现有合同）。""" task = await self.db.tasks.get(task_id) if task is None: raise HTTPException(status_code=404, detail="Task not found") existing = await self.db.contracts.get_for_task(task_id) if existing is not None: return existing resolved_opc = opc_id or (actor["id"] if actor.get("role") == "opc_member" else "") return await self.db.contracts.create(task_id, task["title"], actor["id"], resolved_opc) async def create_dispute(self, task_id: str, actor: dict, reason: str) -> dict: """发起争议并联动任务置为 disputed。""" task = await self.db.tasks.get(task_id) if task is None: raise HTTPException(status_code=404, detail="Task not found") dispute = await self.db.disputes.create(task_id, task["title"], actor["id"], reason) await self.db.tasks.set_status(task_id, "disputed") return dispute async def resolve_dispute(self, dispute_id: str) -> dict: dispute = await self.db.disputes.set_status(dispute_id, "resolved", resolution="平台调解结案") if dispute is None: raise HTTPException(status_code=404, detail="Dispute not found") return dispute async def investor_matches(self, user_id: str) -> dict: """投资撮合：按投资人偏好（行业/阶段关键词）打分排序。""" pref = await self.db.investor_prefs.get(user_id) or {} industries = set(pref.get("industries") or []) data = await self.db.portal_pages.get("investor", "projects") or {"items": []} scored = [] for it in data.get("items", []): text = f"{it.get('title', '')} {it.get('meta', '')}" score = sum(10 for ind in industries if ind and ind in text) if pref.get("stage") and pref["stage"] in text: score += 5 scored.append((score, it)) scored.sort(key=lambda x: x[0], reverse=True) return {"items": [{"title": it["title"], "meta": it["meta"], "tag": it.get("tag"), "match": min(100, s + 50)} for s, it in scored]}