wren
418 lines
17 KiB
Python
418 lines
17 KiB
Python
"""评查服务实现。
|
|
|
|
编排 LeAudit 引擎执行链路：
|
|
文档 → OCR → Extract → Evaluate → Rescue → Persist
|
|
"""
|
|
|
|
from datetime import datetime
|
|
|
|
from fastapi_common.fastapi_common_logger import logger
|
|
from fastapi_common.fastapi_common_sqlalchemy.database import GetAsyncSession
|
|
from fastapi_common.fastapi_common_web.domain.responses import StatusCodeEnum
|
|
from fastapi_common.fastapi_common_web.exception.LeauditException import LeauditException
|
|
from sqlalchemy import select, text
|
|
|
|
from fastapi_modules.fastapi_leaudit.domian.vo.auditVo import (
|
|
AuditArtifactVO,
|
|
AuditFieldResultVO,
|
|
AuditMetricsVO,
|
|
AuditRescueOutcomeVO,
|
|
AuditResultVO,
|
|
AuditRunErrorVO,
|
|
AuditRunVO,
|
|
)
|
|
from fastapi_modules.fastapi_leaudit.leaudit_bridge.fileSourceResolver import FileSourceResolver
|
|
from fastapi_modules.fastapi_leaudit.leaudit_bridge.tasks import dispatch_leaudit_task
|
|
from fastapi_modules.fastapi_leaudit.models import (
|
|
LeauditAuditRun,
|
|
LeauditDocument,
|
|
LeauditDocumentFile,
|
|
)
|
|
from fastapi_modules.fastapi_leaudit.services import IAuditService
|
|
|
|
|
|
class AuditServiceImpl(IAuditService):
|
|
"""评查服务实现。"""
|
|
|
|
async def Run(self, DocumentId: int, RuleType: str | None = None, Force: bool = False) -> AuditRunVO:
|
|
"""触发文档评查。
|
|
|
|
当前阶段同步触发 bridge 执行链，后续再切换为 Celery 异步分发。
|
|
"""
|
|
async with GetAsyncSession() as session:
|
|
logger.info(f"触发评查: documentId={DocumentId}, ruleType={RuleType}")
|
|
document = await session.get(LeauditDocument, DocumentId)
|
|
if not document:
|
|
raise LeauditException(StatusCodeEnum.HTTP_404_NOT_FOUND, "评查文档不存在")
|
|
|
|
fileResult = await session.execute(
|
|
select(LeauditDocumentFile)
|
|
.where(
|
|
LeauditDocumentFile.documentId == DocumentId,
|
|
LeauditDocumentFile.isActive.is_(True),
|
|
)
|
|
.order_by(LeauditDocumentFile.Id.desc())
|
|
.limit(1)
|
|
)
|
|
documentFile = fileResult.scalar_one_or_none()
|
|
if not documentFile:
|
|
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "当前文档没有可执行文件版本")
|
|
|
|
runNoResult = await session.execute(
|
|
select(LeauditAuditRun.runNo)
|
|
.where(LeauditAuditRun.documentId == DocumentId)
|
|
.order_by(LeauditAuditRun.runNo.desc())
|
|
.limit(1)
|
|
)
|
|
latestRunNo = runNoResult.scalar_one_or_none() or 0
|
|
|
|
bindingResult = await session.execute(
|
|
text(
|
|
"""
|
|
SELECT
|
|
rs.id AS rule_set_id,
|
|
rs.current_version_id AS rule_version_id,
|
|
rv.oss_url AS rule_source_oss_url,
|
|
rv.file_sha256 AS rule_source_sha256,
|
|
rv.metadata_type_id AS rule_type_id
|
|
FROM leaudit_rule_type_bindings b
|
|
JOIN leaudit_rule_sets rs ON rs.id = b.rule_set_id
|
|
LEFT JOIN leaudit_rule_versions rv ON rv.id = rs.current_version_id
|
|
WHERE b.doc_type_id = :doc_type_id
|
|
AND b.is_active = true
|
|
AND b.region = :region
|
|
ORDER BY b.priority DESC, b.id DESC
|
|
LIMIT 1
|
|
"""
|
|
),
|
|
{"doc_type_id": document.typeId, "region": document.region},
|
|
)
|
|
binding = bindingResult.mappings().first()
|
|
if not binding or not binding["rule_set_id"] or not binding["rule_version_id"]:
|
|
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "当前文档类型未绑定可用规则版本")
|
|
|
|
run = LeauditAuditRun(
|
|
documentId=DocumentId,
|
|
documentFileId=documentFile.Id,
|
|
runNo=int(latestRunNo) + 1,
|
|
triggerSource="manual" if not Force else "retry",
|
|
status="pending",
|
|
ruleSetId=int(binding["rule_set_id"]),
|
|
ruleVersionId=int(binding["rule_version_id"]),
|
|
ruleTypeId=binding["rule_type_id"],
|
|
ruleSourceOssUrl=binding["rule_source_oss_url"],
|
|
ruleSourceSha256=binding["rule_source_sha256"],
|
|
startedAt=datetime.now(),
|
|
)
|
|
session.add(run)
|
|
await session.flush()
|
|
|
|
document.currentRunId = run.Id
|
|
document.processingStatus = "running"
|
|
await session.commit()
|
|
await session.refresh(run)
|
|
|
|
try:
|
|
Resolver = FileSourceResolver()
|
|
Payload = await Resolver.ResolvePayload(documentFile)
|
|
except Exception as Error:
|
|
raise LeauditException(
|
|
StatusCodeEnum.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
f"读取评查文件失败: {Error}",
|
|
) from Error
|
|
|
|
dispatch_leaudit_task(
|
|
document_id=DocumentId,
|
|
file_content=Payload.fileContent,
|
|
filename=Payload.fileName,
|
|
upload_info={
|
|
"run_id": run.Id,
|
|
"rule_version_id": run.ruleVersionId,
|
|
"rule_source_oss_url": run.ruleSourceOssUrl,
|
|
"source_type": Payload.sourceType,
|
|
"source_path": Payload.sourcePath,
|
|
},
|
|
rules_path=RuleType,
|
|
)
|
|
|
|
await session.refresh(run)
|
|
return AuditRunVO(
|
|
runId=run.Id,
|
|
documentId=run.documentId,
|
|
runNo=run.runNo,
|
|
documentFileId=run.documentFileId,
|
|
status=run.status,
|
|
phase=run.phase,
|
|
resultStatus=run.resultStatus,
|
|
ruleSetId=run.ruleSetId,
|
|
ruleVersionId=run.ruleVersionId,
|
|
ruleTypeId=run.ruleTypeId,
|
|
rescueApplied=run.rescueApplied or False,
|
|
totalScore=float(run.totalScore) if run.totalScore else None,
|
|
passedCount=run.passedCount,
|
|
failedCount=run.failedCount,
|
|
skippedCount=run.skippedCount,
|
|
startedAt=run.startedAt,
|
|
finishedAt=run.finishedAt,
|
|
)
|
|
|
|
async def GetRunStatus(self, RunId: int) -> AuditRunVO:
|
|
"""查询评查运行状态。"""
|
|
async with GetAsyncSession() as session:
|
|
run = await session.get(LeauditAuditRun, RunId)
|
|
if not run:
|
|
raise LeauditException(StatusCodeEnum.HTTP_404_NOT_FOUND, "评查运行记录不存在")
|
|
return AuditRunVO(
|
|
runId=run.Id,
|
|
documentId=run.documentId,
|
|
runNo=run.runNo,
|
|
documentFileId=run.documentFileId,
|
|
status=run.status,
|
|
phase=run.phase,
|
|
resultStatus=run.resultStatus,
|
|
ruleSetId=run.ruleSetId,
|
|
ruleVersionId=run.ruleVersionId,
|
|
ruleTypeId=run.ruleTypeId,
|
|
rescueApplied=run.rescueApplied or False,
|
|
totalScore=float(run.totalScore) if run.totalScore else None,
|
|
passedCount=run.passedCount,
|
|
failedCount=run.failedCount,
|
|
skippedCount=run.skippedCount,
|
|
startedAt=run.startedAt,
|
|
finishedAt=run.finishedAt,
|
|
)
|
|
|
|
async def GetResult(self, RunId: int) -> AuditResultVO:
|
|
"""获取评查结果。"""
|
|
async with GetAsyncSession() as session:
|
|
run = await session.get(LeauditAuditRun, RunId)
|
|
if not run:
|
|
raise LeauditException(StatusCodeEnum.HTTP_404_NOT_FOUND, "评查运行记录不存在")
|
|
ruleResult = await session.execute(
|
|
text(
|
|
"""
|
|
SELECT
|
|
rule_id,
|
|
rule_name,
|
|
risk,
|
|
score,
|
|
passed,
|
|
status,
|
|
skip_reason,
|
|
confidence,
|
|
pass_message,
|
|
fail_message,
|
|
remediation,
|
|
extracted_fields,
|
|
field_positions,
|
|
rescue_applied,
|
|
rescue_passed
|
|
FROM leaudit_rule_results
|
|
WHERE run_id = :run_id
|
|
ORDER BY id ASC
|
|
"""
|
|
),
|
|
{"run_id": RunId},
|
|
)
|
|
fieldResult = await session.execute(
|
|
text(
|
|
"""
|
|
SELECT
|
|
field_name,
|
|
field_type,
|
|
value_text,
|
|
confidence,
|
|
grounding_method,
|
|
fallback_value,
|
|
raw_value_json,
|
|
meta_json
|
|
FROM leaudit_field_results
|
|
WHERE run_id = :run_id
|
|
ORDER BY id ASC
|
|
"""
|
|
),
|
|
{"run_id": RunId},
|
|
)
|
|
errorResult = await session.execute(
|
|
text(
|
|
"""
|
|
SELECT
|
|
stage,
|
|
level,
|
|
error_code,
|
|
message,
|
|
detail_json,
|
|
created_at
|
|
FROM leaudit_run_errors
|
|
WHERE run_id = :run_id
|
|
ORDER BY id ASC
|
|
"""
|
|
),
|
|
{"run_id": RunId},
|
|
)
|
|
rescueResult = await session.execute(
|
|
text(
|
|
"""
|
|
SELECT
|
|
rule_id,
|
|
status,
|
|
diagnosis,
|
|
diagnosis_confidence,
|
|
final_status,
|
|
failure_reason,
|
|
llm_calls,
|
|
vlm_calls,
|
|
duration_ms,
|
|
requires_human_review,
|
|
payload
|
|
FROM leaudit_rescue_outcomes
|
|
WHERE run_id = :run_id
|
|
ORDER BY id ASC
|
|
"""
|
|
),
|
|
{"run_id": RunId},
|
|
)
|
|
metricResult = await session.execute(
|
|
text(
|
|
"""
|
|
SELECT
|
|
ocr_seconds,
|
|
normalize_seconds,
|
|
extract_seconds,
|
|
evaluate_seconds,
|
|
rescue_seconds,
|
|
total_seconds,
|
|
page_count,
|
|
sub_document_count,
|
|
field_count,
|
|
rule_count,
|
|
llm_call_count,
|
|
vlm_call_count,
|
|
rescue_rule_count,
|
|
artifact_count
|
|
FROM leaudit_run_metrics
|
|
WHERE run_id = :run_id
|
|
ORDER BY id DESC
|
|
LIMIT 1
|
|
"""
|
|
),
|
|
{"run_id": RunId},
|
|
)
|
|
artifactResult = await session.execute(
|
|
text(
|
|
"""
|
|
SELECT
|
|
artifact_type,
|
|
artifact_role,
|
|
file_name,
|
|
file_ext,
|
|
mime_type,
|
|
file_size,
|
|
oss_url,
|
|
is_persisted
|
|
FROM leaudit_artifacts
|
|
WHERE run_id = :run_id
|
|
ORDER BY id ASC
|
|
"""
|
|
),
|
|
{"run_id": RunId},
|
|
)
|
|
rules = [dict(row) for row in ruleResult.mappings().all()]
|
|
fields = [
|
|
AuditFieldResultVO(
|
|
fieldName=row["field_name"],
|
|
fieldType=row["field_type"],
|
|
valueText=row["value_text"],
|
|
confidence=float(row["confidence"]) if row["confidence"] is not None else None,
|
|
groundingMethod=row["grounding_method"],
|
|
fallbackValue=row["fallback_value"],
|
|
rawValueJson=row["raw_value_json"],
|
|
metaJson=row["meta_json"],
|
|
)
|
|
for row in fieldResult.mappings().all()
|
|
]
|
|
errors = [
|
|
AuditRunErrorVO(
|
|
stage=row["stage"],
|
|
level=row["level"],
|
|
errorCode=row["error_code"],
|
|
message=row["message"],
|
|
detailJson=row["detail_json"],
|
|
createdAt=row["created_at"],
|
|
)
|
|
for row in errorResult.mappings().all()
|
|
]
|
|
rescueOutcomes = [
|
|
AuditRescueOutcomeVO(
|
|
ruleId=row["rule_id"],
|
|
status=row["status"],
|
|
diagnosis=row["diagnosis"],
|
|
diagnosisConfidence=float(row["diagnosis_confidence"]) if row["diagnosis_confidence"] is not None else None,
|
|
finalStatus=row["final_status"],
|
|
failureReason=row["failure_reason"],
|
|
llmCalls=row["llm_calls"],
|
|
vlmCalls=row["vlm_calls"],
|
|
durationMs=row["duration_ms"],
|
|
requiresHumanReview=bool(row["requires_human_review"]),
|
|
payload=row["payload"],
|
|
)
|
|
for row in rescueResult.mappings().all()
|
|
]
|
|
metricRow = metricResult.mappings().first()
|
|
metrics = (
|
|
AuditMetricsVO(
|
|
ocrSeconds=float(metricRow["ocr_seconds"]) if metricRow["ocr_seconds"] is not None else None,
|
|
normalizeSeconds=float(metricRow["normalize_seconds"]) if metricRow["normalize_seconds"] is not None else None,
|
|
extractSeconds=float(metricRow["extract_seconds"]) if metricRow["extract_seconds"] is not None else None,
|
|
evaluateSeconds=float(metricRow["evaluate_seconds"]) if metricRow["evaluate_seconds"] is not None else None,
|
|
rescueSeconds=float(metricRow["rescue_seconds"]) if metricRow["rescue_seconds"] is not None else None,
|
|
totalSeconds=float(metricRow["total_seconds"]) if metricRow["total_seconds"] is not None else None,
|
|
pageCount=metricRow["page_count"],
|
|
subDocumentCount=metricRow["sub_document_count"],
|
|
fieldCount=metricRow["field_count"],
|
|
ruleCount=metricRow["rule_count"],
|
|
llmCallCount=metricRow["llm_call_count"],
|
|
vlmCallCount=metricRow["vlm_call_count"],
|
|
rescueRuleCount=metricRow["rescue_rule_count"],
|
|
artifactCount=metricRow["artifact_count"],
|
|
)
|
|
if metricRow
|
|
else None
|
|
)
|
|
artifacts = [
|
|
AuditArtifactVO(
|
|
artifactType=row["artifact_type"],
|
|
artifactRole=row["artifact_role"],
|
|
fileName=row["file_name"],
|
|
fileExt=row["file_ext"],
|
|
mimeType=row["mime_type"],
|
|
fileSize=row["file_size"],
|
|
ossUrl=row["oss_url"],
|
|
isPersisted=row["is_persisted"],
|
|
)
|
|
for row in artifactResult.mappings().all()
|
|
]
|
|
return AuditResultVO(
|
|
runId=run.Id,
|
|
documentId=run.documentId,
|
|
documentFileId=run.documentFileId,
|
|
status=run.status,
|
|
totalScore=float(run.totalScore) if run.totalScore else None,
|
|
passedCount=run.passedCount or 0,
|
|
failedCount=run.failedCount or 0,
|
|
skippedCount=run.skippedCount or 0,
|
|
phase=run.phase,
|
|
resultStatus=run.resultStatus,
|
|
rescueApplied=run.rescueApplied or False,
|
|
ruleSetId=run.ruleSetId,
|
|
ruleVersionId=run.ruleVersionId,
|
|
startedAt=run.startedAt,
|
|
finishedAt=run.finishedAt,
|
|
rules=rules,
|
|
fields=fields,
|
|
errors=errors,
|
|
rescueOutcomes=rescueOutcomes,
|
|
metrics=metrics,
|
|
artifacts=artifacts,
|
|
)
|