764 lines
33 KiB
Python
764 lines
33 KiB
Python
"""产品推介材料业务编排服务。"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import mimetypes
|
||
from datetime import UTC, datetime
|
||
from pathlib import Path
|
||
from typing import Any
|
||
|
||
from sqlalchemy import func, select
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from app.api.schemas.promotion_material import (
|
||
PromotionDeliveryRequest,
|
||
PromotionGenerationRequest,
|
||
PromotionInputsUpdate,
|
||
PromotionReviewRequest,
|
||
PromotionTaskCreate,
|
||
)
|
||
from app.core.config import get_settings
|
||
from app.core.contracts import RequestContext
|
||
from app.core.errors import GenericResourceNotFoundError, ValidationAgentError
|
||
from app.core.promotion_material_contracts import MANDATORY_RISK_DISCLOSURE
|
||
from app.model.audit import InteractionAudit
|
||
from app.model.promotion_material import (
|
||
PromotionAttachment,
|
||
PromotionComplianceCheck,
|
||
PromotionDeliveryRecord,
|
||
PromotionInputSnapshot,
|
||
PromotionMaterialTask,
|
||
PromotionMaterialVersion,
|
||
PromotionReviewRecord,
|
||
)
|
||
from app.service.api_transaction_service import ApiTransactionService
|
||
from app.service.authorization_service import AuthorizationService
|
||
from app.service.promotion_compliance import (
|
||
ComplianceFinding,
|
||
PromotionComplianceChecker,
|
||
)
|
||
from app.service.promotion_pdf_adapter import PromotionPdfAdapter
|
||
from app.service.promotion_performance import (
|
||
create_performance_chart,
|
||
file_hash,
|
||
parse_performance_file,
|
||
)
|
||
from app.service.promotion_poster_renderer import PromotionPosterRenderer
|
||
from app.service.promotion_renderer import PromotionPptxRenderer
|
||
|
||
|
||
class PromotionMaterialService:
|
||
def __init__(self, session: AsyncSession | None = None) -> None:
|
||
self.session = session
|
||
settings = get_settings()
|
||
self.storage_root = Path(settings.promotion_material_storage_dir).resolve()
|
||
self.max_photo_size = settings.promotion_max_photo_size_bytes
|
||
self.max_performance_size = settings.promotion_max_performance_file_size_bytes
|
||
self.compliance = PromotionComplianceChecker()
|
||
self.renderer = PromotionPptxRenderer()
|
||
self.poster_renderer = PromotionPosterRenderer()
|
||
self.pdf_adapter = PromotionPdfAdapter(
|
||
enabled=settings.promotion_pdf_enabled,
|
||
converter_path=settings.promotion_pdf_converter_path,
|
||
)
|
||
|
||
async def create_task(
|
||
self, payload: PromotionTaskCreate, context: RequestContext, key: str | None
|
||
) -> dict[str, Any]:
|
||
await self._require(context, "promotion:write")
|
||
if key is None:
|
||
raise ValidationAgentError("必须提供 Idempotency-Key")
|
||
body = payload.model_dump(mode="json")
|
||
return await ApiTransactionService().execute(
|
||
context,
|
||
"promotion-material:create-task",
|
||
key,
|
||
body,
|
||
lambda session: self._create_task_tx(session, payload, context),
|
||
)
|
||
|
||
async def update_inputs(
|
||
self,
|
||
task_no: str,
|
||
payload: PromotionInputsUpdate,
|
||
context: RequestContext,
|
||
key: str | None,
|
||
) -> dict[str, Any]:
|
||
await self._require(context, "promotion:write")
|
||
if key is None:
|
||
raise ValidationAgentError("必须提供 Idempotency-Key")
|
||
return await ApiTransactionService().execute(
|
||
context,
|
||
f"promotion-material:update-inputs:{task_no}",
|
||
key,
|
||
payload.model_dump(mode="json"),
|
||
lambda session: self._update_inputs_tx(session, task_no, payload, context),
|
||
)
|
||
|
||
async def add_attachment(
|
||
self,
|
||
task_no: str,
|
||
attachment_type: str,
|
||
filename: str,
|
||
media_type: str,
|
||
payload: bytes,
|
||
context: RequestContext,
|
||
key: str | None,
|
||
) -> dict[str, Any]:
|
||
await self._require(context, "promotion:write")
|
||
if key is None:
|
||
raise ValidationAgentError("必须提供 Idempotency-Key")
|
||
if not payload:
|
||
raise ValidationAgentError("上传文件不能为空")
|
||
body = {"attachment_type": attachment_type, "filename": filename,
|
||
"media_type": media_type, "sha256": file_hash(payload)}
|
||
return await ApiTransactionService().execute(
|
||
context,
|
||
f"promotion-material:add-attachment:{task_no}",
|
||
key,
|
||
body,
|
||
lambda session: self._add_attachment_tx(
|
||
session, task_no, attachment_type, filename, media_type, payload, context
|
||
),
|
||
)
|
||
|
||
async def generate(
|
||
self,
|
||
task_no: str,
|
||
payload: PromotionGenerationRequest,
|
||
context: RequestContext,
|
||
key: str | None,
|
||
) -> dict[str, Any]:
|
||
await self._require(context, "promotion:write")
|
||
if key is None:
|
||
raise ValidationAgentError("必须提供 Idempotency-Key")
|
||
return await ApiTransactionService().execute(
|
||
context,
|
||
f"promotion-material:generate:{task_no}",
|
||
key,
|
||
payload.model_dump(mode="json"),
|
||
lambda session: self._generate_tx(session, task_no, payload, context),
|
||
)
|
||
|
||
async def compliance_checks(
|
||
self, task_no: str, context: RequestContext
|
||
) -> dict[str, Any]:
|
||
await self._require(context, "promotion:read")
|
||
session = self._session()
|
||
rows = (await session.execute(select(PromotionComplianceCheck).where(
|
||
PromotionComplianceCheck.task_no == task_no
|
||
).order_by(PromotionComplianceCheck.id))).scalars().all()
|
||
return {"code": 0, "message": "ok", "data": {
|
||
"task_no": task_no,
|
||
"findings": [self._compliance_dict(row) for row in rows],
|
||
}}
|
||
|
||
async def get_task(self, task_no: str, context: RequestContext) -> dict[str, Any]:
|
||
await self._require(context, "promotion:read")
|
||
session = self._session()
|
||
task = await session.scalar(select(PromotionMaterialTask).where(
|
||
PromotionMaterialTask.task_no == task_no
|
||
))
|
||
if task is None:
|
||
raise GenericResourceNotFoundError("推介材料任务不存在")
|
||
is_advisor = "advisor" in context.roles
|
||
if is_advisor:
|
||
delivery = await session.scalar(select(PromotionDeliveryRecord).where(
|
||
PromotionDeliveryRecord.task_no == task_no,
|
||
PromotionDeliveryRecord.advisor_id == int(context.user_id),
|
||
PromotionDeliveryRecord.status == "sent",
|
||
))
|
||
if delivery is None:
|
||
raise GenericResourceNotFoundError("该材料尚未发送给当前投顾")
|
||
version = await session.scalar(select(PromotionMaterialVersion).where(
|
||
PromotionMaterialVersion.task_no == task_no,
|
||
PromotionMaterialVersion.status.in_(("approved", "sent")),
|
||
).order_by(PromotionMaterialVersion.version_no.desc()))
|
||
if version is None:
|
||
return {"code": 0, "message": "ok", "data": {
|
||
"task_no": task_no,
|
||
"product_name": task.product_name,
|
||
"status": task.status,
|
||
"material_version": None,
|
||
}}
|
||
return {"code": 0, "message": "ok", "data": {
|
||
"task_no": task_no,
|
||
"product_name": task.product_name,
|
||
"status": task.status,
|
||
"material_version": {
|
||
"id": version.id,
|
||
"version_no": version.version_no,
|
||
"style_code": version.style_code,
|
||
"status": version.status,
|
||
"pptx_path": version.pptx_path,
|
||
"pdf_path": version.pdf_path,
|
||
"poster_path": version.poster_path,
|
||
"chart_paths": version.chart_paths,
|
||
},
|
||
}}
|
||
|
||
async def review(
|
||
self,
|
||
task_no: str,
|
||
payload: PromotionReviewRequest,
|
||
context: RequestContext,
|
||
key: str | None,
|
||
) -> dict[str, Any]:
|
||
await self._require(context, "promotion:review")
|
||
if key is None:
|
||
raise ValidationAgentError("必须提供 Idempotency-Key")
|
||
return await ApiTransactionService().execute(
|
||
context,
|
||
f"promotion-material:review:{task_no}",
|
||
key,
|
||
payload.model_dump(mode="json"),
|
||
lambda session: self._review_tx(session, task_no, payload, context),
|
||
)
|
||
|
||
async def deliver(
|
||
self,
|
||
task_no: str,
|
||
payload: PromotionDeliveryRequest,
|
||
context: RequestContext,
|
||
key: str | None,
|
||
) -> dict[str, Any]:
|
||
await self._require(context, "promotion:deliver")
|
||
if key is None:
|
||
raise ValidationAgentError("必须提供 Idempotency-Key")
|
||
return await ApiTransactionService().execute(
|
||
context,
|
||
f"promotion-material:deliver:{task_no}",
|
||
key,
|
||
payload.model_dump(mode="json"),
|
||
lambda session: self._deliver_tx(session, task_no, payload, context),
|
||
)
|
||
|
||
async def _create_task_tx(
|
||
self, session: AsyncSession, payload: PromotionTaskCreate, context: RequestContext
|
||
) -> dict[str, Any]:
|
||
task_no = await self._next_task_no(session)
|
||
now = self._now()
|
||
session.add(PromotionMaterialTask(
|
||
task_no=task_no,
|
||
product_code=payload.product_code,
|
||
product_name=payload.product_name,
|
||
material_title=payload.material_title,
|
||
style_code=payload.style_code,
|
||
output_formats=payload.output_formats,
|
||
template_version="promotion-v1",
|
||
status="draft",
|
||
created_by=int(context.user_id),
|
||
created_at=now,
|
||
updated_at=now,
|
||
))
|
||
self._audit(session, context, "promotion.task_created", {"task_no": task_no})
|
||
return {"code": 0, "message": "ok", "data": {"task_no": task_no, "status": "draft"}}
|
||
|
||
async def _update_inputs_tx(
|
||
self, session: AsyncSession, task_no: str, payload: PromotionInputsUpdate,
|
||
context: RequestContext,
|
||
) -> dict[str, Any]:
|
||
task = await self._task(session, task_no)
|
||
latest = await session.scalar(select(func.max(PromotionInputSnapshot.version_no)).where(
|
||
PromotionInputSnapshot.task_no == task_no
|
||
))
|
||
version_no = int(latest or 0) + 1
|
||
now = self._now()
|
||
values = payload.model_dump(mode="json")
|
||
session.add(PromotionInputSnapshot(
|
||
task_no=task_no,
|
||
version_no=version_no,
|
||
product_info=values["product_info"],
|
||
manager_info=values["manager_info"],
|
||
team_info=values["team_info"],
|
||
strategy_info=values["strategy_info"],
|
||
fee_structure=values["fee_structure"],
|
||
performance_info=values["performance_info"],
|
||
risk_disclosure=values["risk_disclosure"],
|
||
source_notes=values["source_notes"],
|
||
created_by=int(context.user_id),
|
||
created_at=now,
|
||
))
|
||
task.status = "input_ready"
|
||
task.updated_at = now
|
||
self._audit(session, context, "promotion.inputs_updated", {
|
||
"task_no": task_no, "input_version": version_no,
|
||
})
|
||
return {"code": 0, "message": "ok", "data": {
|
||
"task_no": task_no, "input_version": version_no, "status": task.status,
|
||
}}
|
||
|
||
async def _add_attachment_tx(
|
||
self,
|
||
session: AsyncSession,
|
||
task_no: str,
|
||
attachment_type: str,
|
||
filename: str,
|
||
media_type: str,
|
||
payload: bytes,
|
||
context: RequestContext,
|
||
) -> dict[str, Any]:
|
||
task = await self._task(session, task_no)
|
||
self._validate_attachment(
|
||
attachment_type,
|
||
filename,
|
||
media_type,
|
||
len(payload),
|
||
max_photo_size=self.max_photo_size,
|
||
max_performance_size=self.max_performance_size,
|
||
)
|
||
digest = file_hash(payload)
|
||
duplicate = await session.scalar(select(PromotionAttachment).where(
|
||
PromotionAttachment.task_no == task_no,
|
||
PromotionAttachment.file_hash == digest,
|
||
))
|
||
if duplicate is not None:
|
||
return {"code": 0, "message": "ok", "data": {
|
||
"attachment_id": duplicate.id, "duplicate": True,
|
||
}}
|
||
extension = Path(filename).suffix.lower()
|
||
destination = self.storage_root / task_no / attachment_type / f"{digest}{extension}"
|
||
destination.parent.mkdir(parents=True, exist_ok=True)
|
||
destination.write_bytes(payload)
|
||
parsed_metadata: dict[str, Any] = {}
|
||
try:
|
||
if attachment_type == "manager_photo":
|
||
from PIL import Image
|
||
|
||
with Image.open(destination) as image:
|
||
parsed_metadata = {"width": image.width, "height": image.height,
|
||
"format": image.format}
|
||
elif attachment_type == "performance_data":
|
||
parsed_metadata = parse_performance_file(destination)
|
||
except Exception as exc:
|
||
destination.unlink(missing_ok=True)
|
||
raise ValidationAgentError("附件内容无法解析或校验失败") from exc
|
||
now = self._now()
|
||
attachment = PromotionAttachment(
|
||
task_no=task_no,
|
||
attachment_type=attachment_type,
|
||
filename=Path(filename).name,
|
||
media_type=(
|
||
media_type
|
||
or mimetypes.guess_type(filename)[0]
|
||
or "application/octet-stream"
|
||
),
|
||
file_hash=digest,
|
||
size_bytes=len(payload),
|
||
file_path=str(destination),
|
||
parsed_metadata=parsed_metadata,
|
||
uploaded_by=int(context.user_id),
|
||
created_at=now,
|
||
)
|
||
session.add(attachment)
|
||
task.updated_at = now
|
||
await session.flush()
|
||
self._audit(session, context, "promotion.attachment_uploaded", {
|
||
"task_no": task_no, "attachment_id": attachment.id,
|
||
"attachment_type": attachment_type, "sha256": digest,
|
||
})
|
||
return {"code": 0, "message": "ok", "data": {
|
||
"attachment_id": attachment.id, "attachment_type": attachment_type,
|
||
"sha256": digest, "size_bytes": len(payload),
|
||
}}
|
||
|
||
async def _generate_tx(
|
||
self,
|
||
session: AsyncSession,
|
||
task_no: str,
|
||
payload: PromotionGenerationRequest,
|
||
context: RequestContext,
|
||
) -> dict[str, Any]:
|
||
task = await self._task(session, task_no)
|
||
snapshot = await session.scalar(select(PromotionInputSnapshot).where(
|
||
PromotionInputSnapshot.task_no == task_no
|
||
).order_by(PromotionInputSnapshot.version_no.desc()))
|
||
if snapshot is None:
|
||
return {"code": 422, "message": "请先补充结构化资料", "data": {}}
|
||
inputs = self._snapshot_dict(snapshot)
|
||
attachments = (await session.execute(select(PromotionAttachment).where(
|
||
PromotionAttachment.task_no == task_no
|
||
).order_by(PromotionAttachment.id))).scalars().all()
|
||
performance_attachment = next(
|
||
(item for item in attachments if item.attachment_type == "performance_data"),
|
||
None,
|
||
)
|
||
inputs["performance_info"] = {
|
||
**inputs["performance_info"],
|
||
"performance_attachment_id": performance_attachment.id
|
||
if performance_attachment is not None
|
||
else None,
|
||
}
|
||
input_findings = self.compliance.check_inputs(inputs)
|
||
if input_findings:
|
||
self._save_findings(session, task_no, None, input_findings)
|
||
task.status = "compliance_failed"
|
||
task.updated_at = self._now()
|
||
return {"code": 422, "message": "输入资料未通过合规校验", "data": {
|
||
"task_no": task_no,
|
||
"findings": [self._finding_dict(item) for item in input_findings],
|
||
}}
|
||
task.status = "generating"
|
||
task.updated_at = self._now()
|
||
version_no = int(await session.scalar(select(func.max(
|
||
PromotionMaterialVersion.version_no
|
||
)).where(PromotionMaterialVersion.task_no == task_no)) or 0) + 1
|
||
draft = self._build_draft(task, inputs)
|
||
pptx_path = self.storage_root / task_no / "materials" / f"v{version_no}.pptx"
|
||
poster_path = self.storage_root / task_no / "materials" / f"v{version_no}-poster.png"
|
||
photo_path = next(
|
||
(
|
||
item.file_path
|
||
for item in attachments
|
||
if item.attachment_type == "manager_photo"
|
||
),
|
||
None,
|
||
)
|
||
try:
|
||
chart_paths = self._build_charts(task_no, version_no, list(attachments), inputs)
|
||
self.renderer.render(draft, pptx_path, photo_path=photo_path,
|
||
chart_paths=chart_paths)
|
||
requested_formats = payload.output_formats or task.output_formats
|
||
if "poster" in requested_formats:
|
||
self.poster_renderer.render(
|
||
draft,
|
||
poster_path,
|
||
photo_path=photo_path,
|
||
chart_paths=chart_paths,
|
||
)
|
||
pdf_path: str | None = None
|
||
if "pdf" in requested_formats:
|
||
target_pdf = self.storage_root / task_no / "materials" / f"v{version_no}.pdf"
|
||
pdf_path = self.pdf_adapter.convert(pptx_path, target_pdf)
|
||
if pdf_path is None:
|
||
raise RuntimeError("PDF 转换未启用或转换器路径未配置")
|
||
except (RuntimeError, OSError, ValueError) as exc:
|
||
task.status = "failed"
|
||
task.updated_at = self._now()
|
||
return {"code": 503, "message": str(exc), "data": {"task_no": task_no}}
|
||
version = PromotionMaterialVersion(
|
||
task_no=task_no,
|
||
input_snapshot_id=snapshot.id,
|
||
version_no=version_no,
|
||
style_code=task.style_code,
|
||
template_version=task.template_version,
|
||
prompt_version="deterministic-v1",
|
||
draft_json=draft,
|
||
pptx_path=str(pptx_path),
|
||
pdf_path=pdf_path,
|
||
poster_path=str(poster_path) if "poster" in requested_formats else None,
|
||
chart_paths=chart_paths,
|
||
status="generated",
|
||
generated_by=int(context.user_id),
|
||
created_at=self._now(),
|
||
)
|
||
session.add(version)
|
||
await session.flush()
|
||
findings = self.compliance.check_draft(draft, inputs)
|
||
if not findings:
|
||
findings = [ComplianceFinding(
|
||
"overall.pass", "确定性合规校验通过", "generated_text", "pass",
|
||
None, "可提交人工审核",
|
||
)]
|
||
self._save_findings(session, task_no, version.id, findings)
|
||
blocking = any(item.severity == "block" for item in findings)
|
||
version.status = "compliance_failed" if blocking else "pending_review"
|
||
task.status = version.status
|
||
task.updated_at = self._now()
|
||
self._audit(session, context, "promotion.material_generated", {
|
||
"task_no": task_no, "material_version_id": version.id,
|
||
"status": task.status,
|
||
})
|
||
return {"code": 0 if not blocking else 422,
|
||
"message": "ok" if not blocking else "生成内容未通过合规校验",
|
||
"data": {
|
||
"task_no": task_no, "material_version_id": version.id,
|
||
"status": task.status, "pptx_path": str(pptx_path),
|
||
"pdf_path": pdf_path,
|
||
"poster_path": (
|
||
str(poster_path) if "poster" in requested_formats else None
|
||
),
|
||
"chart_paths": chart_paths,
|
||
"findings": [self._finding_dict(item) for item in findings],
|
||
}}
|
||
|
||
async def _review_tx(
|
||
self, session: AsyncSession, task_no: str, payload: PromotionReviewRequest,
|
||
context: RequestContext,
|
||
) -> dict[str, Any]:
|
||
task = await self._task(session, task_no)
|
||
version = await session.scalar(select(PromotionMaterialVersion).where(
|
||
PromotionMaterialVersion.id == payload.material_version_id,
|
||
PromotionMaterialVersion.task_no == task_no,
|
||
).with_for_update())
|
||
if version is None:
|
||
raise GenericResourceNotFoundError("材料版本不存在")
|
||
if version.status != "pending_review":
|
||
return {"code": 422, "message": "当前材料版本不在待审核状态", "data": {}}
|
||
checks = (await session.execute(select(PromotionComplianceCheck).where(
|
||
PromotionComplianceCheck.material_version_id == version.id,
|
||
PromotionComplianceCheck.severity == "block",
|
||
))).scalars().all()
|
||
if checks:
|
||
return {"code": 422, "message": "存在阻断级合规问题", "data": {}}
|
||
now = self._now()
|
||
session.add(PromotionReviewRecord(
|
||
task_no=task_no, material_version_id=version.id, reviewer_id=int(context.user_id),
|
||
decision=payload.decision, comment=payload.comment, created_at=now,
|
||
))
|
||
version.status = "approved" if payload.decision == "approved" else "rejected"
|
||
task.status = (
|
||
"approved"
|
||
if payload.decision == "approved"
|
||
else "draft" if payload.decision == "revision_requested" else "rejected"
|
||
)
|
||
task.updated_at = now
|
||
self._audit(session, context, "promotion.material_reviewed", {
|
||
"task_no": task_no, "material_version_id": version.id,
|
||
"decision": payload.decision,
|
||
})
|
||
return {"code": 0, "message": "ok", "data": {
|
||
"task_no": task_no, "material_version_id": version.id, "status": task.status,
|
||
}}
|
||
|
||
async def _deliver_tx(
|
||
self, session: AsyncSession, task_no: str, payload: PromotionDeliveryRequest,
|
||
context: RequestContext,
|
||
) -> dict[str, Any]:
|
||
task = await self._task(session, task_no)
|
||
version = await session.scalar(select(PromotionMaterialVersion).where(
|
||
PromotionMaterialVersion.id == payload.material_version_id,
|
||
PromotionMaterialVersion.task_no == task_no,
|
||
).with_for_update())
|
||
if version is None:
|
||
raise GenericResourceNotFoundError("材料版本不存在")
|
||
if version.status != "approved":
|
||
return {"code": 422, "message": "只有审核通过的材料可以发送", "data": {}}
|
||
if payload.delivery_channel != "internal_record":
|
||
return {"code": 422, "message": "首版只支持内部发送记录，未接入外部投顾端", "data": {}}
|
||
now = self._now()
|
||
for advisor_id in payload.advisor_ids:
|
||
existing = await session.scalar(select(PromotionDeliveryRecord).where(
|
||
PromotionDeliveryRecord.material_version_id == version.id,
|
||
PromotionDeliveryRecord.advisor_id == advisor_id,
|
||
))
|
||
if existing is None:
|
||
session.add(PromotionDeliveryRecord(
|
||
task_no=task_no, material_version_id=version.id, advisor_id=advisor_id,
|
||
delivery_channel=payload.delivery_channel, status="sent",
|
||
created_by=int(context.user_id), created_at=now, sent_at=now,
|
||
))
|
||
else:
|
||
existing.status = "sent"
|
||
existing.sent_at = now
|
||
version.status = "sent"
|
||
task.status = "sent"
|
||
task.updated_at = now
|
||
self._audit(session, context, "promotion.material_delivered", {
|
||
"task_no": task_no, "material_version_id": version.id,
|
||
"advisor_ids": payload.advisor_ids,
|
||
})
|
||
return {"code": 0, "message": "ok", "data": {
|
||
"task_no": task_no, "material_version_id": version.id,
|
||
"advisor_ids": payload.advisor_ids, "status": "sent",
|
||
}}
|
||
|
||
@staticmethod
|
||
def _build_draft(task: PromotionMaterialTask, inputs: dict[str, Any]) -> dict[str, Any]:
|
||
product = inputs["product_info"]
|
||
manager = inputs["manager_info"]
|
||
team = inputs["team_info"]
|
||
strategy = inputs["strategy_info"]
|
||
fees = inputs["fee_structure"]
|
||
performance = inputs["performance_info"]
|
||
risk = inputs["risk_disclosure"]
|
||
fee_text = "；".join(f"{key}: {value}" for key, value in fees.items() if value)
|
||
performance_text = (
|
||
f"数据截至 {performance.get('as_of_date') or '未填写'}。"
|
||
f"区间 {performance.get('history_months') or '未填写'} 个月。"
|
||
f"产品收益 {performance.get('product_return') or '未提供'}。"
|
||
f"最大回撤 {performance.get('max_drawdown') or '未提供'}，"
|
||
f"波动率 {performance.get('volatility') or '未提供'}，"
|
||
f"夏普比率 {performance.get('sharpe_ratio') or '未提供'}。"
|
||
)
|
||
return {
|
||
"title": task.material_title,
|
||
"subtitle": f"{task.product_name} 产品推介材料",
|
||
"style_code": task.style_code,
|
||
"chapters": [
|
||
{"title": task.material_title, "body": "仅供合规审核和专业投顾使用"},
|
||
{"title": "产品基本信息", "body": (
|
||
f"基金类型：{product['fund_type']}\n运作方式：{product['operation_mode']}\n"
|
||
f"产品状态：{product.get('product_status', '')}\n"
|
||
f"投资目标：{product['investment_objective']}\n"
|
||
f"业绩比较基准：{product.get('benchmark') or '未提供'}"
|
||
)},
|
||
{"title": "管理人及投研团队", "body": (
|
||
f"管理人：{manager['management_company']}\n登记编码：{manager['registration_code']}\n"
|
||
f"基金经理：{manager['manager_name']}\n"
|
||
f"从业年限：{manager.get('employment_years') or '未提供'}\n"
|
||
"实际投资管理经验："
|
||
f"{manager.get('investment_management_experience') or '未提供'}\n"
|
||
f"团队建设：{team['team_description']}\n"
|
||
f"投研能力：{team.get('research_capability') or '未提供'}"
|
||
)},
|
||
{"title": "投资范围、策略与限制", "body": (
|
||
f"投资范围：{strategy['investment_scope']}\n策略：{strategy['strategy']}\n"
|
||
f"投资限制：{strategy['restrictions']}\n"
|
||
f"工具属性：{strategy.get('index_tool_attribute') or '不适用'}"
|
||
)},
|
||
{"title": "费用结构", "body": fee_text or "未提供费用结构"},
|
||
{"title": "基金经理历史业绩", "body": (
|
||
"以下内容为基金经理代表产品历史业绩，不代表本基金历史业绩。\n"
|
||
+ performance_text
|
||
), "chart_index": 0},
|
||
{"title": "产品、基准与代表产品曲线", "body": (
|
||
"曲线由上传的结构化业绩数据生成，具体口径以来源文件和审核结果为准。"
|
||
), "chart_index": 0},
|
||
{"title": "收益与风险指标", "body": (
|
||
f"{performance_text}\n"
|
||
"最大回撤反映历史区间内的最大跌幅，波动率反映收益变化幅度，"
|
||
"夏普比率用于辅助观察单位风险对应的超额收益。"
|
||
)},
|
||
{"title": "风险揭示", "body": (
|
||
MANDATORY_RISK_DISCLOSURE + "。\n"
|
||
+ "\n".join(f"特别风险：{item}" for item in risk.get("special_risks", []))
|
||
+ (
|
||
f"\n补充说明：{risk['additional_notes']}"
|
||
if risk.get("additional_notes")
|
||
else ""
|
||
)
|
||
)},
|
||
{"title": "资料来源与版本", "body": (
|
||
"本材料基于运营人员提交的结构化资料、附件和固定模板生成。"
|
||
"生成后须经人工审核，未经审核不得对外使用。"
|
||
)},
|
||
],
|
||
}
|
||
|
||
def _build_charts(
|
||
self,
|
||
task_no: str,
|
||
version_no: int,
|
||
attachments: list[PromotionAttachment],
|
||
inputs: dict[str, Any],
|
||
) -> list[str]:
|
||
performance_attachment = next(
|
||
(item for item in attachments if item.attachment_type == "performance_data"), None
|
||
)
|
||
if performance_attachment is None:
|
||
return []
|
||
data = parse_performance_file(performance_attachment.file_path)
|
||
destination = self.storage_root / task_no / "charts" / f"v{version_no}-performance.png"
|
||
return [create_performance_chart(
|
||
data, destination, title=f"{inputs['product_info'].get('fund_type', '')} 业绩曲线"
|
||
)]
|
||
|
||
async def _task(self, session: AsyncSession, task_no: str) -> PromotionMaterialTask:
|
||
task = await session.scalar(select(PromotionMaterialTask).where(
|
||
PromotionMaterialTask.task_no == task_no
|
||
).with_for_update())
|
||
if task is None:
|
||
raise GenericResourceNotFoundError("推介材料任务不存在")
|
||
return task
|
||
|
||
def _session(self) -> AsyncSession:
|
||
if self.session is None:
|
||
raise RuntimeError("查询服务缺少数据库会话")
|
||
return self.session
|
||
|
||
@staticmethod
|
||
async def _require(context: RequestContext, permission: str) -> None:
|
||
await AuthorizationService.require(context, permission)
|
||
|
||
async def _next_task_no(self, session: AsyncSession) -> str:
|
||
today = datetime.now().strftime("%Y%m%d")
|
||
count = await session.scalar(select(func.count()).select_from(PromotionMaterialTask).where(
|
||
PromotionMaterialTask.task_no.like(f"PM-{today}-%")
|
||
))
|
||
return f"PM-{today}-{int(count or 0) + 1:04d}"
|
||
|
||
@staticmethod
|
||
def _snapshot_dict(snapshot: PromotionInputSnapshot) -> dict[str, Any]:
|
||
return {
|
||
"product_info": snapshot.product_info,
|
||
"manager_info": snapshot.manager_info,
|
||
"team_info": snapshot.team_info,
|
||
"strategy_info": snapshot.strategy_info,
|
||
"fee_structure": snapshot.fee_structure,
|
||
"performance_info": snapshot.performance_info,
|
||
"risk_disclosure": snapshot.risk_disclosure,
|
||
"source_notes": snapshot.source_notes,
|
||
}
|
||
|
||
@staticmethod
|
||
def _validate_attachment(
|
||
attachment_type: str,
|
||
filename: str,
|
||
media_type: str,
|
||
size: int,
|
||
*,
|
||
max_photo_size: int,
|
||
max_performance_size: int,
|
||
) -> None:
|
||
limits = {
|
||
"manager_photo": (max_photo_size, {".jpg", ".jpeg", ".png", ".webp"}),
|
||
"performance_data": (max_performance_size, {".csv", ".xlsx", ".xlsm"}),
|
||
"source_evidence": (30 * 1024 * 1024, {".pdf", ".docx", ".xlsx", ".csv"}),
|
||
"template_file": (50 * 1024 * 1024, {".pptx"}),
|
||
}
|
||
if attachment_type not in limits:
|
||
raise ValidationAgentError("不支持的附件类型")
|
||
maximum, extensions = limits[attachment_type]
|
||
if size > maximum:
|
||
raise ValidationAgentError("附件超过大小限制")
|
||
if Path(filename).suffix.lower() not in extensions:
|
||
raise ValidationAgentError("附件扩展名与附件类型不匹配")
|
||
if attachment_type == "manager_photo" and not media_type.startswith("image/"):
|
||
raise ValidationAgentError("基金经理头像必须是图片")
|
||
|
||
@staticmethod
|
||
def _finding_dict(item: ComplianceFinding) -> dict[str, Any]:
|
||
return {
|
||
"rule_code": item.rule_code, "rule_name": item.rule_name, "scope": item.scope,
|
||
"severity": item.severity, "hit_text": item.hit_text, "suggestion": item.suggestion,
|
||
}
|
||
|
||
@staticmethod
|
||
def _compliance_dict(row: PromotionComplianceCheck) -> dict[str, Any]:
|
||
return {
|
||
"id": row.id, "material_version_id": row.material_version_id,
|
||
"rule_code": row.rule_code, "rule_name": row.rule_name, "scope": row.scope,
|
||
"severity": row.severity, "hit_text": row.hit_text, "suggestion": row.suggestion,
|
||
}
|
||
|
||
def _save_findings(
|
||
self,
|
||
session: AsyncSession,
|
||
task_no: str,
|
||
version_id: int | None,
|
||
findings: list[ComplianceFinding],
|
||
) -> None:
|
||
now = self._now()
|
||
for item in findings:
|
||
session.add(PromotionComplianceCheck(
|
||
task_no=task_no, material_version_id=version_id,
|
||
rule_code=item.rule_code, rule_name=item.rule_name, scope=item.scope,
|
||
severity=item.severity, hit_text=item.hit_text, suggestion=item.suggestion,
|
||
created_at=now,
|
||
))
|
||
|
||
@staticmethod
|
||
def _audit(session: AsyncSession, context: RequestContext, action: str,
|
||
detail: dict[str, Any]) -> None:
|
||
session.add(InteractionAudit(
|
||
actor_type="user", actor_id=int(context.user_id), target_customer_id=None,
|
||
session_id=None, portal=context.portal, action_type=action,
|
||
detail={**detail, "trace_id": context.trace_id},
|
||
created_at=datetime.now(UTC).replace(tzinfo=None),
|
||
))
|
||
|
||
@staticmethod
|
||
def _now() -> datetime:
|
||
return datetime.now(UTC).replace(tzinfo=None)
|