1073 lines
38 KiB
Python
1073 lines
38 KiB
Python
"""智能受理编排服务。
|
|
|
|
负责把临时材料、Agent 结构化结果和人工补充收敛为一次可追溯、幂等的正式建单事务。
|
|
"""
|
|
|
|
import base64
|
|
from datetime import timedelta
|
|
|
|
from celery.result import AsyncResult
|
|
from django.conf import settings
|
|
from django.db import transaction
|
|
from django.utils import timezone
|
|
from django.utils.dateparse import parse_datetime
|
|
|
|
from apps.agents.models import AgentArtifact, AgentDefinition, AgentRun, AgentVersion
|
|
from apps.agents.services import append_run_event, build_config_snapshot, execute_agent_run
|
|
from apps.audit.models import OperationAuditLog
|
|
from apps.knowledge.models import KnowledgeItem
|
|
from apps.knowledge.services import retrieve_knowledge
|
|
from apps.modelhub.models import ModelDeployment
|
|
from apps.tickets.materials import SUPPORTED_EXTENSIONS
|
|
from apps.tickets.models import (
|
|
TicketActorSource,
|
|
TicketAttachment,
|
|
TicketDraft,
|
|
TicketDraftMaterial,
|
|
TicketDraftMessage,
|
|
TicketEvent,
|
|
TicketMessageTimelineItem,
|
|
)
|
|
from apps.tickets.services import (
|
|
BUSINESS_TIME_FIELDS,
|
|
TicketDataError,
|
|
create_ticket_from_fields,
|
|
create_ticket_from_intake,
|
|
normalize_business_datetime,
|
|
normalize_tags,
|
|
)
|
|
from apps.tickets.storage import copy_object, delete_object, get_object
|
|
from apps.workitems.services import (
|
|
complete_ticket_intake_failure_work_item,
|
|
sync_ticket_intake_failure_work_item,
|
|
sync_ticket_missing_info_work_item,
|
|
)
|
|
|
|
ACTIVE_DRAFT_STATUSES = {
|
|
"collecting",
|
|
"analyzing",
|
|
"needs_input",
|
|
"failed",
|
|
# Compatibility while an existing development database is being migrated.
|
|
"editing",
|
|
"ready",
|
|
}
|
|
FINAL_DRAFT_STATUSES = {"ticket_created", "rejected", "expired", "confirmed"}
|
|
ALLOWED_FIELD_CODES = {
|
|
"title",
|
|
"description",
|
|
"category_code",
|
|
"priority",
|
|
"problem_performance",
|
|
"problem_object",
|
|
"submitter_name",
|
|
"submitter_org",
|
|
"impact_scope",
|
|
"environment",
|
|
"related_system",
|
|
"product_name",
|
|
"module_name",
|
|
"tags",
|
|
"attempted_actions",
|
|
"error_information",
|
|
"customer_request",
|
|
"current_result",
|
|
"assignee_id",
|
|
"problem_started_at",
|
|
"customer_last_message_at",
|
|
"support_first_response_at",
|
|
"support_last_reply_at",
|
|
}
|
|
PROVENANCE_FIELD_CODES = {
|
|
"problem_object",
|
|
"submitter_name",
|
|
"submitter_org",
|
|
"product_name",
|
|
"module_name",
|
|
}
|
|
|
|
|
|
class TicketDraftError(ValueError):
|
|
def __init__(self, status_code: int, message: str):
|
|
super().__init__(message)
|
|
self.status_code = status_code
|
|
|
|
|
|
def _build_knowledge_context(query: str, limit: int = 3) -> list[dict]:
|
|
"""Return only reviewed item guidance; never expose raw document chunks to the Agent."""
|
|
if not query.strip():
|
|
return []
|
|
retrieved = retrieve_knowledge(query=query, limit=max(limit * 3, limit))
|
|
item_ids = [
|
|
item.get("metadata", {}).get("item_id")
|
|
for item in retrieved
|
|
if item.get("metadata", {}).get("source_type") == "knowledge_item"
|
|
]
|
|
published = {
|
|
item.id: item
|
|
for item in KnowledgeItem.objects.filter(
|
|
id__in=[item_id for item_id in item_ids if item_id],
|
|
status="published",
|
|
knowledge_base__enabled=True,
|
|
)
|
|
}
|
|
context = []
|
|
seen = set()
|
|
for result in retrieved:
|
|
item_id = result.get("metadata", {}).get("item_id")
|
|
item = published.get(item_id)
|
|
if item is None or item.id in seen:
|
|
continue
|
|
seen.add(item.id)
|
|
context.append(
|
|
{
|
|
"knowledge_item_id": item.id,
|
|
"title": item.title,
|
|
"applicable_scope": item.applicable_scope,
|
|
"root_cause": item.root_cause,
|
|
"troubleshooting_steps": item.troubleshooting_steps,
|
|
"solution": item.solution,
|
|
"risk_note": item.risk_note,
|
|
"retrieval_score": result.get("score", 0),
|
|
}
|
|
)
|
|
if len(context) >= limit:
|
|
break
|
|
return context
|
|
|
|
|
|
def audit_draft(draft: TicketDraft, action: str, result: str = "success") -> None:
|
|
OperationAuditLog.objects.create(
|
|
user=draft.created_by,
|
|
module="tickets",
|
|
action=action,
|
|
target_type="ticket_draft",
|
|
target_id=str(draft.public_id),
|
|
request_snapshot={
|
|
"status": draft.status,
|
|
"revision": draft.revision,
|
|
"guided_rounds": draft.guided_rounds,
|
|
"material_count": draft.materials.count(),
|
|
"result": result,
|
|
},
|
|
result=result,
|
|
)
|
|
|
|
|
|
def get_ticket_intake_agent() -> AgentDefinition | None:
|
|
return (
|
|
AgentDefinition.objects.select_related("active_version__model_deployment__provider")
|
|
.filter(code="ticket-intake", active_version__status="published")
|
|
.first()
|
|
)
|
|
|
|
|
|
def _effective_step_deployments(version: AgentVersion) -> list[ModelDeployment]:
|
|
return [
|
|
step.model_deployment or version.model_deployment
|
|
for step in version.steps.select_related(
|
|
"model_deployment__provider",
|
|
"agent_version__model_deployment__provider",
|
|
)
|
|
]
|
|
|
|
|
|
def draft_availability() -> dict:
|
|
material_limits = {
|
|
"max_file_size": settings.TICKET_MATERIAL_MAX_FILE_BYTES,
|
|
"max_files": settings.TICKET_MATERIAL_MAX_FILES,
|
|
"max_total_size": settings.TICKET_MATERIAL_MAX_TOTAL_BYTES,
|
|
"supported_extensions": list(SUPPORTED_EXTENSIONS),
|
|
}
|
|
definition = get_ticket_intake_agent()
|
|
if definition is None or definition.active_version is None:
|
|
return {
|
|
"available": False,
|
|
"reason": "尚未发布建单 Agent",
|
|
"vision_available": False,
|
|
"vision_reason": "尚未发布建单 Agent",
|
|
**material_limits,
|
|
}
|
|
deployments = _effective_step_deployments(definition.active_version)
|
|
available = bool(
|
|
deployments
|
|
and all(deployment.enabled and deployment.provider.enabled for deployment in deployments)
|
|
)
|
|
vision_deployments = [
|
|
deployment for deployment in deployments if deployment.capability == "vision_chat"
|
|
]
|
|
vision_available = bool(
|
|
available
|
|
and vision_deployments
|
|
and all(deployment.provider.image_egress_approved for deployment in vision_deployments)
|
|
)
|
|
if not available:
|
|
reason = "建单 Agent 的模型配置未启用"
|
|
else:
|
|
reason = ""
|
|
if not vision_deployments:
|
|
vision_reason = "当前建单模型不支持图片理解"
|
|
elif not all(
|
|
deployment.provider.image_egress_approved for deployment in vision_deployments
|
|
):
|
|
vision_reason = "管理员尚未授权图片发送至模型渠道"
|
|
elif not available:
|
|
vision_reason = reason
|
|
else:
|
|
vision_reason = ""
|
|
return {
|
|
"available": available,
|
|
"reason": reason,
|
|
"vision_available": vision_available,
|
|
"vision_reason": vision_reason,
|
|
**material_limits,
|
|
}
|
|
|
|
|
|
def assert_revision(draft: TicketDraft, expected_revision: int) -> None:
|
|
if draft.revision != expected_revision:
|
|
raise TicketDraftError(409, "草稿已在其他位置更新，请刷新后重试")
|
|
|
|
|
|
def serialize_material(material: TicketDraftMaterial) -> dict:
|
|
return {
|
|
"id": str(material.public_id),
|
|
"file_name": material.file_name,
|
|
"material_type": material.material_type,
|
|
"extension": material.extension,
|
|
"claimed_mime_type": material.claimed_mime_type,
|
|
"mime_type": material.mime_type,
|
|
"file_size": material.file_size,
|
|
"status": material.status,
|
|
"scan_status": material.scan_status,
|
|
"scan_result": material.scan_result,
|
|
"parse_status": material.parse_status,
|
|
"parse_error": material.parse_error,
|
|
"parsed_text_length": len(material.parsed_text),
|
|
}
|
|
|
|
|
|
serialize_image = serialize_material
|
|
|
|
|
|
def serialize_agent_progress(draft: TicketDraft) -> dict:
|
|
run = draft.latest_agent_run
|
|
if run is None:
|
|
return {
|
|
"stage": "idle",
|
|
"message": "等待开始分析",
|
|
"current_step": "",
|
|
"total_steps": 0,
|
|
"retry_count": 0,
|
|
"elapsed_ms": 0,
|
|
"slow": False,
|
|
}
|
|
started_at = run.started_at or run.created_at
|
|
finished_at = run.finished_at or timezone.now()
|
|
elapsed_ms = max(int((finished_at - started_at).total_seconds() * 1000), 0)
|
|
active = run.status in {"queued", "running"}
|
|
slow_threshold_ms = settings.AI_SLOW_RUN_THRESHOLD_SECONDS * 1000
|
|
return {
|
|
"stage": run.progress_stage,
|
|
"message": run.progress_message or "任务已进入处理队列",
|
|
"current_step": run.current_step,
|
|
"total_steps": run.total_steps,
|
|
"retry_count": run.retry_count,
|
|
"elapsed_ms": elapsed_ms,
|
|
"slow": active and elapsed_ms >= slow_threshold_ms,
|
|
}
|
|
|
|
|
|
def serialize_timeline_item(item: TicketMessageTimelineItem) -> dict:
|
|
return {
|
|
"sequence": item.sequence,
|
|
"speaker": item.speaker,
|
|
"role": item.role,
|
|
"content": item.content,
|
|
"occurred_at": item.occurred_at.isoformat() if item.occurred_at else "",
|
|
"occurred_at_raw": item.occurred_at_raw,
|
|
"timezone": item.timezone,
|
|
"source_ref": item.source_ref,
|
|
"confidence": float(item.confidence) if item.confidence is not None else None,
|
|
"conflict": item.conflict,
|
|
}
|
|
|
|
|
|
def serialize_draft(draft: TicketDraft, *, ticket_serializer=None) -> dict:
|
|
confirmed = None
|
|
if draft.confirmed_ticket_id and ticket_serializer:
|
|
confirmed = ticket_serializer(draft.confirmed_ticket)
|
|
materials = [serialize_material(material) for material in draft.materials.all()]
|
|
timeline_items = list(draft.timeline_items.all())
|
|
normalized_timeline = (
|
|
[serialize_timeline_item(item) for item in timeline_items]
|
|
if timeline_items
|
|
else draft.message_timeline
|
|
)
|
|
return {
|
|
"public_id": str(draft.public_id),
|
|
"status": draft.status,
|
|
"revision": draft.revision,
|
|
"source_text": draft.source_text,
|
|
"problem_valid": draft.problem_valid,
|
|
"invalid_reason": draft.invalid_reason,
|
|
"fields": draft.current_fields,
|
|
"last_ai_fields": draft.last_ai_fields,
|
|
"field_evidence": draft.field_evidence,
|
|
"message_timeline": normalized_timeline,
|
|
"missing_fields": draft.missing_fields,
|
|
"questions": draft.questions,
|
|
"guided_rounds": draft.guided_rounds,
|
|
"agent_run_public_id": str(draft.latest_agent_run.public_id)
|
|
if draft.latest_agent_run_id
|
|
else None,
|
|
"agent_progress": serialize_agent_progress(draft),
|
|
"materials": materials,
|
|
"images": [item for item in materials if item["material_type"] == "image"],
|
|
"messages": [
|
|
{
|
|
"role": message.role,
|
|
"content": message.content,
|
|
"round_number": message.round_number,
|
|
"created_at": message.created_at,
|
|
}
|
|
for message in draft.messages.all()
|
|
],
|
|
"decision": draft.decision,
|
|
"error_code": draft.error_code,
|
|
"error_message": draft.error_message,
|
|
"created_ticket": confirmed,
|
|
"confirmed_ticket": confirmed,
|
|
"created_at": draft.created_at,
|
|
"updated_at": draft.updated_at,
|
|
"expires_at": draft.expires_at,
|
|
}
|
|
|
|
|
|
def create_agent_run_for_draft(draft: TicketDraft) -> AgentRun:
|
|
definition = get_ticket_intake_agent()
|
|
if definition is None or definition.active_version is None:
|
|
raise TicketDraftError(422, "尚未发布可用的建单 Agent")
|
|
version = definition.active_version
|
|
ready_materials = list(draft.materials.filter(scan_status="clean"))
|
|
image_refs = [
|
|
{
|
|
"source_ref": f"material:{material.public_id}",
|
|
"file_name": material.file_name,
|
|
"object_path": material.storage_path,
|
|
"mime_type": material.mime_type,
|
|
}
|
|
for material in ready_materials
|
|
if material.material_type == "image"
|
|
]
|
|
material_texts = [
|
|
{
|
|
"source_ref": f"material:{material.public_id}",
|
|
"file_name": material.file_name,
|
|
"mime_type": material.mime_type,
|
|
"text": material.parsed_text,
|
|
}
|
|
for material in ready_materials
|
|
if material.parse_status == "parsed" and material.parsed_text
|
|
]
|
|
material_refs = [
|
|
{
|
|
"source_ref": f"material:{material.public_id}",
|
|
"file_name": material.file_name,
|
|
"material_type": material.material_type,
|
|
"mime_type": material.mime_type,
|
|
"sha256": material.sha256,
|
|
}
|
|
for material in ready_materials
|
|
]
|
|
messages = [
|
|
{"role": item.role, "content": item.content, "round": item.round_number}
|
|
for item in draft.messages.all()
|
|
]
|
|
retrieval_query = " ".join(
|
|
[
|
|
draft.source_text,
|
|
*[item["content"] for item in messages if item["role"] == "user"],
|
|
*[item["text"] for item in material_texts],
|
|
]
|
|
).strip()
|
|
complete_ticket_intake_failure_work_item(draft, actor=draft.created_by)
|
|
run = AgentRun.objects.create(
|
|
definition=definition,
|
|
agent_version=version,
|
|
sandbox=False,
|
|
input_payload={
|
|
"draft_public_id": str(draft.public_id),
|
|
"source_text": draft.source_text,
|
|
"current_fields": draft.current_fields,
|
|
"messages": messages,
|
|
"image_refs": image_refs,
|
|
"material_refs": material_refs,
|
|
"material_texts": material_texts,
|
|
"knowledge_context": _build_knowledge_context(retrieval_query),
|
|
},
|
|
config_snapshot=build_config_snapshot(version),
|
|
total_steps=version.steps.count(),
|
|
created_by=draft.created_by,
|
|
)
|
|
append_run_event(run, "queued", {"message": "受理任务已进入处理队列"})
|
|
draft.latest_agent_run = run
|
|
draft.status = "analyzing"
|
|
draft.problem_valid = None
|
|
draft.invalid_reason = ""
|
|
draft.revision += 1
|
|
draft.error_code = ""
|
|
draft.error_message = ""
|
|
draft.expires_at = timezone.now() + timedelta(hours=settings.TICKET_DRAFT_RETENTION_HOURS)
|
|
draft.save()
|
|
audit_draft(draft, "draft_analysis_started")
|
|
return run
|
|
|
|
|
|
def _image_parts(draft: TicketDraft) -> list[dict]:
|
|
parts = []
|
|
for image in draft.materials.filter(material_type="image", scan_status="clean"):
|
|
encoded = base64.b64encode(get_object(image.storage_path)).decode("ascii")
|
|
parts.append(
|
|
{
|
|
"type": "image_url",
|
|
"image_url": {"url": f"data:{image.mime_type};base64,{encoded}"},
|
|
}
|
|
)
|
|
return parts
|
|
|
|
|
|
def _normalize_field_evidence(raw_evidence) -> tuple[dict, dict]:
|
|
if not isinstance(raw_evidence, dict):
|
|
return {}, {}
|
|
normalized = {}
|
|
confidence_by_field = {}
|
|
for code, raw_item in raw_evidence.items():
|
|
if code not in ALLOWED_FIELD_CODES:
|
|
continue
|
|
if isinstance(raw_item, str):
|
|
item = {"excerpt": raw_item.strip()} if raw_item.strip() else {}
|
|
elif isinstance(raw_item, dict):
|
|
item = {
|
|
"excerpt": str(raw_item.get("excerpt") or "").strip(),
|
|
"source_refs": [
|
|
str(value).strip()
|
|
for value in raw_item.get("source_refs", [])
|
|
if str(value).strip()
|
|
]
|
|
if isinstance(raw_item.get("source_refs"), list)
|
|
else [],
|
|
"location": str(raw_item.get("location") or "").strip(),
|
|
"raw_value": str(raw_item.get("raw_value") or "").strip(),
|
|
"timezone": str(raw_item.get("timezone") or "").strip(),
|
|
"conflicts": [
|
|
str(value).strip()
|
|
for value in raw_item.get("conflicts", [])
|
|
if str(value).strip()
|
|
]
|
|
if isinstance(raw_item.get("conflicts"), list)
|
|
else [],
|
|
}
|
|
confidence = raw_item.get("confidence")
|
|
if isinstance(confidence, (int, float)) and not isinstance(confidence, bool):
|
|
confidence = max(0.0, min(float(confidence), 1.0))
|
|
item["confidence"] = confidence
|
|
confidence_by_field[code] = confidence
|
|
else:
|
|
continue
|
|
normalized[code] = item
|
|
return normalized, confidence_by_field
|
|
|
|
|
|
def _normalize_message_timeline(raw_timeline) -> list[dict]:
|
|
if not isinstance(raw_timeline, list):
|
|
return []
|
|
timeline = []
|
|
for position, raw_item in enumerate(raw_timeline[:200], start=1):
|
|
if not isinstance(raw_item, dict):
|
|
continue
|
|
content = str(raw_item.get("content") or "").strip()
|
|
if not content:
|
|
continue
|
|
role = str(raw_item.get("role") or "unknown").strip()
|
|
if role not in {"customer", "support", "unknown"}:
|
|
role = "unknown"
|
|
confidence = raw_item.get("confidence")
|
|
if not isinstance(confidence, (int, float)) or isinstance(confidence, bool):
|
|
confidence = None
|
|
else:
|
|
confidence = max(0.0, min(float(confidence), 1.0))
|
|
timeline.append(
|
|
{
|
|
"sequence": position,
|
|
"speaker": str(raw_item.get("speaker") or "").strip(),
|
|
"role": role,
|
|
"content": content,
|
|
"occurred_at": str(raw_item.get("occurred_at") or "").strip(),
|
|
"occurred_at_raw": str(raw_item.get("occurred_at_raw") or "").strip(),
|
|
"timezone": str(raw_item.get("timezone") or "").strip(),
|
|
"source_ref": str(raw_item.get("source_ref") or "").strip(),
|
|
"confidence": confidence,
|
|
"conflict": str(raw_item.get("conflict") or "").strip(),
|
|
}
|
|
)
|
|
return timeline
|
|
|
|
|
|
@transaction.atomic
|
|
def _replace_message_timeline(draft: TicketDraft, timeline: list[dict]) -> None:
|
|
draft = TicketDraft.objects.select_for_update().get(id=draft.id)
|
|
materials = {
|
|
f"material:{material.public_id}": material
|
|
for material in draft.materials.all()
|
|
}
|
|
draft.timeline_items.all().delete()
|
|
items = []
|
|
for item in timeline:
|
|
occurred_at_raw = item.get("occurred_at", "")
|
|
occurred_at = parse_datetime(occurred_at_raw) if occurred_at_raw else None
|
|
if occurred_at is not None and timezone.is_naive(occurred_at):
|
|
occurred_at = None
|
|
source_ref = item.get("source_ref", "")
|
|
items.append(
|
|
TicketMessageTimelineItem(
|
|
draft=draft,
|
|
ticket=draft.confirmed_ticket,
|
|
source_material=materials.get(source_ref),
|
|
sequence=item["sequence"],
|
|
speaker=item.get("speaker", ""),
|
|
role=item.get("role", "unknown"),
|
|
content=item["content"],
|
|
occurred_at=occurred_at,
|
|
occurred_at_raw=item.get("occurred_at_raw", "") or occurred_at_raw,
|
|
timezone=item.get("timezone", ""),
|
|
source_ref=source_ref,
|
|
confidence=item.get("confidence"),
|
|
conflict=item.get("conflict", ""),
|
|
)
|
|
)
|
|
TicketMessageTimelineItem.objects.bulk_create(items)
|
|
|
|
|
|
def _mark_analysis_failed(
|
|
draft: TicketDraft,
|
|
*,
|
|
error_code: str,
|
|
error_message: str,
|
|
run: AgentRun | None = None,
|
|
) -> None:
|
|
draft.status = "failed"
|
|
draft.error_code = error_code
|
|
draft.error_message = error_message
|
|
draft.revision += 1
|
|
draft.save()
|
|
if run is not None:
|
|
run.status = "failed"
|
|
run.progress_stage = "failed"
|
|
run.progress_message = error_message[:160]
|
|
run.error_code = error_code
|
|
run.error_message = error_message
|
|
run.finished_at = run.finished_at or timezone.now()
|
|
run.save(
|
|
update_fields=[
|
|
"status",
|
|
"progress_stage",
|
|
"progress_message",
|
|
"error_code",
|
|
"error_message",
|
|
"finished_at",
|
|
]
|
|
)
|
|
append_run_event(
|
|
run,
|
|
"failed",
|
|
{"error_code": error_code, "error_message": error_message},
|
|
)
|
|
sync_ticket_intake_failure_work_item(draft, run=run, actor=draft.created_by)
|
|
audit_draft(draft, "draft_analysis_failed", "failed")
|
|
|
|
|
|
def _mark_analysis_cancelled(draft: TicketDraft, run: AgentRun) -> None:
|
|
changed = (
|
|
draft.status != "failed"
|
|
or draft.error_code != "analysis_cancelled"
|
|
or draft.error_message != "智能受理已取消，原始材料和已填字段均已保留"
|
|
)
|
|
draft.status = "failed"
|
|
draft.error_code = "analysis_cancelled"
|
|
draft.error_message = "智能受理已取消，原始材料和已填字段均已保留"
|
|
if changed:
|
|
draft.revision += 1
|
|
draft.save()
|
|
if run.status != "cancelled":
|
|
run.status = "cancelled"
|
|
run.progress_stage = "cancelled"
|
|
run.progress_message = "运行已取消"
|
|
run.finished_at = run.finished_at or timezone.now()
|
|
run.save(
|
|
update_fields=[
|
|
"status",
|
|
"progress_stage",
|
|
"progress_message",
|
|
"finished_at",
|
|
]
|
|
)
|
|
append_run_event(run, "cancelled", {"message": "运行已取消"})
|
|
sync_ticket_intake_failure_work_item(draft, run=run, actor=draft.created_by)
|
|
audit_draft(draft, "draft_analysis_cancelled", "cancelled")
|
|
|
|
|
|
def _copy_materials_to_ticket(draft: TicketDraft, ticket, user) -> None:
|
|
"""复制材料并创建附件；任一对象失败时回收本次已复制对象。"""
|
|
|
|
copied_paths = []
|
|
try:
|
|
for material in draft.materials.all():
|
|
source_path = material.storage_path
|
|
target_path = f"tickets/{ticket.id}/{material.public_id}-{material.file_name}"
|
|
copy_object(source_path, target_path)
|
|
copied_paths.append(target_path)
|
|
attachment = TicketAttachment.objects.create(
|
|
ticket=ticket,
|
|
file_name=material.file_name,
|
|
file_type=material.material_type,
|
|
mime_type=material.mime_type,
|
|
file_size=material.file_size,
|
|
storage_path=target_path,
|
|
sha256=material.sha256,
|
|
scan_status=material.scan_status,
|
|
scan_result=material.scan_result,
|
|
parse_status=material.parse_status,
|
|
parse_error=material.parse_error,
|
|
parsed_text=material.parsed_text,
|
|
created_by=user,
|
|
)
|
|
material.status = "attached"
|
|
material.confirmed_attachment = attachment
|
|
material.storage_path = target_path
|
|
material.save(update_fields=["status", "confirmed_attachment", "storage_path"])
|
|
# 临时对象只能在数据库提交后删除，回滚时仍要保留原始材料供重试或人工接管。
|
|
transaction.on_commit(lambda path=source_path: delete_object(path), robust=True)
|
|
except Exception:
|
|
for copied_path in copied_paths:
|
|
try:
|
|
delete_object(copied_path)
|
|
except Exception:
|
|
pass
|
|
raise
|
|
|
|
|
|
@transaction.atomic
|
|
def _auto_create_ticket(
|
|
draft_id: int,
|
|
run: AgentRun,
|
|
*,
|
|
fields: dict,
|
|
field_evidence: dict,
|
|
confidence_by_field: dict,
|
|
human_field_names: set[str],
|
|
) -> TicketDraft:
|
|
"""在行锁内幂等创建并关联唯一正式工单。"""
|
|
|
|
# Agent/Celery 重试可能并发进入；锁定受理记录后再判断是否已经完成建单。
|
|
draft = (
|
|
TicketDraft.objects.select_for_update(of=("self",))
|
|
.select_related("created_by", "confirmed_ticket")
|
|
.prefetch_related("materials")
|
|
.get(id=draft_id)
|
|
)
|
|
if draft.confirmed_ticket_id:
|
|
if draft.status not in {"ticket_created", "confirmed"}:
|
|
draft.status = "ticket_created"
|
|
draft.revision += 1
|
|
draft.save(update_fields=["status", "revision", "updated_at"])
|
|
TicketMessageTimelineItem.objects.filter(draft=draft, ticket__isnull=True).update(
|
|
ticket_id=draft.confirmed_ticket_id
|
|
)
|
|
complete_ticket_intake_failure_work_item(draft, actor=draft.created_by)
|
|
return draft
|
|
|
|
ticket, service_missing_fields = create_ticket_from_intake(
|
|
fields,
|
|
draft.created_by,
|
|
agent_run_id=run.id,
|
|
evidence_by_field=field_evidence,
|
|
confidence_by_field=confidence_by_field,
|
|
human_field_names=human_field_names,
|
|
reported_missing_fields=draft.missing_fields,
|
|
)
|
|
_copy_materials_to_ticket(draft, ticket, draft.created_by)
|
|
|
|
combined_missing_fields = sorted(
|
|
set(draft.missing_fields) | set(service_missing_fields)
|
|
)
|
|
draft.confirmed_ticket = ticket
|
|
draft.missing_fields = combined_missing_fields
|
|
draft.status = "ticket_created"
|
|
draft.decision = "auto_created"
|
|
draft.confirmed_at = timezone.now()
|
|
draft.revision += 1
|
|
draft.save()
|
|
TicketMessageTimelineItem.objects.filter(draft=draft).update(ticket=ticket)
|
|
sync_ticket_missing_info_work_item(
|
|
ticket,
|
|
combined_missing_fields,
|
|
questions=draft.questions,
|
|
draft_public_id=str(draft.public_id),
|
|
actor=draft.created_by,
|
|
)
|
|
TicketEvent.objects.create(
|
|
ticket=ticket,
|
|
event_type="ai_intake_created",
|
|
to_value={
|
|
"draft_public_id": str(draft.public_id),
|
|
"agent_run_public_id": str(run.public_id),
|
|
"missing_fields": combined_missing_fields,
|
|
},
|
|
operator=draft.created_by,
|
|
source=TicketActorSource.AGENT,
|
|
agent_run_id=run.id,
|
|
)
|
|
audit_draft(draft, "draft_auto_created")
|
|
complete_ticket_intake_failure_work_item(draft, actor=draft.created_by)
|
|
return draft
|
|
|
|
|
|
def execute_draft_analysis(draft_id: int, run_id: int) -> None:
|
|
"""执行一次受理分析，并把成功、补充信息、取消和失败统一落回受理状态。"""
|
|
|
|
draft = (
|
|
TicketDraft.objects.select_related("created_by")
|
|
.prefetch_related("materials")
|
|
.get(id=draft_id)
|
|
)
|
|
run = AgentRun.objects.select_related("agent_version__model_deployment__provider").get(
|
|
id=run_id
|
|
)
|
|
if run.cancellation_requested_at or run.status == "cancelled":
|
|
_mark_analysis_cancelled(draft, run)
|
|
return
|
|
if draft.confirmed_ticket_id:
|
|
if run.status in {"queued", "running"}:
|
|
run.status = "succeeded"
|
|
run.progress_stage = "completed"
|
|
run.progress_message = "工单已创建，已跳过重复执行"
|
|
run.finished_at = timezone.now()
|
|
run.save(
|
|
update_fields=[
|
|
"status",
|
|
"progress_stage",
|
|
"progress_message",
|
|
"finished_at",
|
|
]
|
|
)
|
|
append_run_event(run, "completed", {"ticket_id": draft.confirmed_ticket_id})
|
|
return
|
|
append_run_event(run, "parsing", {"message": "正在解析受理材料"})
|
|
image_parts = []
|
|
if draft.materials.filter(material_type="image", scan_status="clean").exists():
|
|
vision_deployments = [
|
|
deployment
|
|
for deployment in _effective_step_deployments(run.agent_version)
|
|
if deployment.capability == "vision_chat"
|
|
]
|
|
if not vision_deployments or not all(
|
|
deployment.enabled
|
|
and deployment.provider.enabled
|
|
and deployment.provider.image_egress_approved
|
|
for deployment in vision_deployments
|
|
):
|
|
_mark_analysis_failed(
|
|
draft,
|
|
error_code="vision_not_allowed",
|
|
error_message="当前模型或渠道不允许图片输入",
|
|
run=run,
|
|
)
|
|
return
|
|
image_parts = _image_parts(draft)
|
|
append_run_event(run, "extracting", {"message": "正在提取问题与工单字段"})
|
|
execute_agent_run(run.id, image_parts=image_parts)
|
|
run.refresh_from_db()
|
|
draft.refresh_from_db()
|
|
if run.status == "cancelled":
|
|
_mark_analysis_cancelled(draft, run)
|
|
return
|
|
if run.status != "succeeded" or not isinstance(run.final_output, dict):
|
|
_mark_analysis_failed(
|
|
draft,
|
|
error_code=run.error_code or "analysis_failed",
|
|
error_message=run.error_message or "AI 分析失败，请重试或转为普通表单",
|
|
run=run,
|
|
)
|
|
return
|
|
fields = run.final_output.get("fields")
|
|
missing_fields = run.final_output.get("missing_fields")
|
|
questions = run.final_output.get("questions")
|
|
if (
|
|
not isinstance(fields, dict)
|
|
or not isinstance(missing_fields, list)
|
|
or not isinstance(questions, list)
|
|
):
|
|
_mark_analysis_failed(
|
|
draft,
|
|
error_code="invalid_artifact",
|
|
error_message="AI 产物结构不完整",
|
|
run=run,
|
|
)
|
|
return
|
|
fields = {code: value for code, value in fields.items() if code in ALLOWED_FIELD_CODES}
|
|
fields = {
|
|
code: value.replace("\r", " ").replace("\n", " ").strip()
|
|
if isinstance(value, str)
|
|
else value
|
|
for code, value in fields.items()
|
|
}
|
|
fields["tags"] = normalize_tags(fields.get("tags"))
|
|
for code in BUSINESS_TIME_FIELDS:
|
|
raw_value = fields.get(code)
|
|
normalized_datetime = normalize_business_datetime(raw_value)
|
|
fields[code] = normalized_datetime.isoformat() if normalized_datetime else ""
|
|
if raw_value and normalized_datetime is None and code not in missing_fields:
|
|
missing_fields.append(code)
|
|
missing_fields = [str(item) for item in missing_fields if str(item) in ALLOWED_FIELD_CODES]
|
|
source_corpus = " ".join(
|
|
[
|
|
draft.source_text,
|
|
*draft.messages.values_list("content", flat=True),
|
|
*draft.materials.filter(
|
|
scan_status="clean", parse_status="parsed"
|
|
).values_list("parsed_text", flat=True),
|
|
]
|
|
)
|
|
if not draft.materials.filter(material_type="image", scan_status="clean").exists():
|
|
for code in PROVENANCE_FIELD_CODES:
|
|
value = fields.get(code)
|
|
if isinstance(value, str) and value and value not in source_corpus:
|
|
fields[code] = ""
|
|
if code not in missing_fields:
|
|
missing_fields.append(code)
|
|
|
|
# A guided re-analysis must not silently overwrite fields that a person changed.
|
|
manual_fields = {
|
|
code: value
|
|
for code, value in draft.current_fields.items()
|
|
if code in ALLOWED_FIELD_CODES and draft.last_ai_fields.get(code) != value
|
|
}
|
|
fields.update(manual_fields)
|
|
missing_fields = [code for code in missing_fields if not fields.get(code)]
|
|
questions = [str(item).replace("\r", " ").replace("\n", " ").strip() for item in questions]
|
|
field_evidence, confidence_by_field = _normalize_field_evidence(
|
|
run.final_output.get("field_evidence")
|
|
)
|
|
message_timeline = _normalize_message_timeline(run.final_output.get("message_timeline"))
|
|
_replace_message_timeline(draft, message_timeline)
|
|
problem_valid_value = run.final_output.get("problem_valid")
|
|
problem_valid = (
|
|
problem_valid_value
|
|
if isinstance(problem_valid_value, bool)
|
|
else bool(str(fields.get("description") or "").strip())
|
|
)
|
|
invalid_reason = str(run.final_output.get("invalid_reason") or "").strip()
|
|
if not str(fields.get("description") or "").strip():
|
|
problem_valid = False
|
|
invalid_reason = invalid_reason or "尚未形成有效问题描述"
|
|
artifact = AgentArtifact.objects.create(
|
|
run=run,
|
|
artifact_type="ticket_draft",
|
|
schema_version=2,
|
|
payload={
|
|
"draft_public_id": str(draft.public_id),
|
|
"problem_valid": problem_valid,
|
|
"invalid_reason": invalid_reason,
|
|
"fields": fields,
|
|
"field_evidence": field_evidence,
|
|
"message_timeline": message_timeline,
|
|
"missing_fields": missing_fields,
|
|
"questions": questions,
|
|
},
|
|
created_by=draft.created_by,
|
|
)
|
|
draft.current_fields = fields
|
|
draft.last_ai_fields = fields
|
|
draft.problem_valid = problem_valid
|
|
draft.invalid_reason = invalid_reason
|
|
draft.field_evidence = field_evidence
|
|
draft.message_timeline = message_timeline
|
|
draft.missing_fields = missing_fields
|
|
draft.questions = questions
|
|
draft.latest_artifact = artifact
|
|
draft.status = "needs_input"
|
|
draft.error_code = ""
|
|
draft.error_message = ""
|
|
draft.revision += 1
|
|
draft.save()
|
|
audit_draft(draft, "draft_analysis_succeeded")
|
|
complete_ticket_intake_failure_work_item(draft, actor=draft.created_by)
|
|
if not problem_valid:
|
|
append_run_event(
|
|
run,
|
|
"needs_input",
|
|
{"invalid_reason": invalid_reason, "questions": questions},
|
|
)
|
|
audit_draft(draft, "draft_needs_input")
|
|
return
|
|
try:
|
|
append_run_event(run, "creating_ticket", {"message": "正在创建正式工单"})
|
|
_auto_create_ticket(
|
|
draft.id,
|
|
run,
|
|
fields=fields,
|
|
field_evidence=field_evidence,
|
|
confidence_by_field=confidence_by_field,
|
|
human_field_names=set(manual_fields),
|
|
)
|
|
draft.refresh_from_db(fields=["confirmed_ticket"])
|
|
append_run_event(
|
|
run,
|
|
"completed",
|
|
{"ticket_id": draft.confirmed_ticket_id, "message": "正式工单已创建"},
|
|
)
|
|
except Exception:
|
|
draft.refresh_from_db()
|
|
_mark_analysis_failed(
|
|
draft,
|
|
error_code="ticket_creation_failed",
|
|
error_message="自动建单未完成，原始材料已保留，请重试或转为人工建单",
|
|
run=run,
|
|
)
|
|
|
|
|
|
@transaction.atomic
|
|
def cancel_draft_analysis(
|
|
draft_public_id,
|
|
expected_revision: int,
|
|
user,
|
|
) -> TicketDraft:
|
|
draft = (
|
|
TicketDraft.objects.select_for_update(of=("self",))
|
|
.select_related("latest_agent_run", "created_by")
|
|
.get(public_id=draft_public_id, created_by=user)
|
|
)
|
|
assert_revision(draft, expected_revision)
|
|
if draft.status != "analyzing" or draft.latest_agent_run_id is None:
|
|
raise TicketDraftError(400, "当前受理记录没有可取消的运行")
|
|
|
|
run = AgentRun.objects.select_for_update().get(id=draft.latest_agent_run_id)
|
|
if run.status not in {"queued", "running"}:
|
|
if run.status == "cancelled":
|
|
_mark_analysis_cancelled(draft, run)
|
|
return draft
|
|
raise TicketDraftError(400, "当前运行已经结束")
|
|
|
|
run.cancellation_requested_at = timezone.now()
|
|
run.progress_stage = "cancelling"
|
|
run.progress_message = "正在取消智能受理"
|
|
run_update_fields = [
|
|
"cancellation_requested_at",
|
|
"progress_stage",
|
|
"progress_message",
|
|
]
|
|
if run.status == "queued":
|
|
run.status = "cancelled"
|
|
run.progress_stage = "cancelled"
|
|
run.progress_message = "运行已取消"
|
|
run.finished_at = timezone.now()
|
|
run_update_fields.extend(["status", "finished_at"])
|
|
run.save(update_fields=run_update_fields)
|
|
if run.status == "cancelled":
|
|
append_run_event(run, "cancelled", {"message": "运行已取消"})
|
|
else:
|
|
append_run_event(
|
|
run,
|
|
"cancellation_requested",
|
|
{"message": "已请求取消，当前模型调用结束后停止"},
|
|
)
|
|
|
|
_mark_analysis_cancelled(draft, run)
|
|
if run.task_id:
|
|
task_id = run.task_id
|
|
transaction.on_commit(lambda: AsyncResult(task_id).revoke(terminate=False))
|
|
return draft
|
|
|
|
|
|
@transaction.atomic
|
|
def confirm_draft(draft_public_id, expected_revision: int, user) -> TicketDraft:
|
|
draft = (
|
|
TicketDraft.objects.select_for_update()
|
|
.select_related("created_by")
|
|
.prefetch_related("materials")
|
|
.get(public_id=draft_public_id, created_by=user)
|
|
)
|
|
if draft.confirmed_ticket_id:
|
|
return draft
|
|
assert_revision(draft, expected_revision)
|
|
if draft.status not in {"needs_input", "ready", "failed"}:
|
|
raise TicketDraftError(400, "当前受理记录不能转为人工建单")
|
|
try:
|
|
ticket = create_ticket_from_fields(draft.current_fields, user)
|
|
except TicketDataError as error:
|
|
raise TicketDraftError(400, str(error)) from error
|
|
decision = "accepted" if draft.current_fields == draft.last_ai_fields else "modified"
|
|
_copy_materials_to_ticket(draft, ticket, user)
|
|
draft.confirmed_ticket = ticket
|
|
draft.status = "ticket_created"
|
|
draft.decision = decision
|
|
draft.confirmed_at = timezone.now()
|
|
draft.revision += 1
|
|
draft.save()
|
|
TicketMessageTimelineItem.objects.filter(draft=draft).update(ticket=ticket)
|
|
TicketEvent.objects.create(
|
|
ticket=ticket,
|
|
event_type="ai_draft_confirmed",
|
|
to_value={
|
|
"draft_public_id": str(draft.public_id),
|
|
"decision": decision,
|
|
"agent_run_public_id": str(draft.latest_agent_run.public_id)
|
|
if draft.latest_agent_run_id
|
|
else None,
|
|
},
|
|
operator=user,
|
|
)
|
|
audit_draft(draft, "draft_confirmed")
|
|
complete_ticket_intake_failure_work_item(draft, actor=user)
|
|
return draft
|
|
|
|
|
|
@transaction.atomic
|
|
def reject_draft(draft_public_id, expected_revision: int, user) -> TicketDraft:
|
|
draft = TicketDraft.objects.select_for_update().get(public_id=draft_public_id, created_by=user)
|
|
assert_revision(draft, expected_revision)
|
|
if draft.status in FINAL_DRAFT_STATUSES:
|
|
if draft.status == "rejected":
|
|
return draft
|
|
raise TicketDraftError(400, "草稿已经结束")
|
|
draft.status = "rejected"
|
|
draft.decision = "rejected"
|
|
draft.revision += 1
|
|
draft.expires_at = timezone.now() + timedelta(hours=settings.TICKET_DRAFT_RETENTION_HOURS)
|
|
draft.save()
|
|
audit_draft(draft, "draft_rejected")
|
|
complete_ticket_intake_failure_work_item(draft, actor=user, cancelled=True)
|
|
return draft
|
|
|
|
|
|
def add_answer(draft: TicketDraft, answer: str, question: str) -> None:
|
|
if draft.guided_rounds >= 5:
|
|
raise TicketDraftError(400, "逐问模式最多进行 5 轮，请手工补齐剩余字段")
|
|
round_number = draft.guided_rounds + 1
|
|
if question.strip():
|
|
TicketDraftMessage.objects.create(
|
|
draft=draft,
|
|
role="assistant",
|
|
content=question.strip(),
|
|
round_number=round_number,
|
|
)
|
|
TicketDraftMessage.objects.create(
|
|
draft=draft,
|
|
role="user",
|
|
content=answer.strip(),
|
|
round_number=round_number,
|
|
)
|
|
draft.guided_rounds = round_number
|
|
draft.save(update_fields=["guided_rounds", "updated_at"])
|