wsb1224
f8ea5db19a
提取共享函数read_image_bytes，当URL为/uploads/本地路径时 直接从文件系统读取，避免通过公网HTTP下载导致404。 统一修复AliyunOCRProvider和recognize_waybill两处图片下载。 Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2010 lines
80 KiB
Python
2010 lines
80 KiB
Python
"""AI 智能服务模块
|
||
|
||
提供两大核心能力：
|
||
1. OCR 图片识别：将图片中的文字提取为结构化数据，支持阿里云 OCR 和 Mock 两种 provider。
|
||
2. 智能填单：通过文本预处理、规则提取、LLM 结构化解析、产品库模糊匹配等多层管线，
|
||
从粘贴文本或图片中自动识别订单信息并填充到表单。
|
||
|
||
架构分层：
|
||
- TextPreprocessor：清洗粘贴文本中的时间戳、表情标记等噪声。
|
||
- RuleExtractor：基于正则的确定性字段提取（手机号、数量、价格、地址）。
|
||
- OrderOCRParser：基于 OCR 行列表做订单版面分析和字段提取。
|
||
- LLMOrderParser：调用通义千问 qwen-plus 做订单文本结构化解析。
|
||
- BaseOCRProvider / AliyunOCRProvider / MockOCRProvider：OCR 提供者抽象与实现。
|
||
- AIService：业务入口，串联上述组件完成图片识别和智能填单流程。
|
||
|
||
被调用方：ai 路由（图片识别、识别结果修正、智能填单接口）。
|
||
"""
|
||
|
||
import json
|
||
import logging
|
||
import re
|
||
from decimal import Decimal
|
||
from difflib import SequenceMatcher
|
||
from urllib import error, parse, request
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
from sqlalchemy import select
|
||
from sqlalchemy.exc import SQLAlchemyError
|
||
from sqlalchemy.orm import Session
|
||
|
||
from backend.app.core.config import get_settings
|
||
from backend.app.core.error_codes import ErrorCode
|
||
from backend.app.core.exceptions import AppException
|
||
from backend.app.repositories.ai_repository import AIRepository
|
||
from backend.app.services.audit_service import audit_service
|
||
|
||
|
||
def read_image_bytes(image_url: str) -> bytes:
|
||
"""读取图片字节。本地 /uploads/ 路径直接读文件，其他走 HTTP。"""
|
||
from pathlib import Path, PurePosixPath
|
||
from urllib.parse import urlparse
|
||
url_path = PurePosixPath(urlparse(image_url).path)
|
||
if len(url_path.parts) >= 2 and url_path.parts[1] == "uploads":
|
||
settings = get_settings()
|
||
return (Path(settings.local_upload_dir) / url_path.name).read_bytes()
|
||
with request.urlopen(image_url, timeout=15) as resp:
|
||
return resp.read()
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 智能填单：文本预处理
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class TextPreprocessor:
|
||
"""清洗粘贴文本中的噪声，保留有效订单信息。
|
||
|
||
处理内容包括：移除时间戳、括号时间标记、表情/媒体标记、用户名前缀等，
|
||
并合并多余空行。无外部依赖，纯文本处理。
|
||
"""
|
||
|
||
TIMESTAMP_RE = re.compile(r'\d{4}[-/]\d{1,2}[-/]\d{1,2}\s+\d{1,2}:\d{2}(:\d{2})?')
|
||
BRACKET_TIME_RE = re.compile(r'\[\d{1,2}:\d{2}(:\d{2})?\]')
|
||
USERNAME_PREFIX_RE = re.compile(r'^[^:\s]{1,10}[：:]\s*', re.MULTILINE)
|
||
NOISE_MARKERS = [
|
||
'[图片]', '[表情]', '[语音]', '[视频]', '[文件]', '[链接]',
|
||
'[红包]', '[转账]', '[位置]', '[名片]', '—— ——',
|
||
]
|
||
|
||
def preprocess(self, text: str) -> str:
|
||
"""清洗文本，移除噪声内容并合并多余空行。
|
||
|
||
参数：
|
||
text: 原始粘贴文本。
|
||
|
||
返回：
|
||
清洗后的纯文本，空输入返回空字符串。
|
||
"""
|
||
if not text or not text.strip():
|
||
return ""
|
||
result = text
|
||
result = self.TIMESTAMP_RE.sub('', result)
|
||
result = self.BRACKET_TIME_RE.sub('', result)
|
||
for marker in self.NOISE_MARKERS:
|
||
result = result.replace(marker, '')
|
||
result = self.USERNAME_PREFIX_RE.sub('', result)
|
||
result = re.sub(r'\n{3,}', '\n\n', result)
|
||
return result.strip()
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 智能填单：规则提取层
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class RuleExtractor:
|
||
"""基于规则的字段提取器，处理确定性高的字段。
|
||
|
||
通过正则表达式提取手机号、数量+单位、单价，并基于地址关键词密度识别地址段。
|
||
适用于文本预处理后的清洗文本。
|
||
"""
|
||
|
||
PHONE_RE = re.compile(r'1[3-9]\d{9}')
|
||
QTY_UNIT_RE = re.compile(
|
||
r'(\d+\.?\d*)\s*(张|个|卷|条|套|片|块|吨|件|箱|包|米|cm|厘米|毫米|mm|kg|KG|公斤|斤|组|台|根)'
|
||
)
|
||
PRICE_RE = re.compile(r'(?:单价|价格|报价)\s*[:：]?\s*(\d+\.?\d*)')
|
||
ADDRESS_KEYWORDS = [
|
||
'省', '市', '区', '县', '镇', '路', '街', '号',
|
||
'楼', '室', '栋', '单元', '村', '大厦', '广场',
|
||
]
|
||
|
||
def extract(self, text: str) -> dict:
|
||
"""从文本中提取确定性字段。
|
||
|
||
参数：
|
||
text: 清洗后的文本。
|
||
|
||
返回：
|
||
字典，包含 customer_mobile、_raw_quantity、_raw_unit、_raw_price、customer_address 等字段。
|
||
"""
|
||
result: dict = {}
|
||
phones = self.PHONE_RE.findall(text)
|
||
if phones:
|
||
result['customer_mobile'] = phones[0]
|
||
qty_match = self.QTY_UNIT_RE.search(text)
|
||
if qty_match:
|
||
result['_raw_quantity'] = float(qty_match.group(1))
|
||
result['_raw_unit'] = qty_match.group(2)
|
||
price_match = self.PRICE_RE.search(text)
|
||
if price_match:
|
||
result['_raw_price'] = float(price_match.group(1))
|
||
addr = self._extract_address(text)
|
||
if addr:
|
||
result['customer_address'] = addr
|
||
return result
|
||
|
||
def _extract_address(self, text: str) -> str | None:
|
||
"""基于地址关键词密度提取地址段。
|
||
|
||
逐行扫描，关键词命中数 >= 2 的连续行视为地址段，取最长段。
|
||
|
||
参数：
|
||
text: 清洗后的文本。
|
||
|
||
返回：
|
||
拼接后的地址字符串，未识别到时返回 None。
|
||
"""
|
||
lines = text.split('\n')
|
||
best: list[str] = []
|
||
current: list[str] = []
|
||
for line in lines:
|
||
stripped = line.strip()
|
||
if not stripped:
|
||
continue
|
||
addr_hits = sum(1 for kw in self.ADDRESS_KEYWORDS if kw in stripped)
|
||
if addr_hits >= 2:
|
||
current.append(stripped)
|
||
else:
|
||
if len(current) > len(best):
|
||
best = list(current)
|
||
current = []
|
||
if len(current) > len(best):
|
||
best = current
|
||
return ''.join(best) if best else None
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 智能填单：OCR 版面分析
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class OrderOCRParser:
|
||
"""基于 OCR 行列表做订单版面分析。
|
||
|
||
将 OCR 返回的文本行按区域分类（头部、地址、表格、其他），
|
||
从各区域中提取客户信息和产品明细。
|
||
"""
|
||
|
||
PHONE_RE = re.compile(r'1[3-9]\d{9}')
|
||
ADDRESS_KEYWORDS = {
|
||
'省', '市', '区', '县', '镇', '路', '街', '号',
|
||
'楼', '室', '栋', '单元', '村', '大厦', '广场',
|
||
'弄', '巷', '苑', '园', '城',
|
||
}
|
||
QTY_RE = re.compile(
|
||
r'(\d+\.?\d*)\s*(张|个|卷|条|套|片|块|吨|件|箱|包|米|cm|厘米|毫米|mm|kg|KG|公斤|斤|组|台|根)'
|
||
)
|
||
PRICE_RE = re.compile(r'(?:单价|价格|报价|￥|¥)\s*[:：]?\s*(\d+\.?\d*)')
|
||
TABLE_HEADER_KEYWORDS = {'产品', '品名', '名称', '规格', '数量', '单价', '金额', '合计'}
|
||
|
||
def parse(self, line_list: list[str], ocr_confidence: float) -> dict:
|
||
"""解析 OCR 行列表，输出结构化的版面分析结果。
|
||
|
||
参数：
|
||
line_list: OCR 返回的文本行列表。
|
||
ocr_confidence: OCR 识别置信度。
|
||
|
||
返回：
|
||
包含 raw_text、ocr_confidence、layout_zones、pre_filled、table_rows 的字典。
|
||
"""
|
||
raw_text = '\n'.join(line_list)
|
||
zones = self._classify_lines(line_list)
|
||
pre_filled = self._extract_from_zones(line_list, zones)
|
||
table_rows = self._parse_table_lines(line_list, zones.get('table_lines', []))
|
||
return {
|
||
"raw_text": raw_text,
|
||
"ocr_confidence": ocr_confidence,
|
||
"layout_zones": zones,
|
||
"pre_filled": pre_filled,
|
||
"table_rows": table_rows,
|
||
}
|
||
|
||
def _classify_lines(self, lines: list[str]) -> dict:
|
||
"""将 OCR 文本行按区域类型分类。
|
||
|
||
分类逻辑：前 3 行为头部、含地址关键词的连续行归为地址区、
|
||
遇到表格表头后连续的产品行归为表格区，其余为其他。
|
||
|
||
参数：
|
||
lines: OCR 文本行列表。
|
||
|
||
返回：
|
||
包含 header_lines、address_lines、table_lines、other_lines 的分类索引字典。
|
||
"""
|
||
zones: dict[str, list[int]] = {
|
||
"header_lines": [], "address_lines": [],
|
||
"table_lines": [], "other_lines": [],
|
||
}
|
||
table_started = False
|
||
for i, line in enumerate(lines):
|
||
stripped = line.strip()
|
||
if not stripped:
|
||
continue
|
||
if any(kw in stripped for kw in self.TABLE_HEADER_KEYWORDS):
|
||
table_started = True
|
||
zones["table_lines"].append(i)
|
||
continue
|
||
if table_started:
|
||
if self.QTY_RE.search(stripped) or self.PRICE_RE.search(stripped):
|
||
zones["table_lines"].append(i)
|
||
continue
|
||
table_started = False
|
||
addr_count = sum(1 for kw in self.ADDRESS_KEYWORDS if kw in stripped)
|
||
if addr_count >= 2:
|
||
zones["address_lines"].append(i)
|
||
continue
|
||
if i < 3:
|
||
zones["header_lines"].append(i)
|
||
else:
|
||
zones["other_lines"].append(i)
|
||
return zones
|
||
|
||
def _extract_from_zones(self, lines: list[str], zones: dict) -> dict:
|
||
"""从已分类的区域中提取客户基本信息（姓名、手机、地址）。
|
||
|
||
参数：
|
||
lines: OCR 文本行列表。
|
||
zones: 区域分类结果字典。
|
||
|
||
返回：
|
||
包含 customer_mobile、customer_name、customer_address 的预填字段字典。
|
||
"""
|
||
result: dict = {}
|
||
for i in zones.get("header_lines", []):
|
||
text = lines[i].strip()
|
||
if not text:
|
||
continue
|
||
phone_match = self.PHONE_RE.search(text)
|
||
if phone_match:
|
||
result["customer_mobile"] = phone_match.group(0)
|
||
name_part = self.PHONE_RE.sub('', text).strip()
|
||
if name_part and len(name_part) <= 20 and not any(
|
||
kw in name_part for kw in self.ADDRESS_KEYWORDS
|
||
):
|
||
result.setdefault("customer_name", name_part)
|
||
addr_parts = [lines[i].strip() for i in zones.get("address_lines", [])]
|
||
if addr_parts:
|
||
result["customer_address"] = ''.join(addr_parts)
|
||
return result
|
||
|
||
def _parse_table_lines(self, lines: list[str], table_indices: list[int]) -> list[dict]:
|
||
"""解析表格区域中的产品行，提取数量、单价和产品名称。
|
||
|
||
参数：
|
||
lines: OCR 文本行列表。
|
||
table_indices: 表格区域的行索引列表。
|
||
|
||
返回：
|
||
产品行列表，每个元素包含 raw（原始行）和 fields（提取的字段）字典。
|
||
"""
|
||
rows: list[dict] = []
|
||
for i in table_indices:
|
||
line = lines[i].strip()
|
||
if not line:
|
||
continue
|
||
if any(kw in line for kw in self.TABLE_HEADER_KEYWORDS) and not self.QTY_RE.search(line):
|
||
continue
|
||
row: dict = {"raw": line, "fields": {}}
|
||
qty_match = self.QTY_RE.search(line)
|
||
if qty_match:
|
||
row["fields"]["quantity"] = float(qty_match.group(1))
|
||
row["fields"]["unit"] = qty_match.group(2)
|
||
price_match = self.PRICE_RE.search(line)
|
||
if price_match:
|
||
row["fields"]["sale_price"] = float(price_match.group(1))
|
||
name_part = self.QTY_RE.sub('', line)
|
||
name_part = self.PRICE_RE.sub('', name_part)
|
||
name_part = re.sub(r'\d+\.?\d*', '', name_part).strip()
|
||
if name_part:
|
||
row["fields"]["product_name"] = name_part
|
||
if row["fields"]:
|
||
rows.append(row)
|
||
return rows
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 智能填单：LLM 结构化解析
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class LLMOrderParser:
|
||
"""调用通义千问 qwen-plus 进行订单文本结构化解析。
|
||
|
||
支持纯文本和 OCR 图片两种输入模式，通过 system prompt 引导 LLM 输出标准 JSON 格式的订单信息。
|
||
内置产品库提示词（product_hints），帮助 LLM 匹配产品名称和规格。
|
||
"""
|
||
|
||
TEXT_SYSTEM_PROMPT = """你是高温布/特氟龙/胶带/输送带行业的订单解析助手。从业务员粘贴的文本中提取订单信息。
|
||
|
||
## 输入格式（非常重要）
|
||
业务员粘贴的文本由两列组成，中间用 tab 或多个空格分隔：
|
||
- 左列：产品描述（厚度 + 材料名 + 尺寸 + 数量 + 工艺要求）
|
||
- 右列：客户姓名，手机号，地址（备注）
|
||
|
||
示例：0.13mm 咖色高温布 1*10米 SYY+5681，13711561796，广东省广州市白云区石井街道
|
||
|
||
必须严格按这个结构拆分，不要把左列的产品信息混入右列的客户地址中。
|
||
|
||
## customer_address 规则（非常重要）
|
||
customer_address 只能包含地理地址信息（省/市/区/县/镇/街道/路/号/楼/室/栋/公司名），绝对不能包含：
|
||
- 产品描述（厚度、材料名、尺寸等）
|
||
- 客户姓名和手机号
|
||
- 订单编号（如 SYY+5681）
|
||
- 整段原始文本
|
||
|
||
## product_name 规则（非常重要）
|
||
product_name 只填产品材料类型名称，不要带型号编号：
|
||
- "0.13mm 咖色高温布" → product_name="高温布"
|
||
- "145g咖色高温布" → product_name="高温布"
|
||
- "黑色4*4mm网格输送带" → product_name="网格输送带"
|
||
- "咖色特氟龙胶带" → product_name="特氟龙胶带"
|
||
- "用凯夫拉布做" → product_name="凯夫拉布"
|
||
常见产品名：高温布、特氟龙胶带、网格输送带、烧烤网格片、凯夫拉布、硅胶布、胶带、输送带、揉面垫、硅胶烤垫
|
||
|
||
## specification 规则
|
||
specification 必须包含所有产品参数，格式为 "厚度/克重 颜色 标准化尺寸"：
|
||
- "0.13mm 咖色高温布 1*10米" → specification="0.13mm 咖色 1000mm×10000mm"
|
||
- "145g咖色高温布 25*30厘米 1000张" → specification="145g 咖色 250mm×300mm"
|
||
|
||
## 尺寸标准化
|
||
将所有尺寸统一转换为 "长mm×宽mm" 格式：
|
||
- "1*10米" → "1000mm×10000mm"
|
||
- "60*80cm" → "600mm×800mm"
|
||
- "25*30厘米" → "250mm×300mm"
|
||
- "长800mm宽250mm" → "800mm×250mm"
|
||
- "80厘米宽*1米长" → "1000mm×800mm"
|
||
|
||
## 数量单位
|
||
常用单位：张、个、卷、条、套、片、块
|
||
|
||
## 备注提取
|
||
- 括号中的内容：（不要浅色的）、（单片卷）、（加急安排）→ items[].remark
|
||
- 尾部工艺要求：带回仓库包装、黑膜包边、牛鼻子接头 → items[].remark
|
||
|
||
## 严格按以下 JSON 格式输出：
|
||
{{
|
||
"customer_name": "客户姓名",
|
||
"customer_mobile": "11位手机号",
|
||
"customer_address": "仅包含地理地址",
|
||
"order_source": null,
|
||
"delivery_type": null,
|
||
"remark": "订单级备注",
|
||
"items": [
|
||
{{
|
||
"product_name": "产品材料类型（不带型号）",
|
||
"specification": "产品自身规格（厚度、颜色等标准参数）",
|
||
"demand_specification": "客户要求的尺寸，统一转换为m格式（如0.25m×0.3m），仅提取客户说的尺寸，无尺寸则为null",
|
||
"unit": "数量单位",
|
||
"quantity": 数量数字,
|
||
"sale_price": null,
|
||
"remark": "产品级备注"
|
||
}}
|
||
]
|
||
}}
|
||
|
||
## 示例
|
||
输入: 0.13mm 咖色高温布 1*10米 SYY+5681，13711561796，广东省 广州市 白云区 石井街道
|
||
输出: {{"customer_name":"SYY+5681","customer_mobile":"13711561796","customer_address":"广东省广州市白云区石井街道","remark":null,"items":[{{"product_name":"高温布","specification":"0.13mm 咖色","demand_specification":"1m×10m","unit":null,"quantity":null,"sale_price":null,"remark":null}}]}}
|
||
|
||
输入: 145g咖色高温布 25*30厘米 1000张 何莹，19932065916，河北省 邯郸市 大名县 园中街瑞盾门业
|
||
输出: {{"customer_name":"何莹","customer_mobile":"19932065916","customer_address":"河北省邯郸市大名县园中街瑞盾门业","remark":null,"items":[{{"product_name":"高温布","specification":"145g 咖色","demand_specification":"0.25m×0.3m","unit":"张","quantity":1000,"sale_price":null,"remark":null}}]}}
|
||
|
||
输入: 用凯夫拉布做，18丝布带。宽度22.8cm，长度56.5，两边重叠6mm 50个（重叠位置要加固） 徐阳飞，15158849480，浙江省 杭州市 富阳区 场口镇
|
||
输出: {{"customer_name":"徐阳飞","customer_mobile":"15158849480","customer_address":"浙江省杭州市富阳区场口镇","remark":null,"items":[{{"product_name":"凯夫拉布","specification":"18丝布带 重叠6mm","demand_specification":"0.228m×0.565m","unit":"个","quantity":50,"sale_price":null,"remark":"重叠位置要加固"}}]}}
|
||
|
||
可选的产品库（名称 + 规格）：
|
||
{product_hints}"""
|
||
|
||
IMAGE_SYSTEM_PROMPT = """你是订单信息解析助手。OCR 系统已经从图片中提取了文本并做了初步分析。
|
||
你需要基于 OCR 的结果，补充和完善订单信息。
|
||
|
||
OCR 已提取的信息：
|
||
- OCR 置信度：{ocr_confidence}
|
||
- 已识别的客户姓名：{customer_name}
|
||
- 已识别的客户手机：{customer_mobile}
|
||
- 已识别的客户地址：{customer_address}
|
||
- 产品表格区域识别到的原始行：
|
||
{table_rows}
|
||
|
||
你需要完成：
|
||
1. 验证 OCR 提取的字段是否合理
|
||
2. 从原始文本中补充 OCR 未提取到的字段
|
||
3. 解析产品明细（如果 OCR 表格区域数据可用，优先使用）
|
||
4. 识别订单来源、配送方式等附加信息
|
||
|
||
严格按以下 JSON 格式输出：
|
||
{{
|
||
"customer_name": "客户姓名",
|
||
"customer_mobile": "手机号",
|
||
"customer_address": "地址",
|
||
"order_source": "订单来源",
|
||
"delivery_type": "配送方式",
|
||
"remark": "备注",
|
||
"items": [
|
||
{{
|
||
"product_name": "产品名称",
|
||
"specification": "规格",
|
||
"unit": "单位",
|
||
"quantity": 数量数字,
|
||
"sale_price": 单价数字
|
||
}}
|
||
]
|
||
}}
|
||
|
||
规则：
|
||
- 无法识别的字段填 null，不要编造
|
||
- 如果 OCR 已提取的字段看起来正确，直接沿用
|
||
|
||
可选的产品库（名称 + 规格）：
|
||
{product_hints}"""
|
||
|
||
def _build_product_hints(self, product_groups: list[dict]) -> str:
|
||
"""构建产品库提示词，供 LLM 在解析时参考。
|
||
|
||
参数：
|
||
product_groups: 产品分组列表，每组包含 product_name 和 specifications。
|
||
|
||
返回：
|
||
格式化的产品提示文本，最多 30 个产品，每个最多 5 个规格。
|
||
"""
|
||
hints: list[str] = []
|
||
for group in product_groups[:50]:
|
||
specs = ', '.join(
|
||
f"{s['specification']}({s['unit']})"
|
||
for s in group.get("specifications", [])[:5]
|
||
)
|
||
hints.append(f"- {group['product_name']}: {specs}")
|
||
return '\n'.join(hints) or "（产品库为空）"
|
||
|
||
def parse(self, text: str, product_groups: list[dict],
|
||
api_key: str, api_url: str,
|
||
ocr_context: dict | None = None,
|
||
model: str = "qwen-plus") -> dict:
|
||
"""调用 LLM 解析订单文本，返回结构化订单数据。
|
||
|
||
参数：
|
||
text: 待解析的订单文本。
|
||
product_groups: 产品库数据，用于构建提示词。
|
||
api_key: LLM API 访问密钥。
|
||
api_url: LLM API 地址。
|
||
ocr_context: 可选的 OCR 上下文，图片模式时提供版面分析结果。
|
||
|
||
返回：
|
||
包含 customer_name、customer_mobile、items 等字段的订单字典。
|
||
|
||
异常：
|
||
LLM 调用失败或返回格式异常时抛出 AppException。
|
||
"""
|
||
product_hints = self._build_product_hints(product_groups)
|
||
if ocr_context:
|
||
system_prompt = self.IMAGE_SYSTEM_PROMPT.format(
|
||
ocr_confidence=ocr_context.get("ocr_confidence", "N/A"),
|
||
customer_name=ocr_context.get("pre_filled", {}).get("customer_name", "未识别"),
|
||
customer_mobile=ocr_context.get("pre_filled", {}).get("customer_mobile", "未识别"),
|
||
customer_address=ocr_context.get("pre_filled", {}).get("customer_address", "未识别"),
|
||
table_rows='\n'.join(
|
||
f" - {row['raw']}" for row in ocr_context.get("table_rows", [])
|
||
) or " 无",
|
||
product_hints=product_hints,
|
||
)
|
||
else:
|
||
system_prompt = self.TEXT_SYSTEM_PROMPT.format(product_hints=product_hints)
|
||
|
||
payload = json.dumps({
|
||
"model": model,
|
||
"messages": [
|
||
{"role": "system", "content": system_prompt},
|
||
{"role": "user", "content": f"请解析以下订单内容：\n\n{text}"},
|
||
],
|
||
"temperature": 0.1,
|
||
"max_tokens": 1024,
|
||
}).encode("utf-8")
|
||
|
||
headers = {
|
||
"Content-Type": "application/json",
|
||
"Authorization": f"Bearer {api_key}",
|
||
}
|
||
req = urllib_request.Request(
|
||
url=api_url, data=payload, headers=headers, method="POST"
|
||
)
|
||
with urllib_request.urlopen(req, timeout=30) as resp:
|
||
result = json.loads(resp.read().decode("utf-8"))
|
||
|
||
content = result["choices"][0]["message"]["content"]
|
||
return self._extract_json(content)
|
||
|
||
def _extract_json(self, text: str) -> dict:
|
||
"""从 LLM 响应文本中提取 JSON 内容。
|
||
|
||
处理 LLM 可能包裹在 markdown 代码块中的情况，
|
||
以及 LLM 响应被截断导致 JSON 不完整的常见场景。
|
||
|
||
参数：
|
||
text: LLM 原始响应文本。
|
||
|
||
返回：
|
||
解析后的字典。
|
||
"""
|
||
text = text.strip()
|
||
if text.startswith("```"):
|
||
text = text.split("\n", 1)[1]
|
||
text = text.rsplit("```", 1)[0]
|
||
text = text.strip()
|
||
try:
|
||
return json.loads(text)
|
||
except json.JSONDecodeError:
|
||
# LLM 响应可能被截断，尝试截断到最后一个完整 } 修复
|
||
last_brace = text.rfind("}")
|
||
while last_brace > 0:
|
||
try:
|
||
return json.loads(text[:last_brace + 1])
|
||
except json.JSONDecodeError:
|
||
last_brace = text.rfind("}", 0, last_brace - 1)
|
||
raise
|
||
|
||
def safe_parse(self, text: str, product_groups: list[dict],
|
||
api_key: str, api_url: str,
|
||
ocr_context: dict | None = None,
|
||
model: str = "qwen-plus") -> dict | None:
|
||
"""安全版解析入口，异常时返回 None 而非抛出异常。
|
||
|
||
参数：
|
||
text: 待解析的订单文本。
|
||
product_groups: 产品库数据。
|
||
api_key: LLM API 访问密钥。
|
||
api_url: LLM API 地址。
|
||
ocr_context: 可选的 OCR 上下文。
|
||
model: LLM 模型名称。
|
||
|
||
返回：
|
||
解析后的订单字典，失败时返回 None。
|
||
"""
|
||
try:
|
||
return self.parse(text, product_groups, api_key, api_url, ocr_context, model=model)
|
||
except Exception:
|
||
logger.warning("[LLM] 解析失败", exc_info=True)
|
||
return None
|
||
|
||
|
||
# 避免和后面 urllib_request 冲突，这里在文件顶部已经 import 了
|
||
urllib_request = request
|
||
|
||
|
||
class BaseOCRProvider:
|
||
"""OCR 提供者基类，定义统一的识别接口。
|
||
|
||
子类需实现 recognize 方法，返回 (raw_result, suggested_result, confidence) 三元组。
|
||
"""
|
||
provider_name = "base"
|
||
|
||
def recognize(self, image_url: str, biz_type: str, biz_id: int) -> tuple[dict, dict, float]:
|
||
"""识别图片中的文字内容。
|
||
|
||
参数：
|
||
image_url: 图片 URL 地址。
|
||
biz_type: 业务类型标识。
|
||
biz_id: 业务记录 ID。
|
||
|
||
返回：
|
||
三元组 (原始识别结果, 建议结果, 置信度)。
|
||
"""
|
||
raise NotImplementedError
|
||
|
||
|
||
class MockOCRProvider(BaseOCRProvider):
|
||
"""模拟 OCR 提供者，用于开发调试和测试环境。
|
||
|
||
不调用真实 OCR 服务，直接返回固定格式的模拟结果，置信度 0.92。
|
||
"""
|
||
provider_name = "mock_aliyun_adapter"
|
||
|
||
def recognize(self, image_url: str, biz_type: str, biz_id: int) -> tuple[dict, dict, float]:
|
||
"""返回模拟的 OCR 识别结果。
|
||
|
||
参数：
|
||
image_url: 图片 URL 地址。
|
||
biz_type: 业务类型标识。
|
||
biz_id: 业务记录 ID。
|
||
|
||
返回：
|
||
三元组 (模拟原始结果, 模拟建议结果, 0.92)。
|
||
"""
|
||
# 模拟 OCR 识别出的文本行，用于开发调试时走通完整解析流程
|
||
sample_lines = [
|
||
"张三 13800138000",
|
||
"广东省深圳市南山区科技园路88号",
|
||
"产品名称：工业级密封圈",
|
||
"规格：DN50 数量：100件 单价：15.5",
|
||
"合计金额：1550.00",
|
||
"备注：尽快发货",
|
||
]
|
||
suggested_result = {
|
||
"image_name": image_url.rsplit("/", 1)[-1],
|
||
"biz_type": biz_type,
|
||
"biz_id": biz_id,
|
||
"line_list": sample_lines,
|
||
"recognized_text": "\n".join(sample_lines),
|
||
}
|
||
raw_result = {
|
||
"provider": self.provider_name,
|
||
"image_url": image_url,
|
||
"fields": suggested_result,
|
||
}
|
||
return raw_result, suggested_result, 0.92
|
||
|
||
|
||
class AliyunOCRProvider(BaseOCRProvider):
|
||
"""阿里云 OCR 提供者，通过官方 SDK 调用阿里云文字识别服务。
|
||
|
||
依赖 settings 中的 aliyun_ai_access_key_id、aliyun_ai_access_key_secret、
|
||
aliyun_ai_region 等配置。使用 alibabacloud_ocr_api20210707 SDK。
|
||
"""
|
||
provider_name = "aliyun_ocr"
|
||
|
||
ENDPOINT = "ocr-api.cn-hangzhou.aliyuncs.com"
|
||
|
||
def __init__(self, settings) -> None:
|
||
self.settings = settings
|
||
|
||
def recognize(self, image_url: str, biz_type: str, biz_id: int) -> tuple[dict, dict, float]:
|
||
"""调用阿里云 OCR 识别图片中的文字。
|
||
|
||
参数：
|
||
image_url: 图片 URL 地址。
|
||
biz_type: 业务类型标识。
|
||
biz_id: 业务记录 ID。
|
||
|
||
返回：
|
||
三元组 (原始 API 响应, 结构化建议结果, 置信度)。
|
||
"""
|
||
payload = self._call_aliyun(image_url)
|
||
raw_result = {
|
||
"provider": self.provider_name,
|
||
"region": self.settings.aliyun_ai_region,
|
||
"image_url": image_url,
|
||
"payload": payload,
|
||
}
|
||
suggested_result = self._build_suggested_result(payload, image_url, biz_type, biz_id)
|
||
confidence = self._extract_confidence(payload)
|
||
return raw_result, suggested_result, confidence
|
||
|
||
def _get_client(self):
|
||
"""构建阿里云 OCR SDK 客户端。"""
|
||
from alibabacloud_ocr_api20210707.client import Client as OcrClient
|
||
from alibabacloud_tea_openapi.models import Config
|
||
|
||
config = Config(
|
||
access_key_id=self.settings.aliyun_ai_access_key_id,
|
||
access_key_secret=self.settings.aliyun_ai_access_key_secret,
|
||
endpoint=self.ENDPOINT,
|
||
)
|
||
return OcrClient(config)
|
||
|
||
def _call_aliyun(self, image_url: str) -> dict:
|
||
"""通过官方 SDK 调用阿里云 OCR 接口。
|
||
|
||
先从 URL 下载图片字节，再通过 SDK 发送识别请求。
|
||
|
||
参数：
|
||
image_url: 图片 URL 地址。
|
||
|
||
返回：
|
||
阿里云 OCR SDK 的响应字典。
|
||
|
||
异常：
|
||
下载图片失败或 SDK 调用失败时抛出 AppException。
|
||
"""
|
||
from alibabacloud_ocr_api20210707.models import RecognizeGeneralRequest
|
||
|
||
try:
|
||
image_bytes = read_image_bytes(image_url)
|
||
except Exception as exc:
|
||
raise AppException(
|
||
code=ErrorCode.THIRD_PARTY_FAILED,
|
||
message=f"下载 OCR 图片失败：{exc}",
|
||
status_code=400,
|
||
) from exc
|
||
|
||
try:
|
||
client = self._get_client()
|
||
ocr_request = RecognizeGeneralRequest(body=image_bytes)
|
||
response = client.recognize_general(ocr_request)
|
||
except Exception as exc:
|
||
raise AppException(
|
||
code=ErrorCode.THIRD_PARTY_FAILED,
|
||
message=f"阿里云 OCR SDK 调用失败：{exc}",
|
||
status_code=400,
|
||
) from exc
|
||
|
||
body = response.body
|
||
if hasattr(body, "to_map"):
|
||
payload = body.to_map()
|
||
elif isinstance(body, dict):
|
||
payload = body
|
||
else:
|
||
payload = json.loads(str(body)) if body else {}
|
||
|
||
# SDK 返回 Data 为 JSON 字符串，解析为 dict 便于后续统一提取
|
||
if isinstance(payload.get("Data"), str):
|
||
try:
|
||
payload["Data"] = json.loads(payload["Data"])
|
||
except (json.JSONDecodeError, TypeError):
|
||
pass
|
||
|
||
return payload
|
||
|
||
def _build_suggested_result(self, payload: dict, image_url: str, biz_type: str, biz_id: int) -> dict:
|
||
"""将阿里云 OCR 原始响应转换为统一的结构化建议结果。
|
||
|
||
从响应中递归提取文本行，拼接为 recognized_text 和 line_list。
|
||
|
||
参数：
|
||
payload: 阿里云 OCR API 响应字典。
|
||
image_url: 图片 URL 地址。
|
||
biz_type: 业务类型标识。
|
||
biz_id: 业务记录 ID。
|
||
|
||
返回：
|
||
包含 image_name、biz_type、recognized_text、line_list 等字段的建议结果字典。
|
||
"""
|
||
# 不强依赖某个固定响应字段，先把常见 OCR 结果平铺为统一结构，便于前端先联调。
|
||
texts = self._collect_texts(payload)
|
||
result = {
|
||
"image_name": image_url.rsplit("/", 1)[-1],
|
||
"biz_type": biz_type,
|
||
"biz_id": biz_id,
|
||
"recognized_text": "\n".join(texts).strip(),
|
||
"line_list": texts,
|
||
}
|
||
if texts:
|
||
result["customer_name"] = texts[0][:50]
|
||
return result
|
||
|
||
def _collect_texts(self, value) -> list[str]:
|
||
"""从嵌套的字典/列表结构中递归提取所有文本值并去重。
|
||
|
||
识别常见 OCR 响应字段名（text、content、word、words 等），
|
||
跳过空值和重复文本。
|
||
|
||
参数：
|
||
value: OCR 响应中的任意嵌套结构。
|
||
|
||
返回：
|
||
去重后的文本列表，保持原始出现顺序。
|
||
"""
|
||
texts: list[str] = []
|
||
if isinstance(value, dict):
|
||
for key, item in value.items():
|
||
lowered = str(key).lower()
|
||
if lowered in {"text", "content", "word", "words", "value", "label", "title"} and isinstance(item, str):
|
||
stripped = item.strip()
|
||
if stripped:
|
||
texts.append(stripped)
|
||
else:
|
||
texts.extend(self._collect_texts(item))
|
||
elif isinstance(value, list):
|
||
for item in value:
|
||
texts.extend(self._collect_texts(item))
|
||
elif isinstance(value, str):
|
||
stripped = value.strip()
|
||
if stripped:
|
||
texts.append(stripped)
|
||
deduplicated: list[str] = []
|
||
seen: set[str] = set()
|
||
for text in texts:
|
||
if text not in seen:
|
||
seen.add(text)
|
||
deduplicated.append(text)
|
||
return deduplicated
|
||
|
||
def _extract_confidence(self, payload: dict) -> float:
|
||
"""从 OCR 响应中提取置信度分数。
|
||
|
||
依次尝试 confidence、score、probability 字段，未找到时默认返回 0.9。
|
||
|
||
参数：
|
||
payload: OCR API 响应字典。
|
||
|
||
返回：
|
||
置信度浮点数（0.0 ~ 1.0）。
|
||
"""
|
||
for key in ("confidence", "score", "probability"):
|
||
value = payload.get(key)
|
||
if isinstance(value, (int, float)):
|
||
return float(value)
|
||
if isinstance(value, str):
|
||
try:
|
||
return float(value)
|
||
except ValueError:
|
||
continue
|
||
return 0.9
|
||
|
||
|
||
class AIService:
|
||
"""AI 智能业务服务入口。
|
||
|
||
整合 OCR 识别、规则提取、LLM 解析、产品库匹配等能力，
|
||
提供图片识别（recognize_image）、识别结果修正（correct_result）、
|
||
智能填单（parse_order）三大对外接口。
|
||
|
||
依赖：
|
||
- AIRepository：AI 识别日志的存储。
|
||
- get_settings：系统配置，包含 API 密钥和 provider 选择。
|
||
- AuditService：操作审计日志记录。
|
||
"""
|
||
|
||
def __init__(self) -> None:
|
||
self.repository = AIRepository()
|
||
self.settings = get_settings()
|
||
|
||
def recognize_image(self, payload: dict, session: Session | None = None) -> dict:
|
||
"""调用 OCR 识别图片中的文字并保存识别日志。
|
||
|
||
参数：
|
||
payload: 请求数据字典，必含 image_url、biz_type，可选 biz_id。
|
||
session: 数据库会话，不可为 None。
|
||
|
||
返回：
|
||
包含 log_id、raw_result、confidence、suggested_result 的字典。
|
||
|
||
被调用方：ai 路由（图片识别接口）。
|
||
"""
|
||
image_url = (payload.get("image_url") or "").strip()
|
||
biz_type = (payload.get("biz_type") or "").strip()
|
||
biz_id = payload.get("biz_id")
|
||
|
||
if not image_url:
|
||
raise AppException(code=ErrorCode.PARAM_ERROR, message="图片地址不能为空", status_code=400)
|
||
if not biz_type:
|
||
raise AppException(code=ErrorCode.PARAM_ERROR, message="业务类型不能为空", status_code=400)
|
||
if image_url.startswith("mock://fail"):
|
||
raise AppException(code=ErrorCode.THIRD_PARTY_FAILED, message="AI 识别失败", status_code=400)
|
||
|
||
provider = self._build_provider()
|
||
raw_result, suggested_result, confidence = provider.recognize(image_url, biz_type, int(biz_id or 0))
|
||
|
||
if session is not None:
|
||
try:
|
||
# 识别原始响应和建议结果都落库，后面人工修正和问题回溯都依赖这份快照。
|
||
log = self.repository.create_log(
|
||
session,
|
||
{
|
||
"biz_type": biz_type,
|
||
"biz_id": biz_id,
|
||
"image_url": image_url,
|
||
"raw_result": json.dumps(raw_result, ensure_ascii=False),
|
||
"confidence": Decimal(str(confidence)),
|
||
"corrected_result": None,
|
||
"created_by": None,
|
||
},
|
||
)
|
||
audit_service.write_log(
|
||
session,
|
||
{
|
||
"operate_type": "ai_recognize",
|
||
"biz_type": biz_type,
|
||
"biz_id": biz_id,
|
||
"before_value": None,
|
||
"after_value": {
|
||
"log_id": log.id,
|
||
"provider": raw_result.get("provider"),
|
||
"confidence": confidence,
|
||
"suggested_result": suggested_result,
|
||
},
|
||
"remark": f"AI识别图片 {image_url}",
|
||
},
|
||
)
|
||
session.commit()
|
||
return {
|
||
"log_id": log.id,
|
||
"raw_result": raw_result,
|
||
"confidence": confidence,
|
||
"suggested_result": suggested_result,
|
||
}
|
||
except AppException:
|
||
session.rollback()
|
||
raise
|
||
except SQLAlchemyError as exc:
|
||
session.rollback()
|
||
raise AppException(code=ErrorCode.INTERNAL_ERROR, message="数据库异常", status_code=500) from exc
|
||
|
||
raise AppException(code=ErrorCode.INTERNAL_ERROR, message="数据库连接不可用", status_code=500)
|
||
|
||
def correct_result(self, log_id: int, payload: dict, session: Session | None = None) -> dict:
|
||
"""人工修正 AI 识别结果并保存。
|
||
|
||
参数：
|
||
log_id: AI 识别日志 ID。
|
||
payload: 修正数据字典，必含 corrected_result（dict）。
|
||
session: 数据库会话，不可为 None。
|
||
|
||
返回：
|
||
包含 log_id 和 corrected 标志的字典。
|
||
|
||
被调用方：ai 路由（识别结果修正接口）。
|
||
"""
|
||
corrected_result = payload.get("corrected_result")
|
||
if not isinstance(corrected_result, dict) or not corrected_result:
|
||
raise AppException(code=ErrorCode.PARAM_ERROR, message="修正结果不能为空", status_code=400)
|
||
|
||
if session is not None:
|
||
try:
|
||
log = self.repository.get_log(session, log_id)
|
||
if log is None:
|
||
raise AppException(code=ErrorCode.NOT_FOUND, message="识别记录不存在", status_code=404)
|
||
before_value = self._safe_load_json(log.corrected_result)
|
||
log.corrected_result = json.dumps(corrected_result, ensure_ascii=False)
|
||
session.add(log)
|
||
audit_service.write_log(
|
||
session,
|
||
{
|
||
"operate_type": "ai_correct",
|
||
"biz_type": log.biz_type,
|
||
"biz_id": log.biz_id,
|
||
"before_value": before_value,
|
||
"after_value": corrected_result,
|
||
"remark": f"修正AI识别结果 {log_id}",
|
||
},
|
||
)
|
||
session.commit()
|
||
return {"log_id": log.id, "corrected": True}
|
||
except AppException:
|
||
session.rollback()
|
||
raise
|
||
except SQLAlchemyError as exc:
|
||
session.rollback()
|
||
raise AppException(code=ErrorCode.INTERNAL_ERROR, message="数据库异常", status_code=500) from exc
|
||
|
||
raise AppException(code=ErrorCode.INTERNAL_ERROR, message="数据库连接不可用", status_code=500)
|
||
|
||
def _build_provider(self) -> BaseOCRProvider:
|
||
"""根据系统配置构建对应的 OCR 提供者实例。
|
||
|
||
当 ai_provider 配置为 'aliyun' 时返回 AliyunOCRProvider，否则返回 MockOCRProvider。
|
||
|
||
返回：
|
||
OCR 提供者实例。
|
||
"""
|
||
provider_name = self.settings.ai_provider.strip().lower()
|
||
# provider 选择集中在这里，后续扩展腾讯云或本地 OCR 时不需要动主流程。
|
||
if provider_name == "aliyun":
|
||
return AliyunOCRProvider(self.settings)
|
||
return MockOCRProvider()
|
||
|
||
def _safe_load_json(self, value: str | None):
|
||
"""安全解析 JSON 字符串，异常时返回原始值或 None。
|
||
|
||
参数：
|
||
value: JSON 字符串或 None。
|
||
|
||
返回：
|
||
解析后的对象，解析失败返回原始字符串，空值返回 None。
|
||
"""
|
||
if not value:
|
||
return None
|
||
try:
|
||
return json.loads(value)
|
||
except json.JSONDecodeError:
|
||
return value
|
||
|
||
# ------------------------------------------------------------------
|
||
# 智能填单：核心解析入口
|
||
# ------------------------------------------------------------------
|
||
|
||
def parse_order(self, payload: dict, session: Session | None = None) -> dict:
|
||
"""智能填单核心入口：从文本或图片中解析订单信息。
|
||
|
||
处理流程：
|
||
1. 获取原始文本（图片模式先调 OCR）
|
||
2. 文本预处理（去噪声）
|
||
3. 规则提取（正则提取手机号、数量、价格、地址）
|
||
4. LLM 结构化解析
|
||
5. 规则结果与 LLM 结果合并
|
||
6. 客户库预匹配
|
||
7. 产品库模糊匹配
|
||
8. 校验并计算置信度
|
||
|
||
参数：
|
||
payload: 请求数据字典，必含 input_type（'text' 或 'image'），
|
||
text 模式需提供 text 字段，image 模式需提供 image_url 字段。
|
||
session: 数据库会话，为 None 时使用 mock 模式。
|
||
|
||
返回：
|
||
包含 parsed_order、raw_text、confidence、parse_source、product_matches、
|
||
factory_options、warnings 的字典。
|
||
|
||
被调用方：ai 路由（智能填单接口）。
|
||
"""
|
||
input_type = payload["input_type"]
|
||
|
||
# 1. 获取原始文本 + OCR 中间结果
|
||
ocr_context = None
|
||
if input_type == "image":
|
||
ocr_context = self._ocr_and_parse_image(payload["image_url"])
|
||
raw_text = ocr_context["raw_text"]
|
||
else:
|
||
raw_text = payload["text"].strip()
|
||
|
||
# 2. 文本预处理
|
||
preprocessor = TextPreprocessor()
|
||
raw_text = preprocessor.preprocess(raw_text)
|
||
if not raw_text:
|
||
raise AppException(
|
||
code=ErrorCode.PARAM_ERROR,
|
||
message="无法提取到文本内容",
|
||
status_code=400,
|
||
)
|
||
|
||
# 3. 多订单切分（text 模式下，按手机号锚点拆分为独立订单段）
|
||
chunks = self._split_orders(raw_text) if input_type == "text" else [raw_text]
|
||
|
||
# 4. 正则提取（整段提取手机号等确定性字段）
|
||
rule_extractor = RuleExtractor()
|
||
rule_result = rule_extractor.extract(raw_text)
|
||
if ocr_context and ocr_context.get("pre_filled"):
|
||
for key, value in ocr_context["pre_filled"].items():
|
||
if value and not rule_result.get(key):
|
||
rule_result[key] = value
|
||
|
||
# 5. LLM 结构化解析（每个订单段独立解析）
|
||
settings = self.settings
|
||
product_groups = self._get_product_groups(session)
|
||
logger.info("[智能填单] product_groups 数量: %d", len(product_groups))
|
||
if product_groups:
|
||
logger.info("[智能填单] 产品列表: %s", [g["product_name"] for g in product_groups[:10]])
|
||
llm_parser = LLMOrderParser()
|
||
|
||
if len(chunks) == 1:
|
||
llm_result = llm_parser.safe_parse(
|
||
chunks[0], product_groups,
|
||
settings.llm_parse_api_key or settings.aliyun_ai_access_key_id,
|
||
settings.llm_parse_api_url,
|
||
ocr_context=ocr_context,
|
||
model=settings.llm_parse_model,
|
||
)
|
||
else:
|
||
# 多段时逐段解析，合并 items
|
||
all_items = []
|
||
merged_customer = {}
|
||
for chunk in chunks:
|
||
chunk_result = llm_parser.safe_parse(
|
||
chunk, product_groups,
|
||
settings.llm_parse_api_key or settings.aliyun_ai_access_key_id,
|
||
settings.llm_parse_api_url,
|
||
model=settings.llm_parse_model,
|
||
)
|
||
if chunk_result:
|
||
all_items.extend(chunk_result.get("items", []))
|
||
for key in ("customer_name", "customer_mobile", "customer_address", "remark"):
|
||
if chunk_result.get(key) and not merged_customer.get(key):
|
||
merged_customer[key] = chunk_result[key]
|
||
llm_result = {**merged_customer, "items": all_items} if all_items else None
|
||
|
||
# 5. 合并
|
||
if llm_result:
|
||
# 标准化 demand_specification 中的单位格式
|
||
for item in llm_result.get("items", []):
|
||
if item.get("demand_specification"):
|
||
item["demand_specification"] = self._standardize_demand_specification(
|
||
item["demand_specification"]
|
||
)
|
||
merged = self._merge_results(rule_result, llm_result)
|
||
parse_source = "hybrid"
|
||
else:
|
||
merged = self._build_fallback_result(rule_result)
|
||
parse_source = "rule"
|
||
|
||
# 5.5 地址后处理：清理 LLM 可能混入的非地址内容
|
||
if merged.get("customer_address"):
|
||
merged["customer_address"] = self._clean_address(
|
||
merged["customer_address"], raw_text
|
||
)
|
||
if merged.get("customer_mobile") and not merged.get("customer_address"):
|
||
merged["customer_address"] = self._extract_address_after_phone(
|
||
raw_text, merged["customer_mobile"]
|
||
)
|
||
|
||
# 6. 客户库预匹配
|
||
if session is not None and merged.get("customer_mobile"):
|
||
try:
|
||
from backend.app.repositories.customer_repository import CustomerRepository
|
||
customer_repo = CustomerRepository()
|
||
existing_customer = customer_repo.find_by_mobile(
|
||
session, merged["customer_mobile"]
|
||
)
|
||
if existing_customer:
|
||
merged["customer_id"] = existing_customer.id
|
||
if existing_customer.address and not merged.get("customer_address"):
|
||
merged["customer_address"] = existing_customer.address
|
||
except Exception:
|
||
pass
|
||
|
||
# 7. 产品库模糊匹配
|
||
product_matches = self._match_products(
|
||
merged.get("items", []), product_groups, session
|
||
)
|
||
for pm in product_matches:
|
||
logger.info("[智能填单] 匹配: input=%s → 候选数=%d, 候选=%s",
|
||
pm["input_name"], len(pm["candidates"]),
|
||
[(c["product_name"], c["match_score"]) for c in pm["candidates"][:3]])
|
||
|
||
# 8. 校验 + 置信度
|
||
warnings = self._validate_parsed_order(merged)
|
||
if parse_source == "rule":
|
||
warnings.append("LLM 服务不可用，仅使用规则提取，部分字段可能不完整")
|
||
ocr_conf = ocr_context["ocr_confidence"] if ocr_context else None
|
||
confidence = self._calc_confidence(merged, warnings, ocr_confidence=ocr_conf)
|
||
|
||
return {
|
||
"parsed_order": merged,
|
||
"raw_text": raw_text,
|
||
"confidence": confidence,
|
||
"ocr_confidence": ocr_conf,
|
||
"parse_source": parse_source,
|
||
"is_mock": session is None,
|
||
"product_matches": product_matches,
|
||
"factory_options": self._get_factory_options(session),
|
||
"warnings": warnings,
|
||
}
|
||
|
||
_PHONE_ANCHOR_RE = re.compile(r'1[3-9]\d{9}')
|
||
|
||
def _split_orders(self, text: str) -> list[str]:
|
||
"""按手机号锚点将多条订单文本切分为独立段。
|
||
|
||
每个手机号标记一段客户信息的开始，手机号之前的行归为该段的产品行。
|
||
如果文本中只有一个手机号，返回原始文本（不分切）。
|
||
|
||
参数：
|
||
text: 预处理后的订单文本。
|
||
|
||
返回：
|
||
订单文本段列表，每段包含产品行和客户信息行。
|
||
"""
|
||
lines = text.split('\n')
|
||
anchors: list[tuple[int, str]] = []
|
||
for i, line in enumerate(lines):
|
||
match = self._PHONE_ANCHOR_RE.search(line)
|
||
if match:
|
||
anchors.append((i, match.group(0)))
|
||
if len(anchors) <= 1:
|
||
return [text]
|
||
chunks: list[str] = []
|
||
for idx, (line_idx, _phone) in enumerate(anchors):
|
||
start = anchors[idx - 1][0] + 1 if idx > 0 else 0
|
||
chunk_lines = lines[start:line_idx + 1]
|
||
chunk = '\n'.join(chunk_lines).strip()
|
||
if chunk:
|
||
chunks.append(chunk)
|
||
return chunks
|
||
|
||
_ADDRESS_KEYWORDS = {'省', '市', '区', '县', '镇', '路', '街', '号', '楼', '室', '栋', '村', '巷', '园'}
|
||
_ORDER_NO_RE = re.compile(r'[A-Z]{2,}[\d\-+]+') # SYY+5681, SO20260604 等订单号
|
||
|
||
def _clean_address(self, address: str, raw_text: str) -> str:
|
||
"""清理 LLM 返回的地址，去除混入的非地址内容。
|
||
|
||
如果地址中包含手机号或产品关键词，说明 LLM 没有正确拆分，
|
||
此时从原始文本中重新提取。
|
||
"""
|
||
if not address:
|
||
return address
|
||
# 如果地址中包含手机号，说明 LLM 把整段文本塞进了地址
|
||
if self._PHONE_ANCHOR_RE.search(address):
|
||
phone_match = self._PHONE_ANCHOR_RE.search(raw_text)
|
||
if phone_match:
|
||
return self._extract_address_after_phone(raw_text, phone_match.group(0))
|
||
return ""
|
||
# 去除订单号
|
||
address = self._ORDER_NO_RE.sub('', address).strip()
|
||
# 去除开头的逗号/空格
|
||
address = address.lstrip('，,、 \t')
|
||
# 如果清理后地址关键词密度太低，说明不是有效地址
|
||
addr_hits = sum(1 for kw in self._ADDRESS_KEYWORDS if kw in address)
|
||
if addr_hits < 1 and len(address) > 5:
|
||
# 可能是 LLM 误填，尝试从原始文本提取
|
||
phone_match = self._PHONE_ANCHOR_RE.search(raw_text)
|
||
if phone_match:
|
||
return self._extract_address_after_phone(raw_text, phone_match.group(0))
|
||
return address
|
||
|
||
def _extract_address_after_phone(self, text: str, phone: str) -> str:
|
||
"""从原始文本中提取手机号之后的地址信息。"""
|
||
idx = text.find(phone)
|
||
if idx < 0:
|
||
return ""
|
||
after = text[idx + len(phone):].strip()
|
||
# 去掉开头的逗号/空格/顿号
|
||
after = after.lstrip('，,、 \t')
|
||
return after if after else ""
|
||
|
||
def _ocr_and_parse_image(self, image_url: str) -> dict:
|
||
"""调用 OCR 识别图片并进行版面分析。
|
||
|
||
参数：
|
||
image_url: 图片 URL 地址。
|
||
|
||
返回：
|
||
OrderOCRParser.parse() 的返回结果，包含 raw_text、pre_filled、table_rows 等。
|
||
"""
|
||
provider = self._build_provider()
|
||
raw_result, suggested_result, ocr_confidence = provider.recognize(
|
||
image_url, "order_parse", 0
|
||
)
|
||
line_list = suggested_result.get("line_list", [])
|
||
if not line_list:
|
||
text = suggested_result.get("recognized_text", "")
|
||
line_list = [line for line in text.split("\n") if line.strip()]
|
||
ocr_parser = OrderOCRParser()
|
||
return ocr_parser.parse(line_list, ocr_confidence)
|
||
|
||
def _merge_results(self, rule_result: dict, llm_result: dict) -> dict:
|
||
"""合并规则提取结果和 LLM 解析结果。
|
||
|
||
以 LLM 结果为基础，规则提取的手机号优先使用，地址取较长者。
|
||
|
||
参数：
|
||
rule_result: 规则提取结果。
|
||
llm_result: LLM 解析结果。
|
||
|
||
返回：
|
||
合并后的订单字典。
|
||
"""
|
||
merged = dict(llm_result)
|
||
if rule_result.get("customer_mobile"):
|
||
merged["customer_mobile"] = rule_result["customer_mobile"]
|
||
rule_addr = rule_result.get("customer_address", "")
|
||
llm_addr = merged.get("customer_address", "")
|
||
if rule_addr and len(rule_addr) > len(llm_addr or ""):
|
||
merged["customer_address"] = rule_addr
|
||
return merged
|
||
|
||
def _build_fallback_result(self, rule_result: dict) -> dict:
|
||
"""当 LLM 不可用时，仅基于规则提取结果构建订单数据。
|
||
|
||
参数：
|
||
rule_result: 规则提取结果。
|
||
|
||
返回：
|
||
包含基础订单字段的字典，产品明细可能不完整。
|
||
"""
|
||
items: list[dict] = []
|
||
if rule_result.get("_raw_quantity"):
|
||
items.append({
|
||
"product_name": "",
|
||
"specification": "",
|
||
"unit": rule_result.get("_raw_unit", ""),
|
||
"quantity": rule_result["_raw_quantity"],
|
||
"sale_price": rule_result.get("_raw_price", 0),
|
||
"cost_price": None,
|
||
})
|
||
return {
|
||
"customer_name": rule_result.get("customer_name"),
|
||
"customer_mobile": rule_result.get("customer_mobile"),
|
||
"customer_address": rule_result.get("customer_address"),
|
||
"order_source": None,
|
||
"delivery_type": None,
|
||
"factory_id": None,
|
||
"remark": None,
|
||
"items": items,
|
||
}
|
||
|
||
def _get_product_groups(self, session: Session | None) -> list[dict]:
|
||
"""获取产品库数据，用于构建 LLM 提示词和模糊匹配。"""
|
||
if session is None:
|
||
return []
|
||
# 优先走 product_service（有缓存和分组逻辑）
|
||
try:
|
||
from backend.app.services.product_service import product_service
|
||
result = product_service.list_products({}, session)
|
||
groups = result.get("list", [])
|
||
if groups:
|
||
logger.info("[智能填单] _get_product_groups 返回 %d 个产品组", len(groups))
|
||
return groups
|
||
except Exception:
|
||
logger.warning("[智能填单] product_service 异常，尝试直查", exc_info=True)
|
||
# product_service 失败或返回空时，直查 Product 表兜底
|
||
try:
|
||
from backend.app.models.business import Product
|
||
stmt = select(Product).where(Product.deleted == 0).limit(100)
|
||
products = list(session.execute(stmt).scalars())
|
||
if products:
|
||
grouped: dict[str, dict] = {}
|
||
for p in products:
|
||
entry = grouped.setdefault(p.product_name, {
|
||
"product_name": p.product_name,
|
||
"product_id": p.id,
|
||
"specifications": [],
|
||
})
|
||
entry["specifications"].append({
|
||
"product_id": p.id,
|
||
"specification": p.specification,
|
||
"unit": p.unit,
|
||
"sale_price": float(p.sale_price or 0),
|
||
"cost_price": float(p.cost_price or 0),
|
||
})
|
||
logger.info("[智能填单] DB兜底: 从 Product 表直查到 %d 个产品组", len(grouped))
|
||
return list(grouped.values())
|
||
except Exception:
|
||
logger.warning("[智能填单] Product 表直查也失败", exc_info=True)
|
||
return []
|
||
|
||
_PRODUCT_ALIASES = {
|
||
"咖色": "咖啡色", "咖啡": "咖啡色",
|
||
"高温布": "高温布", "耐高温布": "高温布", "防火布": "高温布",
|
||
"网格带": "网格输送带",
|
||
"烧烤垫": "烧烤网格片",
|
||
"特氟龙": "特氟龙玻纤胶带",
|
||
}
|
||
|
||
# 输送带上下文关键词：命中任一则判定为输送带场景
|
||
_CONVEYOR_KEYWORDS = {
|
||
"包边", "红膜包边", "黑膜包边", "高温布包边", "凯夫拉包边",
|
||
"接头", "平接", "搭接", "斜接", "牛鼻子接头", "钢扣接头", "螺旋接头",
|
||
"上下盖布搭接", "上下盖布",
|
||
"导条", "凯夫拉导条", "硅胶导条", "四氟导条",
|
||
"柳丁", "鱼眼",
|
||
}
|
||
# 明确指向网格输送带的关键词
|
||
_CONVEYOR_MESH_KEYWORDS = {"网格", "网带", "特氟龙网格"}
|
||
|
||
# 胶带精确映射：关键词 -> 目标产品名
|
||
_TAPE_EXACT_MAP = {
|
||
"膜胶带": "特氟龙纯膜胶带",
|
||
}
|
||
_TAPE_FIBER_KEYWORDS = {"特氟龙胶带", "铁氟龙胶带", "小卷胶带"}
|
||
|
||
# 日用品高温布关键词（不含"高温布"本身，太泛会误命中工业场景）
|
||
_DAILY_CLOTH_KEYWORDS = {"拼豆", "烫布", "煤气灶垫", "烧烤垫"}
|
||
|
||
_PREFIX_STRIP_RE = re.compile(
|
||
r'^[\d.]+\s*(?:mm|cm|m|丝|g)\s*' # 厚度前缀: 0.13mm, 145g
|
||
r'|^(?:咖色|咖啡色|黑色|白色|灰色|红色|蓝色|绿色)' # 颜色前缀
|
||
)
|
||
|
||
# 数据库产品名带型号后缀，如 "高温布-SYY+5681"，需去掉后缀再比较
|
||
_MODEL_SUFFIX_RE = re.compile(r'[-_][A-Za-z0-9+]+$')
|
||
|
||
# 厚度提取：匹配 "0.13mm"、"0.13"、"18丝" 等
|
||
_THICKNESS_RE = re.compile(r'(\d+\.\d+)\s*(?:mm|毫米|丝)?', re.IGNORECASE)
|
||
# 克重提取：匹配 "145g"、"145克" 等
|
||
_WEIGHT_RE = re.compile(r'(\d+)\s*(?:g|克|G)(?:\s|$|[^a-zA-Z])')
|
||
|
||
def _normalize_product_name(self, name: str) -> str:
|
||
"""去除产品名中的厚度/颜色前缀和型号后缀，提取核心材料名。"""
|
||
normalized = self._PREFIX_STRIP_RE.sub('', name).strip()
|
||
normalized = self._MODEL_SUFFIX_RE.sub('', normalized).strip()
|
||
return self._PRODUCT_ALIASES.get(normalized, normalized)
|
||
|
||
def _extract_thickness(self, text: str) -> str | None:
|
||
"""从文本中提取厚度值并归一化为无小数点字符串。
|
||
|
||
例: "0.13mm" -> "013", "0.08" -> "008"
|
||
"""
|
||
if not text:
|
||
return None
|
||
m = self._THICKNESS_RE.search(text)
|
||
if m:
|
||
return m.group(1).replace('.', '')
|
||
return None
|
||
|
||
def _extract_weight(self, text: str) -> str | None:
|
||
"""从文本中提取克重数值。
|
||
|
||
例: "145g" -> "145", "200克" -> "200"
|
||
"""
|
||
if not text:
|
||
return None
|
||
m = self._WEIGHT_RE.search(text)
|
||
if m:
|
||
return m.group(1)
|
||
return None
|
||
|
||
def _apply_rule_matching(self, input_name: str, input_spec: str,
|
||
item_remark: str, demand_spec: str,
|
||
flat_products: list[dict]) -> list[tuple[dict, float]]:
|
||
"""规则匹配层：对特定业务场景返回精确候选，避免依赖模糊匹配。
|
||
|
||
返回: [(product, score), ...] 或空列表（表示无规则命中，走通用匹配）。
|
||
"""
|
||
combined_text = f"{input_name} {input_spec} {demand_spec or ''} {item_remark or ''}"
|
||
|
||
# --- 输送带规则 ---
|
||
if any(kw in combined_text for kw in self._CONVEYOR_KEYWORDS):
|
||
is_mesh = any(kw in combined_text for kw in self._CONVEYOR_MESH_KEYWORDS)
|
||
target = "网格输送带" if is_mesh else "高温布"
|
||
hits = []
|
||
for prod in flat_products:
|
||
pname = prod["product_name"]
|
||
if target in pname or pname in target:
|
||
hits.append((prod, 0.95))
|
||
if hits:
|
||
return hits
|
||
|
||
# --- 胶带规则 ---
|
||
for kw, target in self._TAPE_EXACT_MAP.items():
|
||
if kw in combined_text:
|
||
hits = []
|
||
for prod in flat_products:
|
||
if target in prod["product_name"] or prod["product_name"] in target:
|
||
hits.append((prod, 0.95))
|
||
if hits:
|
||
return hits
|
||
if any(kw in combined_text for kw in self._TAPE_FIBER_KEYWORDS):
|
||
hits = []
|
||
for prod in flat_products:
|
||
if "特氟龙玻纤胶带" in prod["product_name"] or prod["product_name"] in "特氟龙玻纤胶带":
|
||
hits.append((prod, 0.95))
|
||
elif "胶带" in prod["product_name"] and "纯膜" not in prod["product_name"]:
|
||
hits.append((prod, 0.85))
|
||
if hits:
|
||
return hits
|
||
|
||
# --- 日用品高温布规则 ---
|
||
if any(kw in combined_text for kw in self._DAILY_CLOTH_KEYWORDS):
|
||
weight = self._extract_weight(combined_text)
|
||
hits = []
|
||
for prod in flat_products:
|
||
pname = prod["product_name"]
|
||
spec = prod.get("specification", "")
|
||
# 日用品方向产品优先
|
||
is_daily = "日用品" in pname or "日用品" in prod.get("category_name", "")
|
||
weight_match = weight and weight in spec
|
||
if is_daily:
|
||
score = 0.95 if weight_match else 0.85
|
||
hits.append((prod, score))
|
||
elif weight_match and ("高温布" in pname or "高温布" in spec):
|
||
hits.append((prod, 0.75))
|
||
if hits:
|
||
hits.sort(key=lambda x: x[1], reverse=True)
|
||
return hits
|
||
|
||
# --- 揉面垫 / 硅胶烤垫规则：厚度主导 ---
|
||
if "揉面垫" in combined_text or "硅胶烤垫" in combined_text:
|
||
thickness = self._extract_thickness(combined_text)
|
||
hits = []
|
||
for prod in flat_products:
|
||
pname = prod["product_name"]
|
||
spec = prod.get("specification", "")
|
||
if "揉面垫" in combined_text and "揉面垫" not in pname:
|
||
continue
|
||
if "硅胶烤垫" in combined_text and "硅胶烤垫" not in pname:
|
||
continue
|
||
if thickness and thickness in spec.replace('.', ''):
|
||
hits.append((prod, 0.95))
|
||
else:
|
||
hits.append((prod, 0.6))
|
||
if hits:
|
||
hits.sort(key=lambda x: x[1], reverse=True)
|
||
return hits
|
||
|
||
return []
|
||
|
||
def _score_with_thickness(self, input_name: str, input_spec: str,
|
||
prod: dict, base_score: float) -> float:
|
||
"""在基础分数上叠加厚度/克重匹配加权。"""
|
||
combined = f"{input_name} {input_spec}"
|
||
thickness = self._extract_thickness(combined)
|
||
weight = self._extract_weight(combined)
|
||
spec = prod.get("specification", "")
|
||
|
||
bonus = 0.0
|
||
if thickness and thickness in spec.replace('.', ''):
|
||
bonus = 0.3
|
||
elif weight and weight in spec:
|
||
bonus = 0.25
|
||
|
||
return min(base_score + bonus, 1.0)
|
||
|
||
def _match_products(self, items: list[dict],
|
||
product_groups: list[dict],
|
||
session: Session | None) -> list[dict]:
|
||
"""对解析出的产品明细进行库内模糊匹配。
|
||
|
||
优先走规则匹配（输送带/胶带/揉面垫等），再走通用模糊匹配，
|
||
最后 DB 兜底。
|
||
|
||
参数：
|
||
items: 解析出的产品明细列表。
|
||
product_groups: 产品库分组数据。
|
||
session: 数据库会话。
|
||
|
||
返回：
|
||
匹配结果列表，每个元素包含 input_name、input_specification、candidates。
|
||
"""
|
||
flat_products: list[dict] = []
|
||
for group in product_groups:
|
||
for spec in group.get("specifications", []):
|
||
flat_products.append({
|
||
"product_id": spec["product_id"],
|
||
"product_name": group["product_name"],
|
||
"specification": spec["specification"],
|
||
"unit": spec["unit"],
|
||
"sale_price": spec.get("sale_price", 0),
|
||
"cost_price": spec.get("cost_price", 0),
|
||
"category_id": group.get("category_id"),
|
||
"category_name": group.get("category_name", ""),
|
||
})
|
||
matches: list[dict] = []
|
||
for item in items:
|
||
input_name = item.get("product_name", "")
|
||
input_spec = item.get("specification", "")
|
||
item_remark = item.get("remark", "")
|
||
demand_spec = item.get("demand_specification", "")
|
||
if not input_name:
|
||
continue
|
||
normalized_input = self._normalize_product_name(input_name)
|
||
|
||
# 1. 规则匹配层（业务场景优先）
|
||
rule_hits = self._apply_rule_matching(
|
||
input_name, input_spec, item_remark, demand_spec, flat_products
|
||
)
|
||
|
||
scored: list[tuple] = []
|
||
if rule_hits:
|
||
scored = rule_hits
|
||
else:
|
||
# 2. 通用模糊匹配
|
||
for prod in flat_products:
|
||
normalized_prod = self._normalize_product_name(prod["product_name"])
|
||
if normalized_input == normalized_prod:
|
||
base = 1.0
|
||
else:
|
||
name_score = SequenceMatcher(None, normalized_input, normalized_prod).ratio()
|
||
if normalized_prod in normalized_input or normalized_input in normalized_prod:
|
||
name_score = max(name_score, 0.85)
|
||
spec_score = SequenceMatcher(None, input_spec, prod["specification"]).ratio() if input_spec else 0
|
||
base = name_score * 0.5 + spec_score * 0.3
|
||
# 叠加厚度/克重加权
|
||
final_score = self._score_with_thickness(input_name, input_spec, prod, base)
|
||
scored.append((prod, final_score))
|
||
|
||
scored.sort(key=lambda x: x[1], reverse=True)
|
||
candidates = [
|
||
{
|
||
"product_id": prod["product_id"],
|
||
"product_name": prod["product_name"],
|
||
"specification": prod["specification"],
|
||
"unit": prod["unit"],
|
||
"sale_price": prod["sale_price"],
|
||
"cost_price": prod["cost_price"],
|
||
"match_score": round(score, 2),
|
||
}
|
||
for prod, score in scored[:3] if score > 0.25
|
||
]
|
||
# 3. 内存匹配失败时，直接查数据库兜底
|
||
if not candidates and session is not None:
|
||
logger.info("[智能填单] 内存匹配失败, input=%s, normalized=%s, 尝试DB兜底",
|
||
input_name, normalized_input)
|
||
candidates = self._db_fallback_match(input_name, normalized_input, session)
|
||
logger.info("[智能填单] DB兜底结果: %s", [(c["product_name"], c["product_id"]) for c in candidates])
|
||
matches.append({
|
||
"input_name": input_name,
|
||
"input_specification": input_spec,
|
||
"candidates": candidates,
|
||
})
|
||
return matches
|
||
|
||
def _db_fallback_match(self, input_name: str, normalized_input: str,
|
||
session: Session) -> list[dict]:
|
||
"""内存匹配失败时，直接查 Product 表兜底。"""
|
||
from backend.app.models.business import Product
|
||
try:
|
||
# 用 LIKE 按产品名模糊搜索
|
||
stmt = select(Product).where(
|
||
Product.deleted == 0,
|
||
Product.product_name.contains(normalized_input),
|
||
).limit(5)
|
||
products = list(session.execute(stmt).scalars())
|
||
if not products:
|
||
# 试一下原始输入名（可能 LLM 返回了带型号的全名）
|
||
stmt = select(Product).where(
|
||
Product.deleted == 0,
|
||
Product.product_name.contains(input_name),
|
||
).limit(5)
|
||
products = list(session.execute(stmt).scalars())
|
||
results = []
|
||
for p in products:
|
||
results.append({
|
||
"product_id": p.id,
|
||
"product_name": p.product_name,
|
||
"specification": p.specification,
|
||
"unit": p.unit,
|
||
"sale_price": float(p.sale_price or 0),
|
||
"cost_price": float(p.cost_price or 0),
|
||
"match_score": 0.8,
|
||
})
|
||
return results[:3]
|
||
except Exception:
|
||
return []
|
||
|
||
def _validate_parsed_order(self, order: dict) -> list[str]:
|
||
"""校验解析后的订单数据完整性，生成警告列表。
|
||
|
||
检查项：客户姓名、手机号、产品明细、产品名称、数量。
|
||
|
||
参数：
|
||
order: 解析后的订单字典。
|
||
|
||
返回：
|
||
警告信息列表，无警告时返回空列表。
|
||
"""
|
||
warnings: list[str] = []
|
||
if not order.get("customer_name"):
|
||
warnings.append("未识别到客户姓名")
|
||
if not order.get("customer_mobile"):
|
||
warnings.append("未识别到客户手机号")
|
||
if not order.get("items"):
|
||
warnings.append("未识别到产品明细")
|
||
for item in order.get("items", []):
|
||
if not item.get("product_name"):
|
||
warnings.append("存在产品名称为空的明细行")
|
||
if not item.get("quantity"):
|
||
warnings.append(f"产品 {item.get('product_name', '?')} 未识别到数量")
|
||
return warnings
|
||
|
||
def _calc_confidence(self, order: dict, warnings: list[str],
|
||
ocr_confidence: float | None = None) -> float:
|
||
"""计算综合置信度分数。
|
||
|
||
计算规则：以 OCR 置信度（默认 1.0）为基础，每个警告扣 0.1，
|
||
每个缺少单价的产品扣 0.05，最低不低于 0.1。
|
||
|
||
参数：
|
||
order: 解析后的订单字典。
|
||
warnings: 警告列表。
|
||
ocr_confidence: OCR 置信度，可选。
|
||
|
||
返回：
|
||
综合置信度（0.1 ~ 1.0）。
|
||
"""
|
||
base = 1.0
|
||
if ocr_confidence is not None:
|
||
base = ocr_confidence
|
||
base -= len(warnings) * 0.1
|
||
if order.get("items"):
|
||
for item in order["items"]:
|
||
if not item.get("sale_price"):
|
||
base -= 0.05
|
||
return round(max(base, 0.1), 2)
|
||
|
||
# ------------------------------------------------------------------
|
||
# 单位标准化：统一 demand_specification 中的单位格式
|
||
# ------------------------------------------------------------------
|
||
|
||
# 长度单位映射：中文/英文 -> 标准单位
|
||
_LENGTH_UNIT_MAP = {
|
||
"cm": "cm", "厘米": "cm",
|
||
"m": "m", "米": "m",
|
||
"mm": "mm", "毫米": "mm",
|
||
}
|
||
|
||
# 重量单位映射：中文/英文 -> 标准单位
|
||
_WEIGHT_UNIT_MAP = {
|
||
"g": "g", "克": "g",
|
||
"kg": "kg", "公斤": "kg",
|
||
"jin": "斤", "斤": "斤",
|
||
}
|
||
|
||
# 长度尺寸匹配正则：数字 + 可选单位 × 数字 + 可选单位
|
||
_LENGTH_SPEC_RE = re.compile(
|
||
r'([\d.]+)\s*(cm|厘米|m|米|mm|毫米)?\s*[×xX*]\s*([\d.]+)\s*(cm|厘米|m|米|mm|毫米)?',
|
||
re.IGNORECASE
|
||
)
|
||
|
||
# 重量匹配正则：数字 + 单位
|
||
_WEIGHT_SPEC_RE = re.compile(
|
||
r'([\d.]+)\s*(g|克|kg|公斤|斤)',
|
||
re.IGNORECASE
|
||
)
|
||
|
||
def _standardize_demand_specification(self, spec: str) -> str:
|
||
"""标准化需求规格中的单位格式。
|
||
|
||
将所有长度单位统一转换为 "长m×宽m" 格式，
|
||
将所有重量单位统一转换为 "数值+标准单位" 格式。
|
||
|
||
参数：
|
||
spec: 原始需求规格字符串。
|
||
|
||
返回：
|
||
标准化后的字符串。
|
||
"""
|
||
if not spec:
|
||
return spec
|
||
|
||
# 尝试匹配长度尺寸（宽×高）
|
||
length_match = self._LENGTH_SPEC_RE.search(spec)
|
||
if length_match:
|
||
return self._standardize_length_spec(spec, length_match)
|
||
|
||
# 尝试匹配重量
|
||
weight_match = self._WEIGHT_SPEC_RE.search(spec)
|
||
if weight_match:
|
||
return self._standardize_weight_spec(spec, weight_match)
|
||
|
||
# 无法识别，返回原值
|
||
return spec
|
||
|
||
def _standardize_length_spec(self, spec: str, match: re.Match) -> str:
|
||
"""标准化长度尺寸为 "长m×宽m" 格式。"""
|
||
v1 = float(match.group(1))
|
||
u1 = self._LENGTH_UNIT_MAP.get((match.group(2) or "cm").lower(), "cm")
|
||
v2 = float(match.group(3))
|
||
u2 = self._LENGTH_UNIT_MAP.get((match.group(4) or "cm").lower(), "cm")
|
||
|
||
# 转换为米
|
||
def to_m(v, u):
|
||
if u == "m":
|
||
return v
|
||
elif u == "mm":
|
||
return v / 1000
|
||
else: # cm
|
||
return v / 100
|
||
|
||
m1 = to_m(v1, u1)
|
||
m2 = to_m(v2, u2)
|
||
|
||
# 格式化：保留必要小数位
|
||
def format_m(v):
|
||
if v == int(v):
|
||
return str(int(v))
|
||
# 去除尾部多余的0
|
||
return f"{v:.4f}".rstrip("0").rstrip(".")
|
||
|
||
return f"{format_m(m1)}m×{format_m(m2)}m"
|
||
|
||
def _standardize_weight_spec(self, spec: str, match: re.Match) -> str:
|
||
"""标准化重量单位。"""
|
||
value = float(match.group(1))
|
||
unit = self._WEIGHT_UNIT_MAP.get(match.group(2).lower(), match.group(2))
|
||
|
||
# 格式化数值
|
||
if value == int(value):
|
||
value_str = str(int(value))
|
||
else:
|
||
value_str = str(value)
|
||
|
||
return f"{value_str}{unit}"
|
||
|
||
def _get_factory_options(self, session: Session | None) -> list[dict]:
|
||
"""获取工厂（供应商）下拉选项列表，供前端智能填单表单使用。
|
||
|
||
参数：
|
||
session: 数据库会话，为 None 时返回空列表。
|
||
|
||
返回：
|
||
包含 value（supplier_id）和 label（supplier_name）的字典列表。
|
||
"""
|
||
if session is None:
|
||
return []
|
||
try:
|
||
from backend.app.services.supplier_service import supplier_service
|
||
result = supplier_service.list_suppliers(
|
||
session, {"supplier_type": "factory"}
|
||
)
|
||
return [
|
||
{"value": item["supplier_id"], "label": item["supplier_name"]}
|
||
for item in result.get("list", [])
|
||
]
|
||
except Exception:
|
||
return []
|
||
|
||
def parse_customer(self, payload: dict, session: Session | None = None) -> dict:
|
||
"""客户信息智能解析入口：从文本中提取客户信息。
|
||
|
||
复用订单解析的文本预处理和规则提取逻辑，专门用于提取客户相关信息。
|
||
处理流程：
|
||
1. 文本预处理（去噪声）
|
||
2. 规则提取（正则提取手机号、地址）
|
||
3. LLM 结构化解析（提取客户姓名等）
|
||
4. 客户库预匹配（通过手机号查找已有客户）
|
||
|
||
参数：
|
||
payload: 请求数据字典，必含 text 字段。
|
||
session: 数据库会话，为 None 时跳过数据库查询。
|
||
|
||
返回：
|
||
包含 parsed_customer、raw_text、confidence、warnings 的字典。
|
||
|
||
被调用方：ai 路由（客户信息解析接口）。
|
||
"""
|
||
raw_text = payload.get("text", "").strip()
|
||
|
||
# 1. 文本预处理
|
||
preprocessor = TextPreprocessor()
|
||
raw_text = preprocessor.preprocess(raw_text)
|
||
if not raw_text:
|
||
raise AppException(
|
||
code=ErrorCode.PARAM_ERROR,
|
||
message="无法提取到文本内容",
|
||
status_code=400,
|
||
)
|
||
|
||
# 2. 规则提取（手机号、地址）
|
||
rule_extractor = RuleExtractor()
|
||
rule_result = rule_extractor.extract(raw_text)
|
||
|
||
# 3. LLM 结构化解析（提取客户姓名等）
|
||
settings = self.settings
|
||
llm_parsed = {}
|
||
|
||
# 构造简化的 prompt，只提取客户信息
|
||
system_prompt = """你是客户信息提取助手。从用户提供的文本中提取客户信息。
|
||
|
||
## 重要规则
|
||
1. 只提取文本中明确提到的信息，不要猜测或推断
|
||
2. 如果某个字段无法识别，返回空字符串 ""
|
||
3. customer_name 是客户姓名/称呼，不是公司名、订单号或其他编号
|
||
4. customer_mobile 必须是11位手机号码（1开头的数字）
|
||
5. customer_address 只包含地理地址信息（省/市/区/县/镇/街道/路/号等），不要包含其他内容
|
||
|
||
## 输出格式
|
||
严格按以下 JSON 格式输出，不要添加任何其他内容：
|
||
{"customer_name":"","customer_mobile":"","customer_address":"","customer_type":"","settlement_type":"","remark":""}
|
||
|
||
## 字段说明
|
||
- customer_name：客户姓名或称呼（如"张三"、"李总"）
|
||
- customer_mobile：11位手机号
|
||
- customer_address：收货地址（只包含地理信息）
|
||
- customer_type：客户类型，只能是 "channel"/"retail"/"project" 之一，不确定则留空
|
||
- settlement_type：结算方式，只能是 "monthly"/"cash"/"delivered" 之一，不确定则留空
|
||
- remark：备注信息"""
|
||
|
||
payload_data = json.dumps({
|
||
"model": settings.llm_parse_model,
|
||
"messages": [
|
||
{"role": "system", "content": system_prompt},
|
||
{"role": "user", "content": f"请从以下文本中提取客户信息：\n\n{raw_text}"},
|
||
],
|
||
"temperature": 0.1,
|
||
"max_tokens": 512,
|
||
}).encode("utf-8")
|
||
|
||
headers = {
|
||
"Content-Type": "application/json",
|
||
"Authorization": f"Bearer {settings.llm_parse_api_key or settings.aliyun_ai_access_key_id}",
|
||
}
|
||
|
||
try:
|
||
req = request.Request(
|
||
url=settings.llm_parse_api_url, data=payload_data, headers=headers, method="POST"
|
||
)
|
||
with request.urlopen(req, timeout=30) as resp:
|
||
result = json.loads(resp.read().decode("utf-8"))
|
||
|
||
content = result["choices"][0]["message"]["content"]
|
||
logger.info("[客户信息解析] LLM 返回: %s", content)
|
||
|
||
# 解析 JSON
|
||
llm_parsed = self._extract_customer_json(content)
|
||
except Exception as e:
|
||
logger.warning("[客户信息解析] LLM 解析失败: %s", str(e))
|
||
llm_parsed = {}
|
||
|
||
# 4. 合并规则提取和 LLM 解析结果
|
||
parsed_customer = {}
|
||
|
||
# 手机号：优先使用规则提取的（更可靠）
|
||
if rule_result.get("customer_mobile"):
|
||
parsed_customer["customer_mobile"] = rule_result["customer_mobile"]
|
||
elif llm_parsed.get("customer_mobile"):
|
||
parsed_customer["customer_mobile"] = llm_parsed["customer_mobile"]
|
||
|
||
# 地址：优先使用规则提取的（更可靠）
|
||
if rule_result.get("customer_address"):
|
||
parsed_customer["customer_address"] = rule_result["customer_address"]
|
||
elif llm_parsed.get("customer_address"):
|
||
parsed_customer["customer_address"] = llm_parsed["customer_address"]
|
||
|
||
# 客户姓名：使用 LLM 解析的结果
|
||
if llm_parsed.get("customer_name"):
|
||
parsed_customer["customer_name"] = llm_parsed["customer_name"]
|
||
|
||
# 其他字段：使用 LLM 解析的结果
|
||
for key in ("customer_type", "settlement_type", "remark"):
|
||
if llm_parsed.get(key):
|
||
parsed_customer[key] = llm_parsed[key]
|
||
|
||
# 5. 客户库预匹配（通过手机号查找已有客户）
|
||
warnings = []
|
||
if session and parsed_customer.get("customer_mobile"):
|
||
try:
|
||
from backend.app.repositories.customer_repository import CustomerRepository
|
||
customer_repo = CustomerRepository(session)
|
||
existing = customer_repo.find_by_mobile(parsed_customer["customer_mobile"])
|
||
if existing:
|
||
parsed_customer["existing_customer"] = {
|
||
"customer_id": existing.customer_id,
|
||
"customer_name": existing.customer_name,
|
||
"mobile": existing.mobile,
|
||
}
|
||
warnings.append(f"手机号 {parsed_customer['customer_mobile']} 已存在于客户库中（{existing.customer_name}）")
|
||
except Exception as e:
|
||
logger.warning("[客户信息解析] 客户库匹配失败: %s", str(e))
|
||
|
||
# 6. 计算置信度
|
||
confidence = self._calculate_customer_confidence(parsed_customer, warnings)
|
||
|
||
return {
|
||
"parsed_customer": parsed_customer,
|
||
"raw_text": raw_text,
|
||
"confidence": confidence,
|
||
"warnings": warnings,
|
||
}
|
||
|
||
def _extract_customer_json(self, text: str) -> dict:
|
||
"""从 LLM 响应中提取客户信息 JSON。
|
||
|
||
处理 LLM 可能包裹在 markdown 代码块中的情况，
|
||
以及 LLM 响应被截断导致 JSON 不完整的常见场景。
|
||
|
||
参数：
|
||
text: LLM 原始响应文本。
|
||
|
||
返回：
|
||
解析后的客户信息字典。
|
||
"""
|
||
text = text.strip()
|
||
if text.startswith("```"):
|
||
text = text.split("\n", 1)[1] if "\n" in text else text[3:]
|
||
text = text.rsplit("```", 1)[0]
|
||
text = text.strip()
|
||
if text.startswith("json"):
|
||
text = text[4:].strip()
|
||
|
||
try:
|
||
return json.loads(text)
|
||
except json.JSONDecodeError:
|
||
# LLM 响应可能被截断，尝试截断到最后一个完整 } 修复
|
||
last_brace = text.rfind("}")
|
||
while last_brace > 0:
|
||
try:
|
||
return json.loads(text[:last_brace + 1])
|
||
except json.JSONDecodeError:
|
||
last_brace = text.rfind("}", 0, last_brace - 1)
|
||
return {}
|
||
|
||
def _calculate_customer_confidence(self, customer: dict, warnings: list) -> float:
|
||
"""计算客户信息解析的置信度。
|
||
|
||
根据识别到的字段数量和质量计算置信度分数。
|
||
|
||
参数：
|
||
customer: 解析出的客户信息字典。
|
||
warnings: 警告信息列表。
|
||
|
||
返回：
|
||
0.1 到 1.0 之间的置信度分数。
|
||
"""
|
||
base = 0.8
|
||
|
||
# 有客户姓名加分
|
||
if customer.get("customer_name"):
|
||
base += 0.1
|
||
|
||
# 有手机号加分（手机号是关键字段）
|
||
if customer.get("customer_mobile"):
|
||
base += 0.1
|
||
|
||
# 有地址加分
|
||
if customer.get("customer_address"):
|
||
base += 0.05
|
||
|
||
# 有警告扣分（如客户已存在）
|
||
base -= len(warnings) * 0.1
|
||
|
||
return round(max(base, 0.1), 2)
|
||
|
||
|
||
ai_service = AIService()
|