368 lines
14 KiB
Python
368 lines
14 KiB
Python
"""草稿代理 + 本地镜像 + 发送终审（投顾工作台核心闭环）。
|
||
|
||
- 草稿 list/detail/save/discard 代理到投顾Agent（错误码映射见 agent_client）；
|
||
- save 时本地镜像一份 advisor_report(send_status=draft)，实现 A5「以最后保存快照为准」；
|
||
- send 为工作台本地实现：签约兜底 + 三检终审（敏感词/适当性/免责）+ 写 sys_message
|
||
与 advisor_report(sent) 同事务；Agent 不感知 sent。
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import uuid
|
||
from datetime import datetime
|
||
from typing import Any
|
||
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from common_const import (
|
||
AGENT_INTENT_RECOMMEND,
|
||
CUSTOMER_REL_STATUS_SIGNED,
|
||
INTENT_TO_MSG_TYPE,
|
||
MSG_TYPE_RECOMMEND,
|
||
REPORT_SEND_STATUS_DISCARDED,
|
||
REPORT_SEND_STATUS_DRAFT,
|
||
REPORT_SEND_STATUS_SENT,
|
||
)
|
||
from model.advisor_report import AdvisorReport
|
||
from model.sys_message import SysMessage
|
||
from model.sys_user import SysUser
|
||
from repositories.advisor_report import AdvisorReportRepo
|
||
from repositories.product import ProductRepo
|
||
from repositories.risk_assessment import CustomerProfileRepo
|
||
from repositories.sensitive_word import SensitiveWordRepo
|
||
from repositories.sys_message import SysMessageRepo
|
||
from schemas.advisor import DraftSaveReq, RebalanceRunReq, TalkScriptReq
|
||
from service.advisor.agent_client import get_agent_client
|
||
from service.advisor.permissions import ensure_customer_owned, require_owned_relation
|
||
from service.advisor.send_review import review_send
|
||
from utils.exceptions import ForbiddenError, ParamError
|
||
|
||
# 建议清单中「低配申购」侧键（Agent 侧 suggestions 结构，文档未给字段级定义，按合理约定）
|
||
# 假设：suggestions 为 dict，申购清单在 buy/purchase/低配申购/申购 任一键下，项含 product_code。
|
||
_BUY_KEYS = ("buy", "purchase", "低配申购", "申购")
|
||
|
||
|
||
def gen_report_id() -> str:
|
||
"""生成本地报告唯一 ID（advisor_report.report_id）。"""
|
||
return "rpt-" + uuid.uuid4().hex
|
||
|
||
|
||
def _build_report_from_detail(detail: dict, advisor_id: int) -> AdvisorReport:
|
||
"""由 Agent 草稿详情构建本地报告镜像（未 save 直接 send 的兜底，D6）。"""
|
||
return AdvisorReport(
|
||
report_id=gen_report_id(),
|
||
draft_id=str(detail.get("draft_id") or ""),
|
||
customer_id=int(detail.get("customer_id") or 0),
|
||
advisor_id=advisor_id,
|
||
intent=detail.get("intent") or AGENT_INTENT_RECOMMEND,
|
||
title=detail.get("title"),
|
||
content=detail.get("content"),
|
||
edit_history=[],
|
||
send_status=REPORT_SEND_STATUS_DRAFT,
|
||
)
|
||
|
||
|
||
def _extract_buy_codes(detail: Any) -> list[str]:
|
||
"""从 Agent 草稿详情提取发送终审需要校验的产品代码。
|
||
|
||
兼容旧的顶层 ``suggestions``，以及 Agent 当前的 ``structured_data``：调仓只取
|
||
``buy``，推荐取 ``items``。解析失败返回空列表，交由其它终审规则继续处理。
|
||
"""
|
||
if not isinstance(detail, dict):
|
||
return []
|
||
|
||
structured_data = detail.get("structured_data")
|
||
data = structured_data if isinstance(structured_data, dict) else detail
|
||
suggestions = data.get("suggestions")
|
||
if isinstance(suggestions, dict):
|
||
data = suggestions
|
||
|
||
items: list | None = None
|
||
for key in _BUY_KEYS:
|
||
value = data.get(key)
|
||
if isinstance(value, list):
|
||
items = value
|
||
break
|
||
if items is None and isinstance(data.get("items"), list):
|
||
items = data["items"]
|
||
|
||
codes: list[str] = []
|
||
for it in items or []:
|
||
if isinstance(it, dict):
|
||
code = it.get("product_code") or it.get("code") or it.get("fund_code")
|
||
if code:
|
||
codes.append(str(code))
|
||
return codes
|
||
|
||
|
||
async def _get_customer_risk(db: AsyncSession, customer_id: int) -> str | None:
|
||
"""客户当前风险等级（适当性硬依据）。
|
||
|
||
假设：取 fin_customer_profile.risk_level（问卷服务在风评后回写，与 fin_risk_assessment
|
||
保持一致），作为「当前有效 C 级」。
|
||
"""
|
||
profile = await CustomerProfileRepo(db).get_by_customer(customer_id)
|
||
return profile.risk_level if profile else None
|
||
|
||
|
||
async def _resolve_product_risks(
|
||
db: AsyncSession, draft_id: str, auth_header: str, trace_id: str
|
||
) -> list[str | None]:
|
||
"""适当性输入：取草稿建议清单的申购产品，查 fin_product 得 R 级。
|
||
|
||
本地镜像不存 suggestions，故发送时向 Agent 实时取一次结构化清单；Agent 不可用则
|
||
发送被 fail-closed 阻断（合规优先，符合 PRD「不可完全依赖 Agent」+ 双重防护）。
|
||
"""
|
||
result = await get_agent_client().draft_detail(
|
||
draft_id, auth_header=auth_header, trace_id=trace_id
|
||
)
|
||
codes = _extract_buy_codes(result["data"] or {})
|
||
product_repo = ProductRepo(db)
|
||
risks: list[str | None] = []
|
||
for code in codes:
|
||
product = await product_repo.get_by_code(code)
|
||
risks.append(product.risk_level if product else None)
|
||
return risks
|
||
|
||
|
||
def _sent_payload(report: AdvisorReport) -> dict:
|
||
return {
|
||
"report_id": report.report_id,
|
||
"send_time": report.send_time.isoformat() if report.send_time else None,
|
||
"msg_id": report.msg_id,
|
||
}
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 草稿代理（读取/编辑/废弃）
|
||
# ---------------------------------------------------------------------------
|
||
async def list_drafts(
|
||
db: AsyncSession,
|
||
user: SysUser,
|
||
*,
|
||
auth_header: str,
|
||
trace_id: str,
|
||
customer_id: int | None = None,
|
||
status: str | None = None,
|
||
page: int = 1,
|
||
page_size: int = 20,
|
||
) -> dict:
|
||
result = await get_agent_client().draft_list(
|
||
auth_header=auth_header,
|
||
trace_id=trace_id,
|
||
advisor_id=user.id,
|
||
customer_id=customer_id,
|
||
status=status,
|
||
page=page,
|
||
page_size=page_size,
|
||
)
|
||
data = result["data"] or {}
|
||
if result["warning"]:
|
||
data["warning"] = result["warning"]
|
||
return data
|
||
|
||
|
||
async def get_draft(
|
||
db: AsyncSession, user: SysUser, *, auth_header: str, trace_id: str, draft_id: str
|
||
) -> dict:
|
||
result = await get_agent_client().draft_detail(
|
||
draft_id, auth_header=auth_header, trace_id=trace_id
|
||
)
|
||
data = result["data"] or {}
|
||
# 数据权限：草稿归属客户必须属于当前投顾；无法确认归属时拒绝（fail-closed）
|
||
customer_id = data.get("customer_id")
|
||
if customer_id is None:
|
||
raise ForbiddenError("无法校验草稿归属客户")
|
||
await ensure_customer_owned(db, user.id, int(customer_id))
|
||
if result["warning"]:
|
||
data["warning"] = result["warning"]
|
||
return data
|
||
|
||
|
||
async def _upsert_report_mirror(
|
||
db: AsyncSession, user: SysUser, draft_id: str, detail: dict, req: DraftSaveReq
|
||
) -> None:
|
||
"""save 后本地镜像快照（send_status=draft），记录编辑留痕。
|
||
|
||
已发送（sent）的快照不回退为 draft，避免覆盖已交付内容。
|
||
"""
|
||
repo = AdvisorReportRepo(db)
|
||
report = await repo.get_by_draft_id(draft_id)
|
||
edit_entry = {
|
||
"editor": user.id,
|
||
"time": datetime.now().isoformat(),
|
||
"title": req.title,
|
||
}
|
||
if report is None:
|
||
report = AdvisorReport(
|
||
report_id=gen_report_id(),
|
||
draft_id=draft_id,
|
||
customer_id=int(detail["customer_id"]),
|
||
advisor_id=user.id,
|
||
intent=detail.get("intent") or AGENT_INTENT_RECOMMEND,
|
||
title=req.title,
|
||
content=req.content,
|
||
edit_history=[edit_entry],
|
||
send_status=REPORT_SEND_STATUS_DRAFT,
|
||
)
|
||
db.add(report)
|
||
elif report.send_status != REPORT_SEND_STATUS_SENT:
|
||
report.title = req.title
|
||
report.content = req.content
|
||
report.edit_history = list(report.edit_history or []) + [edit_entry]
|
||
report.send_status = REPORT_SEND_STATUS_DRAFT
|
||
await db.commit()
|
||
|
||
|
||
async def save_draft(
|
||
db: AsyncSession,
|
||
user: SysUser,
|
||
*,
|
||
auth_header: str,
|
||
trace_id: str,
|
||
draft_id: str,
|
||
req: DraftSaveReq,
|
||
) -> dict:
|
||
# 1) 先取草稿确认归属（避免对无权限草稿执行写操作），并拿到 intent/customer_id
|
||
detail = await get_draft(db, user, auth_header=auth_header, trace_id=trace_id, draft_id=draft_id)
|
||
# 2) 调 Agent 保存（Agent 重新适当性校验，违规 40020；缺免责仅告警不阻断）
|
||
payload = {
|
||
"title": req.title,
|
||
"content": req.content,
|
||
"structured_data": req.suggestions,
|
||
}
|
||
result = await get_agent_client().draft_save(
|
||
draft_id, payload, auth_header=auth_header, trace_id=trace_id
|
||
)
|
||
# 3) 本地镜像快照
|
||
await _upsert_report_mirror(db, user, draft_id, detail, req)
|
||
data = result["data"] or {}
|
||
if result["warning"]:
|
||
data["warning"] = result["warning"]
|
||
return data
|
||
|
||
|
||
async def discard_draft(
|
||
db: AsyncSession, user: SysUser, *, auth_header: str, trace_id: str, draft_id: str
|
||
) -> dict:
|
||
# 1) 确认归属（避免越权废弃）
|
||
await get_draft(db, user, auth_header=auth_header, trace_id=trace_id, draft_id=draft_id)
|
||
# 2) 回写 Agent 归档（Agent 不可用则废弃失败，本地不翻转，保持一致）
|
||
result = await get_agent_client().draft_operate(
|
||
draft_id, "discard", auth_header=auth_header, trace_id=trace_id
|
||
)
|
||
# 3) 本地镜像翻转 discarded（已 sent 的终态不回退）
|
||
report = await AdvisorReportRepo(db).get_by_draft_id(draft_id)
|
||
if report is not None and report.send_status != REPORT_SEND_STATUS_SENT:
|
||
report.send_status = REPORT_SEND_STATUS_DISCARDED
|
||
await db.commit()
|
||
data = result["data"] or {}
|
||
if result["warning"]:
|
||
data["warning"] = result["warning"]
|
||
return data
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 发送（工作台本地，Agent 不感知）
|
||
# ---------------------------------------------------------------------------
|
||
async def send_draft(
|
||
db: AsyncSession, user: SysUser, *, auth_header: str, trace_id: str, draft_id: str
|
||
) -> dict:
|
||
repo = AdvisorReportRepo(db)
|
||
report = await repo.get_by_draft_id(draft_id)
|
||
|
||
# 无快照：未 save 直接发送，先拉 Agent 草稿建快照（D6 fallback）
|
||
if report is None:
|
||
detail = await get_draft(db, user, auth_header=auth_header, trace_id=trace_id, draft_id=draft_id)
|
||
report = _build_report_from_detail(detail, user.id)
|
||
elif report.advisor_id != user.id:
|
||
raise ForbiddenError("无权操作该客户数据")
|
||
|
||
if report.send_status == REPORT_SEND_STATUS_DISCARDED:
|
||
raise ParamError("已废弃的报告不可发送")
|
||
|
||
# 幂等：已发送直接返回（重复点击不重复发站内信）
|
||
if report.send_status == REPORT_SEND_STATUS_SENT:
|
||
return {**_sent_payload(report), "duplicated": True}
|
||
|
||
# 数据权限 + 签约状态实时兜底（发送前实时查询，PRD §4.5.2）
|
||
rel = await require_owned_relation(db, user.id, report.customer_id)
|
||
if rel.status != CUSTOMER_REL_STATUS_SIGNED:
|
||
raise ForbiddenError("客户尚未签约，禁止发送报告")
|
||
|
||
# 发送终审（三检全过才放行；适当性需 Agent 侧结构化建议清单）
|
||
customer_risk = await _get_customer_risk(db, report.customer_id)
|
||
product_risks = await _resolve_product_risks(db, draft_id, auth_header, trace_id)
|
||
sensitive_words = [w.word for w in await SensitiveWordRepo(db).list_active()]
|
||
review_send(
|
||
content=report.content,
|
||
title=report.title,
|
||
customer_risk=customer_risk,
|
||
product_risks=product_risks,
|
||
sensitive_words=sensitive_words,
|
||
)
|
||
|
||
# 提交结果不确定后重试时，先复用已经写入的站内信，避免重复触达客户。
|
||
existing_message = await SysMessageRepo(db).get_by_biz_id(
|
||
report.report_id, user_id=report.customer_id
|
||
)
|
||
if existing_message is not None:
|
||
report.send_status = REPORT_SEND_STATUS_SENT
|
||
report.send_time = report.send_time or existing_message.create_time
|
||
report.send_by = report.send_by or user.id
|
||
report.msg_id = existing_message.id
|
||
db.add(report)
|
||
await db.commit()
|
||
return {**_sent_payload(report), "duplicated": True}
|
||
|
||
# 写站内信 + 报告置 sent，同事务（失败可重试，避免假送达）
|
||
msg_type = INTENT_TO_MSG_TYPE.get(report.intent, MSG_TYPE_RECOMMEND)
|
||
message = SysMessage(
|
||
user_id=report.customer_id,
|
||
msg_type=msg_type,
|
||
title=report.title or msg_type,
|
||
content=(report.content or "")[:512],
|
||
biz_id=report.report_id,
|
||
)
|
||
report.send_status = REPORT_SEND_STATUS_SENT
|
||
report.send_time = datetime.now()
|
||
report.send_by = user.id
|
||
db.add(message)
|
||
db.add(report) # 已跟踪对象时无副作用，新对象时入 session
|
||
try:
|
||
await db.flush() # 生成 message.id，供回填 msg_id
|
||
report.msg_id = message.id
|
||
await db.commit()
|
||
except Exception:
|
||
await db.rollback()
|
||
raise
|
||
return _sent_payload(report)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 调仓触发 / 话术（代理 Agent）
|
||
# ---------------------------------------------------------------------------
|
||
async def run_rebalance(
|
||
db: AsyncSession, user: SysUser, *, auth_header: str, trace_id: str, req: RebalanceRunReq
|
||
) -> dict:
|
||
# 本地先校验归属 + 签约，快速失败（Agent 侧 40030 为兜底）；未签约不生成待办
|
||
rel = await require_owned_relation(db, user.id, req.customer_id)
|
||
if rel.status != CUSTOMER_REL_STATUS_SIGNED:
|
||
raise ParamError("该客户尚未签约，不支持生成调仓建议")
|
||
result = await get_agent_client().rebalance_run(
|
||
req.customer_id, auth_header=auth_header, trace_id=trace_id
|
||
)
|
||
return result["data"] or {"accepted": True}
|
||
|
||
|
||
async def generate_talk_script(
|
||
db: AsyncSession, user: SysUser, *, auth_header: str, trace_id: str, req: TalkScriptReq
|
||
) -> dict:
|
||
await ensure_customer_owned(db, user.id, req.customer_id)
|
||
result = await get_agent_client().generate_talk_script(
|
||
req.customer_id, req.scene_type, auth_header=auth_header, trace_id=trace_id
|
||
)
|
||
data = result["data"] or {}
|
||
if result["warning"]:
|
||
data["warning"] = result["warning"]
|
||
return data
|