439 lines
17 KiB
Python
439 lines
17 KiB
Python
"""
|
||
发票虚开检测算法
|
||
检测发票金额与实际业务是否匹配，识别虚开发票风险
|
||
"""
|
||
from typing import Dict, Any, List, Optional, Tuple
|
||
from datetime import datetime, timedelta
|
||
from sqlalchemy import select, func, and_, or_
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
from loguru import logger
|
||
|
||
from .base import (
|
||
RiskDetectionAlgorithm,
|
||
DetectionContext,
|
||
DetectionResult,
|
||
RiskEvidence,
|
||
)
|
||
from app.models.risk_detection import RiskLevel
|
||
from app.models.invoice import Invoice
|
||
from app.models.order import Order
|
||
from app.models.settlement import Settlement
|
||
|
||
|
||
class InvoiceFraudDetectionAlgorithm(RiskDetectionAlgorithm):
|
||
"""发票虚开检测算法"""
|
||
|
||
def get_algorithm_code(self) -> str:
|
||
return "INVOICE_FRAUD_DETECTION"
|
||
|
||
def get_algorithm_name(self) -> str:
|
||
return "发票虚开检测"
|
||
|
||
def get_description(self) -> str:
|
||
return (
|
||
"通过对比发票数据与订单、结算记录，"
|
||
"检测是否存在虚开发票、金额不匹配等风险"
|
||
)
|
||
|
||
async def _do_detect(self, context: DetectionContext) -> DetectionResult:
|
||
"""执行发票虚开检测"""
|
||
# 获取参数
|
||
seller_tax_no = context.get_parameter("seller_tax_no")
|
||
period = context.get_parameter("period") # 格式：YYYY-MM
|
||
threshold_rate = context.get_parameter("threshold_rate", 0.1) # 差异率阈值
|
||
|
||
if not seller_tax_no or not period:
|
||
return self._create_error_result(context, "缺少必要参数：seller_tax_no 或 period")
|
||
|
||
db_session = context.db_session
|
||
if not db_session:
|
||
return self._create_error_result(context, "缺少数据库会话")
|
||
|
||
try:
|
||
# 获取发票数据
|
||
invoices = await self._get_invoices(db_session, seller_tax_no, period)
|
||
|
||
# 获取订单和结算数据
|
||
orders, settlements = await self._get_business_data(
|
||
db_session, seller_tax_no, period
|
||
)
|
||
|
||
# 分析发票异常
|
||
anomalies = self._analyze_invoice_anomalies(
|
||
invoices, orders, settlements, threshold_rate
|
||
)
|
||
|
||
# 计算风险指标
|
||
total_invoice_amount = sum(inv["total_amount"] for inv in invoices)
|
||
total_order_amount = sum(order["total_amount"] for order in orders)
|
||
total_settlement_amount = sum(set["actual_amount"] for set in settlements)
|
||
|
||
discrepancy = self._calculate_discrepancy(
|
||
total_invoice_amount, total_order_amount, total_settlement_amount
|
||
)
|
||
|
||
# 判断风险等级
|
||
risk_level, risk_score = self._calculate_risk_level(anomalies, discrepancy)
|
||
|
||
# 生成风险描述和建议
|
||
description, suggestion = self._generate_risk_description(
|
||
anomalies, discrepancy, total_invoice_amount
|
||
)
|
||
|
||
# 创建检测结果
|
||
result = DetectionResult(
|
||
task_id=context.task_id,
|
||
rule_id=context.rule_id,
|
||
entity_id=seller_tax_no,
|
||
entity_type="taxpayer",
|
||
risk_level=risk_level,
|
||
risk_score=risk_score,
|
||
description=description,
|
||
suggestion=suggestion,
|
||
risk_data={
|
||
"invoices": invoices,
|
||
"orders": orders,
|
||
"settlements": settlements,
|
||
"anomalies": anomalies,
|
||
"total_invoice_amount": total_invoice_amount,
|
||
"total_order_amount": total_order_amount,
|
||
"total_settlement_amount": total_settlement_amount,
|
||
"discrepancy": discrepancy,
|
||
"period": period,
|
||
},
|
||
)
|
||
|
||
# 添加证据
|
||
result.add_evidence(RiskEvidence(
|
||
evidence_type="invoice_summary",
|
||
description=f"期间内共开具 {len(invoices)} 张发票，总金额 {total_invoice_amount:,.2f}元",
|
||
data={
|
||
"count": len(invoices),
|
||
"total_amount": total_invoice_amount,
|
||
},
|
||
))
|
||
|
||
result.add_evidence(RiskEvidence(
|
||
evidence_type="business_summary",
|
||
description=f"实际业务：订单金额 {total_order_amount:,.2f}元，结算金额 {total_settlement_amount:,.2f}元",
|
||
data={
|
||
"order_amount": total_order_amount,
|
||
"settlement_amount": total_settlement_amount,
|
||
},
|
||
))
|
||
|
||
if discrepancy > 0:
|
||
result.add_evidence(RiskEvidence(
|
||
evidence_type="discrepancy",
|
||
description=f"发票与业务数据差异：{discrepancy:,.2f}元",
|
||
data={"discrepancy": discrepancy},
|
||
))
|
||
|
||
# 添加主要异常记录
|
||
for anomaly in anomalies[:5]:
|
||
result.add_evidence(RiskEvidence(
|
||
evidence_type="anomaly_detail",
|
||
description=f"异常：{anomaly['description']}",
|
||
data=anomaly,
|
||
))
|
||
|
||
return result
|
||
|
||
except Exception as e:
|
||
logger.error(f"发票虚开检测执行失败: {str(e)}", exc_info=True)
|
||
return self._create_error_result(context, f"检测执行失败: {str(e)}")
|
||
|
||
async def _get_invoices(
|
||
self, db_session: AsyncSession, seller_tax_no: str, period: str
|
||
) -> List[Dict[str, Any]]:
|
||
"""获取发票数据"""
|
||
try:
|
||
start_date, end_date = self._parse_period(period)
|
||
|
||
stmt = select(Invoice).where(
|
||
and_(
|
||
Invoice.seller_tax_no == seller_tax_no,
|
||
Invoice.invoice_date >= start_date,
|
||
Invoice.invoice_date <= end_date,
|
||
Invoice.invoice_status == "正常",
|
||
)
|
||
).order_by(Invoice.invoice_date.desc())
|
||
|
||
result = await db_session.execute(stmt)
|
||
invoices = result.scalars().all()
|
||
|
||
return [
|
||
{
|
||
"invoice_id": inv.invoice_id,
|
||
"invoice_code": inv.invoice_code,
|
||
"invoice_no": inv.invoice_no,
|
||
"invoice_date": inv.invoice_date,
|
||
"total_amount": inv.total_amount,
|
||
"total_tax": inv.total_tax,
|
||
"purchaser_name": inv.purchaser_name,
|
||
"purchaser_tax_no": inv.purchaser_tax_no,
|
||
"direction": inv.direction,
|
||
"is_verified": inv.is_verified,
|
||
"is_red_invoice": inv.is_red_invoice,
|
||
}
|
||
for inv in invoices
|
||
]
|
||
except Exception as e:
|
||
logger.error(f"获取发票数据失败: {str(e)}")
|
||
return []
|
||
|
||
async def _get_business_data(
|
||
self, db_session: AsyncSession, seller_tax_no: str, period: str
|
||
) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
|
||
"""获取订单和结算数据"""
|
||
try:
|
||
start_date, end_date = self._parse_period(period)
|
||
|
||
# 获取订单
|
||
order_stmt = select(Order).where(
|
||
and_(
|
||
Order.order_time >= start_date,
|
||
Order.order_time <= end_date,
|
||
Order.order_status == "已完成",
|
||
)
|
||
)
|
||
|
||
order_result = await db_session.execute(order_stmt)
|
||
orders = order_result.scalars().all()
|
||
|
||
# 获取结算
|
||
settlement_stmt = select(Settlement).where(
|
||
and_(
|
||
Settlement.settlement_start_date >= start_date,
|
||
Settlement.settlement_end_date <= end_date,
|
||
Settlement.settlement_status == "已结算",
|
||
)
|
||
)
|
||
|
||
settlement_result = await db_session.execute(settlement_stmt)
|
||
settlements = settlement_result.scalars().all()
|
||
|
||
orders_data = [
|
||
{
|
||
"order_id": order.order_id,
|
||
"order_time": order.order_time,
|
||
"total_amount": order.total_amount,
|
||
"actual_payment": order.actual_payment,
|
||
}
|
||
for order in orders
|
||
]
|
||
|
||
settlements_data = [
|
||
{
|
||
"settlement_id": settlement.settlement_id,
|
||
"settlement_period": settlement.settlement_period,
|
||
"actual_settlement_amount": settlement.actual_settlement_amount,
|
||
}
|
||
for settlement in settlements
|
||
]
|
||
|
||
return orders_data, settlements_data
|
||
|
||
except Exception as e:
|
||
logger.error(f"获取业务数据失败: {str(e)}")
|
||
return [], []
|
||
|
||
def _analyze_invoice_anomalies(
|
||
self,
|
||
invoices: List[Dict[str, Any]],
|
||
orders: List[Dict[str, Any]],
|
||
settlements: List[Dict[str, Any]],
|
||
threshold_rate: float,
|
||
) -> List[Dict[str, Any]]:
|
||
"""分析发票异常"""
|
||
anomalies = []
|
||
|
||
# 检查发票与订单金额匹配
|
||
if invoices and orders:
|
||
invoice_total = sum(inv["total_amount"] for inv in invoices)
|
||
order_total = sum(order["total_amount"] for order in orders)
|
||
|
||
if invoice_total > 0 and order_total > 0:
|
||
diff_rate = abs(invoice_total - order_total) / max(invoice_total, order_total)
|
||
if diff_rate > threshold_rate:
|
||
anomalies.append({
|
||
"type": "amount_mismatch",
|
||
"description": f"发票总额与订单总额差异率 {diff_rate*100:.2f}% 超过阈值",
|
||
"invoice_total": invoice_total,
|
||
"order_total": order_total,
|
||
"diff_rate": diff_rate,
|
||
})
|
||
|
||
# 检查发票与结算金额匹配
|
||
if invoices and settlements:
|
||
invoice_total = sum(inv["total_amount"] for inv in invoices)
|
||
settlement_total = sum(set["actual_settlement_amount"] for set in settlements)
|
||
|
||
if invoice_total > 0 and settlement_total > 0:
|
||
diff_rate = abs(invoice_total - settlement_total) / max(invoice_total, settlement_total)
|
||
if diff_rate > threshold_rate:
|
||
anomalies.append({
|
||
"type": "settlement_mismatch",
|
||
"description": f"发票总额与结算总额差异率 {diff_rate*100:.2f}% 超过阈值",
|
||
"invoice_total": invoice_total,
|
||
"settlement_total": settlement_total,
|
||
"diff_rate": diff_rate,
|
||
})
|
||
|
||
# 检查大量红字发票
|
||
red_invoices = [inv for inv in invoices if inv["is_red_invoice"]]
|
||
if red_invoices:
|
||
red_rate = len(red_invoices) / len(invoices) if invoices else 0
|
||
if red_rate > 0.3: # 超过30%为红字发票
|
||
anomalies.append({
|
||
"type": "high_red_invoice_rate",
|
||
"description": f"红字发票比例 {red_rate*100:.2f}% 过高",
|
||
"red_count": len(red_invoices),
|
||
"total_count": len(invoices),
|
||
"red_rate": red_rate,
|
||
})
|
||
|
||
# 检查大额发票
|
||
large_invoices = [inv for inv in invoices if inv["total_amount"] > 100000]
|
||
if large_invoices:
|
||
anomalies.append({
|
||
"type": "large_invoices",
|
||
"description": f"存在 {len(large_invoices)} 张大额发票（>10万元）",
|
||
"count": len(large_invoices),
|
||
"total_amount": sum(inv["total_amount"] for inv in large_invoices),
|
||
})
|
||
|
||
# 检查未验证的发票
|
||
unverified_invoices = [inv for inv in invoices if not inv["is_verified"]]
|
||
if unverified_invoices:
|
||
unverified_rate = len(unverified_invoices) / len(invoices) if invoices else 0
|
||
if unverified_rate > 0.2: # 超过20%未验证
|
||
anomalies.append({
|
||
"type": "high_unverified_rate",
|
||
"description": f"未验证发票比例 {unverified_rate*100:.2f}% 过高",
|
||
"unverified_count": len(unverified_invoices),
|
||
"total_count": len(invoices),
|
||
"unverified_rate": unverified_rate,
|
||
})
|
||
|
||
return anomalies
|
||
|
||
def _calculate_discrepancy(
|
||
self,
|
||
invoice_amount: float,
|
||
order_amount: float,
|
||
settlement_amount: float,
|
||
) -> float:
|
||
"""计算金额差异"""
|
||
# 以发票金额为基准，计算与订单和结算的平均差异
|
||
if invoice_amount == 0:
|
||
return 0.0
|
||
|
||
order_diff = abs(invoice_amount - order_amount) if order_amount > 0 else 0
|
||
settlement_diff = abs(invoice_amount - settlement_amount) if settlement_amount > 0 else 0
|
||
|
||
return (order_diff + settlement_diff) / 2
|
||
|
||
def _calculate_risk_level(
|
||
self, anomalies: List[Dict[str, Any]], discrepancy: float
|
||
) -> tuple[RiskLevel, float]:
|
||
"""计算风险等级"""
|
||
if not anomalies and discrepancy < 1000:
|
||
return RiskLevel.LOW, 10.0
|
||
|
||
risk_score = 20.0 # 基础分
|
||
|
||
# 基于异常类型加分
|
||
anomaly_scores = {
|
||
"amount_mismatch": 40,
|
||
"settlement_mismatch": 35,
|
||
"high_red_invoice_rate": 30,
|
||
"large_invoices": 20,
|
||
"high_unverified_rate": 25,
|
||
}
|
||
|
||
for anomaly in anomalies:
|
||
risk_score += anomaly_scores.get(anomaly["type"], 10)
|
||
|
||
# 基于差异金额加分
|
||
if discrepancy > 500000:
|
||
risk_score += 30
|
||
elif discrepancy > 200000:
|
||
risk_score += 20
|
||
elif discrepancy > 100000:
|
||
risk_score += 10
|
||
|
||
# 限制分数范围
|
||
risk_score = min(risk_score, 100.0)
|
||
|
||
# 判断风险等级
|
||
if risk_score >= 90:
|
||
return RiskLevel.CRITICAL, risk_score
|
||
elif risk_score >= 70:
|
||
return RiskLevel.HIGH, risk_score
|
||
elif risk_score >= 50:
|
||
return RiskLevel.MEDIUM, risk_score
|
||
else:
|
||
return RiskLevel.LOW, risk_score
|
||
|
||
def _generate_risk_description(
|
||
self,
|
||
anomalies: List[Dict[str, Any]],
|
||
discrepancy: float,
|
||
total_invoice_amount: float,
|
||
) -> tuple[str, str]:
|
||
"""生成风险描述和建议"""
|
||
if anomalies:
|
||
anomaly_count = len(anomalies)
|
||
anomaly_types = [a["type"] for a in anomalies]
|
||
description = (
|
||
f"检测到 {anomaly_count} 项发票异常风险："
|
||
f"发票总金额 {total_invoice_amount:,.2f}元，"
|
||
f"存在金额不匹配、红字发票比例过高等问题，"
|
||
f"可能涉及虚开发票风险。"
|
||
)
|
||
|
||
suggestion = (
|
||
"1. 核实发票开具的真实性和合法性；\n"
|
||
"2. 检查发票与实际业务的对应关系；\n"
|
||
"3. 提供相关合同、订单、结算证明材料；\n"
|
||
"4. 对红字发票说明冲红原因；\n"
|
||
"5. 及时验证发票真伪；\n"
|
||
"6. 如发现问题，建议主动补正申报。"
|
||
)
|
||
else:
|
||
description = "发票数据检查未发现明显异常，开票行为基本规范。"
|
||
suggestion = "继续保持规范的发票管理。"
|
||
|
||
return description, suggestion
|
||
|
||
def _parse_period(self, period: str) -> tuple[datetime, datetime]:
|
||
"""解析期间为开始和结束日期"""
|
||
try:
|
||
year, month = map(int, period.split("-"))
|
||
start_date = datetime(year, month, 1)
|
||
if month == 12:
|
||
end_date = datetime(year + 1, 1, 1) - timedelta(days=1)
|
||
else:
|
||
end_date = datetime(year, month + 1, 1) - timedelta(days=1)
|
||
return start_date, end_date
|
||
except Exception as e:
|
||
logger.error(f"解析期间失败: {period}, 错误: {str(e)}")
|
||
now = datetime.now()
|
||
start_date = datetime(now.year, now.month, 1)
|
||
end_date = now
|
||
return start_date, end_date
|
||
|
||
def _create_error_result(self, context: DetectionContext, error_message: str) -> DetectionResult:
|
||
"""创建错误结果"""
|
||
return DetectionResult(
|
||
task_id=context.task_id,
|
||
rule_id=context.rule_id,
|
||
entity_id=context.get_parameter("seller_tax_no", ""),
|
||
entity_type="taxpayer",
|
||
risk_level=RiskLevel.UNKNOWN,
|
||
risk_score=0.0,
|
||
description=f"发票虚开检测失败: {error_message}",
|
||
suggestion="请检查参数设置或联系系统管理员",
|
||
)
|