1968 lines
80 KiB
JavaScript
1968 lines
80 KiB
JavaScript
'use strict';
|
||
|
||
const axios = require('axios');
|
||
const crypto = require('crypto');
|
||
const database = require('../config/database');
|
||
const cloudDatabase = require('../config/cloudDatabase');
|
||
const reportDatabase = require('../config/reportReplicaDatabase');
|
||
const { buildSystemPrompt, buildUserPrompt } = require('./csQualityAiPrompt');
|
||
const dataPageCache = require('./dataPageCache');
|
||
|
||
const CHAT_TABLE = '[rpt].[pdd_GoodsChatMessages]';
|
||
const GOODS_TABLE = '[rpt].[pdd_DataGoods]';
|
||
const HISTORY_TABLE = '[app].[pdd_chat_ai_analysis_history]';
|
||
const HISTORY_SCHEMA_VERSION = '1.0';
|
||
const MAX_ANALYSIS_MESSAGES = 10000;
|
||
const MAX_ANALYSIS_TEXT_LENGTH = 2000000;
|
||
const QWEN_PROVIDER = 'aliyun-model-studio';
|
||
const AGNES_PROVIDER = 'agnes-ai-cn';
|
||
const AI_CONFIG_KEYS = [
|
||
'cs_quality_ai_config',
|
||
'agnes_quality_ai_config',
|
||
'qwen_quality_ai_config',
|
||
'selection_fission_ai_analysis_config',
|
||
];
|
||
const DEFAULT_QWEN_BASE_URL = 'https://dashscope.aliyuncs.com/compatible-mode/v1';
|
||
const DEFAULT_QWEN_MODEL = 'qwen3.7-max-2026-06-08';
|
||
const DEFAULT_AGNES_BASE_URL = 'https://api.agnes-ai.cn/v1';
|
||
const DEFAULT_AGNES_MODEL = 'agnes-2.5-flash';
|
||
const DEFAULT_BATCH_MAX_CHARS = 45000;
|
||
const DEFAULT_BATCH_CONCURRENCY = 2;
|
||
const DEFAULT_BATCH_MAX_TOKENS = 8000;
|
||
const DEFAULT_MERGE_MAX_TOKENS = 12000;
|
||
const DEFAULT_MERGE_MAX_BATCHES = 8;
|
||
const DEFAULT_AI_REQUEST_RETRY_COUNT = 2;
|
||
const DEFAULT_AI_RETRY_BASE_DELAY_MS = 1500;
|
||
const MAX_AI_RETRY_DELAY_MS = 30000;
|
||
const CS_QUALITY_CACHE_VERSION = 'v2';
|
||
const CS_QUALITY_MEMORY_CACHE_TTL_SECONDS = Math.max(
|
||
Number.parseInt(process.env.CS_QUALITY_MEMORY_CACHE_TTL_SECONDS || '600', 10) || 600,
|
||
30
|
||
);
|
||
const CS_QUALITY_REDIS_CACHE_TTL_SECONDS = Math.max(
|
||
Number.parseInt(process.env.CS_QUALITY_REDIS_CACHE_TTL_SECONDS || '3600', 10) || 3600,
|
||
CS_QUALITY_MEMORY_CACHE_TTL_SECONDS
|
||
);
|
||
const CS_QUALITY_SNAPSHOT_MAX_DAYS = Math.min(Math.max(
|
||
Number.parseInt(process.env.CS_QUALITY_SNAPSHOT_MAX_DAYS || '3', 10) || 3,
|
||
1
|
||
), 7);
|
||
const CS_QUALITY_JOB_STALE_MS = Math.max(
|
||
Number.parseInt(process.env.CS_QUALITY_JOB_STALE_MS || String(45 * 60 * 1000), 10) || 45 * 60 * 1000,
|
||
15 * 60 * 1000
|
||
);
|
||
const IMPROVEMENT_AREAS = new Set(['产品本体', '规格配置', '宣传主图', '详情页', '客服话术', '价格策略', '库存备货', '履约物流', '安装服务', '售后服务', '无需改进']);
|
||
const IMAGE_URL_PATTERN = /\.(png|jpe?g|gif|webp|bmp|avif)(?:[?#].*)?$/i;
|
||
|
||
const PRE_SALE_MAP = new Map([
|
||
['是否有货', '库存备货'],
|
||
['发货地', '发货问题'], ['发货速度', '发货问题'], ['缺货问题', '发货问题'], ['催发货', '发货问题'], ['延期发货', '发货问题'],
|
||
['贴唛头', '批量外贸单'],
|
||
['是否包邮', '快递问题'], ['指定快递', '快递问题'], ['送货上门', '快递问题'], ['物流速度', '快递问题'], ['配送速度', '快递问题'], ['到货时间', '快递问题'],
|
||
['是否防潮/防火', '产品问题'], ['是否有背板/轨道', '产品问题'], ['材质的区别', '产品问题'], ['产地问题', '产品问题'], ['质保时效', '产品问题'], ['尺寸问题', '产品问题'], ['板材厚度', '产品问题'], ['是否支持定制', '产品问题'], ['承重性', '产品问题'],
|
||
['检测报告', '产品环保问题'], ['气味问题', '产品环保问题'],
|
||
['优惠券问题', '价格问题'], ['买后比价', '价格问题'], ['商品降价', '价格问题'],
|
||
['多拍错拍', '下单错误'], ['地址/电话信息错误', '下单错误'],
|
||
['尺码/尺寸/规格不合适', '决策信息不充分'],
|
||
['安装说明书/安装视频', '安装问题'], ['是否包安装', '安装问题'], ['是否整装发货', '安装问题'],
|
||
['是否有发票', '发票问题'], ['多开/少开发票', '发票问题'], ['催发票', '发票问题'],
|
||
]);
|
||
|
||
const AFTER_SALE_PRIMARY = {
|
||
发货异常: '发货履约问题', 虚假发货: '发货履约问题',
|
||
更新超时: '物流配送问题', 丢件: '物流配送问题', 派送超时: '物流配送问题', 送货异常: '物流配送问题', 退货到仓: '物流配送问题',
|
||
少发漏发: '商品交付问题', 错发: '商品交付问题', 运输产品破损: '商品交付问题',
|
||
产品质量: '商品质量问题', 描述不符: '商品质量问题',
|
||
安装咨询: '安装服务问题', 上门安装: '安装服务问题',
|
||
回复超时: '客服服务问题', 服务态度极差: '客服服务问题', 承诺未履行: '客服服务问题', 操作错误: '客服服务问题',
|
||
上门取件: '退换货问题', 铺货错误: '平台业务问题', 种菜异常: '平台业务问题', 其他: '其他售后',
|
||
};
|
||
const AFTER_SALE_LABELS = new Set(Object.keys(AFTER_SALE_PRIMARY));
|
||
|
||
let historyClientPromise = null;
|
||
let historySchemaPromise = null;
|
||
|
||
function normalizeText(value, maxLength = 2000) {
|
||
return String(value ?? '').trim().slice(0, maxLength);
|
||
}
|
||
|
||
function parseJson(value, fallback = null) {
|
||
if (value && typeof value === 'object') return value;
|
||
try { return JSON.parse(String(value || '')); } catch (_) { return fallback; }
|
||
}
|
||
|
||
function boundedInteger(value, fallback, min, max) {
|
||
const number = Number(value);
|
||
if (!Number.isFinite(number)) return fallback;
|
||
return Math.min(Math.max(Math.trunc(number), min), max);
|
||
}
|
||
|
||
function parseDateOnly(value) {
|
||
const text = normalizeText(value, 10);
|
||
if (!/^\d{4}-\d{2}-\d{2}$/.test(text)) return null;
|
||
const timestamp = Date.parse(`${text}T00:00:00Z`);
|
||
return Number.isFinite(timestamp) ? text : null;
|
||
}
|
||
|
||
function addDate(dateText, amount) {
|
||
const date = new Date(`${dateText}T00:00:00Z`);
|
||
date.setUTCDate(date.getUTCDate() + amount);
|
||
return date.toISOString().slice(0, 10);
|
||
}
|
||
|
||
function resolveDateRange(startDate, endDate) {
|
||
const today = new Date();
|
||
const fallback = new Date(today.getTime() - 86400000).toISOString().slice(0, 10);
|
||
const start = parseDateOnly(startDate) || fallback;
|
||
const end = parseDateOnly(endDate) || start;
|
||
const dayCount = Math.round((Date.parse(`${end}T00:00:00Z`) - Date.parse(`${start}T00:00:00Z`)) / 86400000) + 1;
|
||
if (dayCount < 1) throw new Error('开始日期不能晚于结束日期');
|
||
if (dayCount > 30) throw new Error('聊天记录分析日期范围不能超过30天');
|
||
return { startDate: start, endDate: end, endExclusiveDate: addDate(end, 1), startAt: `${start} 00:00:00`, endExclusive: `${addDate(end, 1)} 00:00:00`, dayCount };
|
||
}
|
||
|
||
function normalizeGoodsId(value) {
|
||
const text = normalizeText(value, 80);
|
||
if (!text || !/^[0-9]+$/.test(text)) throw new Error('商品ID格式不正确');
|
||
return text;
|
||
}
|
||
|
||
function numberValue(value) {
|
||
const number = Number(String(value ?? '').replace(/,/g, '').replace('%', ''));
|
||
return Number.isFinite(number) ? number : 0;
|
||
}
|
||
|
||
function percentValue(value) {
|
||
const number = numberValue(value);
|
||
return number;
|
||
}
|
||
|
||
function formatMetric(value, digits = 2) {
|
||
const number = Number(value);
|
||
return Number.isFinite(number) ? Number(number.toFixed(digits)) : 0;
|
||
}
|
||
|
||
function buildDateWhere(alias, range) {
|
||
return `${alias}.[createTime] >= @startDate AND ${alias}.[createTime] < @endExclusiveDate`;
|
||
}
|
||
|
||
function extractMessageDate(value) {
|
||
const match = String(value || '').match(/(\d{4})[-/.](\d{1,2})[-/.](\d{1,2})/);
|
||
if (!match) return null;
|
||
const dateText = `${match[1]}-${match[2].padStart(2, '0')}-${match[3].padStart(2, '0')}`;
|
||
return parseDateOnly(dateText);
|
||
}
|
||
|
||
function formatProgressDate(value) {
|
||
const date = parseDateOnly(value);
|
||
return date ? `${date.slice(5, 7)}月${date.slice(8, 10)}日` : '';
|
||
}
|
||
|
||
function formatBatchDateRange(batch = {}) {
|
||
const start = formatProgressDate(batch.startDate);
|
||
const end = formatProgressDate(batch.endDate);
|
||
if (!start && !end) return '当前批次';
|
||
if (!end || start === end) return start || end;
|
||
return `${start}至${end}`;
|
||
}
|
||
|
||
function isTruthy(value) {
|
||
return ['1', 'true', 'yes', 'on'].includes(normalizeText(value, 10).toLowerCase());
|
||
}
|
||
|
||
function selectMaxText(current, candidate, maxLength = 2000) {
|
||
const next = normalizeText(candidate, maxLength);
|
||
if (!next) return current || null;
|
||
if (!current || next > current) return next;
|
||
return current;
|
||
}
|
||
|
||
function selectTime(current, candidate, mode) {
|
||
if (!candidate) return current || null;
|
||
if (!current) return candidate;
|
||
const currentTime = new Date(current).getTime();
|
||
const candidateTime = new Date(candidate).getTime();
|
||
if (Number.isFinite(currentTime) && Number.isFinite(candidateTime)) {
|
||
return mode === 'min'
|
||
? (candidateTime < currentTime ? candidate : current)
|
||
: (candidateTime > currentTime ? candidate : current);
|
||
}
|
||
const currentText = String(current);
|
||
const candidateText = String(candidate);
|
||
return mode === 'min'
|
||
? (candidateText < currentText ? candidate : current)
|
||
: (candidateText > currentText ? candidate : current);
|
||
}
|
||
|
||
function aggregateChatDimensionRows(rows = []) {
|
||
const goodsMap = new Map();
|
||
const customerMaps = new Map();
|
||
|
||
for (const row of rows) {
|
||
const goodsId = normalizeText(row.goodsId, 80);
|
||
if (!goodsId) continue;
|
||
const uid = normalizeText(row.uid, 200);
|
||
const csname = normalizeText(row.csname, 200);
|
||
const messageCount = Math.max(0, Number(row.messageCount) || 0);
|
||
|
||
let goods = goodsMap.get(goodsId);
|
||
if (!goods) {
|
||
goods = {
|
||
goodsId,
|
||
goodsName: null,
|
||
hdThumbUrl: null,
|
||
shopName: null,
|
||
messageCount: 0,
|
||
userIds: new Set(),
|
||
csNames: new Set(),
|
||
reportedCsCount: 0,
|
||
chatStartAt: null,
|
||
chatEndAt: null,
|
||
};
|
||
goodsMap.set(goodsId, goods);
|
||
}
|
||
goods.goodsName = selectMaxText(goods.goodsName, row.goodsName);
|
||
goods.hdThumbUrl = selectMaxText(goods.hdThumbUrl, row.hdThumbUrl);
|
||
goods.shopName = selectMaxText(goods.shopName, row.shopName, 200);
|
||
goods.messageCount += messageCount;
|
||
if (uid) goods.userIds.add(uid);
|
||
if (csname) goods.csNames.add(csname);
|
||
goods.reportedCsCount = Math.max(goods.reportedCsCount, Number(row.csCount) || 0);
|
||
goods.chatStartAt = selectTime(goods.chatStartAt, row.firstMsgTime, 'min');
|
||
goods.chatEndAt = selectTime(goods.chatEndAt, row.lastMsgTime, 'max');
|
||
|
||
if (!uid) continue;
|
||
let customerMap = customerMaps.get(goodsId);
|
||
if (!customerMap) {
|
||
customerMap = new Map();
|
||
customerMaps.set(goodsId, customerMap);
|
||
}
|
||
let customer = customerMap.get(uid);
|
||
if (!customer) {
|
||
customer = {
|
||
uid,
|
||
nickname: null,
|
||
csname: null,
|
||
messageCount: 0,
|
||
firstMsgTime: null,
|
||
lastMsgTime: null,
|
||
};
|
||
customerMap.set(uid, customer);
|
||
}
|
||
customer.nickname = selectMaxText(customer.nickname, row.nickname, 200);
|
||
customer.csname = selectMaxText(customer.csname, csname, 200);
|
||
customer.messageCount += messageCount;
|
||
customer.firstMsgTime = selectTime(customer.firstMsgTime, row.firstMsgTime, 'min');
|
||
customer.lastMsgTime = selectTime(customer.lastMsgTime, row.lastMsgTime, 'max');
|
||
}
|
||
|
||
const goodsRows = Array.from(goodsMap.values())
|
||
.map((goods) => ({
|
||
goodsId: goods.goodsId,
|
||
goodsName: goods.goodsName,
|
||
hdThumbUrl: goods.hdThumbUrl,
|
||
shopName: goods.shopName,
|
||
messageCount: goods.messageCount,
|
||
userCount: goods.userIds.size,
|
||
csCount: Math.max(goods.reportedCsCount, goods.csNames.size),
|
||
chatStartAt: goods.chatStartAt,
|
||
chatEndAt: goods.chatEndAt,
|
||
}))
|
||
.sort((left, right) => (
|
||
right.userCount - left.userCount
|
||
|| right.messageCount - left.messageCount
|
||
|| left.goodsId.localeCompare(right.goodsId)
|
||
))
|
||
.slice(0, 5000);
|
||
|
||
const customersByGoods = {};
|
||
for (const [goodsId, customerMap] of customerMaps.entries()) {
|
||
customersByGoods[goodsId] = Array.from(customerMap.values())
|
||
.sort((left, right) => (
|
||
right.messageCount - left.messageCount
|
||
|| left.uid.localeCompare(right.uid)
|
||
))
|
||
.slice(0, 5000);
|
||
}
|
||
|
||
return { goodsRows, customersByGoods };
|
||
}
|
||
|
||
async function getCachedCsQualityPayload(namespace, payload, label, loader, ttl = {}) {
|
||
const key = dataPageCache.buildHashedCacheKey(
|
||
`cs-quality:${namespace}`,
|
||
payload,
|
||
CS_QUALITY_CACHE_VERSION
|
||
);
|
||
return dataPageCache.getOrSetCachedPayload({
|
||
key,
|
||
memoryTtlSeconds: ttl.memory || CS_QUALITY_MEMORY_CACHE_TTL_SECONDS,
|
||
redisTtlSeconds: ttl.redis || CS_QUALITY_REDIS_CACHE_TTL_SECONDS,
|
||
label,
|
||
loader,
|
||
shouldCache: ttl.shouldCache,
|
||
guardLoader: false,
|
||
});
|
||
}
|
||
|
||
async function getChatDimensionSnapshot(options, range, scopeGoodsId = '') {
|
||
const shopName = normalizeText(options.shopName, 200);
|
||
const params = { startDate: range.startDate, endExclusiveDate: range.endExclusiveDate };
|
||
const conditions = [buildDateWhere('g', range)];
|
||
if (shopName) {
|
||
params.shopName = `%${shopName}%`;
|
||
conditions.push('g.[shopName] LIKE @shopName');
|
||
}
|
||
if (scopeGoodsId) {
|
||
params.scopeGoodsId = scopeGoodsId;
|
||
conditions.push('g.[goodsId] = @scopeGoodsId');
|
||
}
|
||
|
||
const cached = await getCachedCsQualityPayload(
|
||
'dimension-snapshot',
|
||
{ startDate: range.startDate, endDate: range.endDate, shopName, scopeGoodsId },
|
||
'cs-quality-dimension-snapshot',
|
||
async () => {
|
||
const rows = await reportDatabase.query(
|
||
`WITH grouped AS (
|
||
SELECT
|
||
g.[goodsId] AS [goodsId], g.[uid] AS [uid], g.[csname] AS [csname],
|
||
MAX(NULLIF(g.[goodsName], N'')) AS [goodsName],
|
||
MAX(NULLIF(g.[hdThumbUrl], N'')) AS [hdThumbUrl],
|
||
MAX(NULLIF(g.[shopName], N'')) AS [shopName],
|
||
MAX(NULLIF(g.[nickname], N'')) AS [nickname],
|
||
COUNT_BIG(1) AS [messageCount],
|
||
MIN(TRY_CONVERT(DATETIME2, g.[msgTime])) AS [firstMsgTime],
|
||
MAX(TRY_CONVERT(DATETIME2, g.[msgTime])) AS [lastMsgTime]
|
||
FROM ${CHAT_TABLE} g WITH (NOLOCK)
|
||
WHERE ${conditions.join(' AND ')}
|
||
GROUP BY g.[goodsId], g.[uid], g.[csname]
|
||
), ranked AS (
|
||
SELECT grouped.*,
|
||
DENSE_RANK() OVER (
|
||
PARTITION BY grouped.[goodsId]
|
||
ORDER BY CASE WHEN NULLIF(LTRIM(RTRIM(grouped.[csname])), N'') IS NULL THEN 0 ELSE 1 END,
|
||
grouped.[csname]
|
||
) AS [csRank],
|
||
MAX(CASE WHEN NULLIF(LTRIM(RTRIM(grouped.[csname])), N'') IS NULL THEN 1 ELSE 0 END)
|
||
OVER (PARTITION BY grouped.[goodsId]) AS [hasBlankCs]
|
||
FROM grouped
|
||
)
|
||
SELECT
|
||
ranked.[goodsId] AS [goodsId], ranked.[uid] AS [uid],
|
||
MAX(NULLIF(ranked.[csname], N'')) AS [csname],
|
||
MAX(ranked.[goodsName]) AS [goodsName],
|
||
MAX(ranked.[hdThumbUrl]) AS [hdThumbUrl],
|
||
MAX(ranked.[shopName]) AS [shopName],
|
||
MAX(ranked.[nickname]) AS [nickname],
|
||
SUM(ranked.[messageCount]) AS [messageCount],
|
||
MIN(ranked.[firstMsgTime]) AS [firstMsgTime],
|
||
MAX(ranked.[lastMsgTime]) AS [lastMsgTime],
|
||
MAX(ranked.[csRank] - ranked.[hasBlankCs]) AS [csCount]
|
||
FROM ranked
|
||
GROUP BY ranked.[goodsId], ranked.[uid]`,
|
||
params,
|
||
{ requestTimeout: 120000 }
|
||
);
|
||
return aggregateChatDimensionRows(rows || []);
|
||
},
|
||
{ shouldCache: (value) => Array.isArray(value?.goodsRows) && value.goodsRows.length > 0 }
|
||
);
|
||
|
||
return { ...cached.value, cacheHit: cached.hit };
|
||
}
|
||
|
||
function mapChatDataMeta(row = {}) {
|
||
return {
|
||
tableName: 'rpt.pdd_GoodsChatMessages',
|
||
minDate: extractMessageDate(row.minDate),
|
||
latestDate: extractMessageDate(row.latestDate),
|
||
messageCount: Math.max(0, Number(row.messageCount) || 0),
|
||
};
|
||
}
|
||
|
||
async function getChatDataMeta() {
|
||
const cached = await getCachedCsQualityPayload(
|
||
'data-meta',
|
||
{},
|
||
'cs-quality-data-meta',
|
||
async () => {
|
||
const rows = await reportDatabase.query(
|
||
`SELECT
|
||
MIN(NULLIF(LTRIM(RTRIM(g.[createTime])), N'')) AS [minDate],
|
||
MAX(NULLIF(LTRIM(RTRIM(g.[createTime])), N'')) AS [latestDate],
|
||
COUNT_BIG(1) AS [messageCount]
|
||
FROM ${CHAT_TABLE} g WITH (NOLOCK)`,
|
||
{},
|
||
{ requestTimeout: 120000 }
|
||
);
|
||
return mapChatDataMeta(rows[0]);
|
||
},
|
||
{ memory: 300, redis: 300 }
|
||
);
|
||
|
||
return { ...cached.value, cache: { hit: cached.hit } };
|
||
}
|
||
|
||
async function getGoods(options = {}) {
|
||
const range = resolveDateRange(options.startDate, options.endDate);
|
||
const shopName = normalizeText(options.shopName, 200);
|
||
const scopeGoodsId = normalizeText(options.goodsId, 80) ? normalizeGoodsId(options.goodsId) : '';
|
||
const canUseSnapshot = range.dayCount <= CS_QUALITY_SNAPSHOT_MAX_DAYS || Boolean(scopeGoodsId);
|
||
|
||
if (canUseSnapshot) {
|
||
const snapshot = await getChatDimensionSnapshot(options, range, scopeGoodsId);
|
||
const result = {
|
||
tableName: 'rpt.pdd_GoodsChatMessages',
|
||
range,
|
||
rows: snapshot.goodsRows || [],
|
||
cache: { hit: snapshot.cacheHit },
|
||
};
|
||
if (isTruthy(options.includeInitial) && result.rows[0]) {
|
||
const firstGoods = result.rows[0];
|
||
const customers = snapshot.customersByGoods?.[String(firstGoods.goodsId)] || [];
|
||
const firstCustomer = customers[0] || null;
|
||
let messages = [];
|
||
let messagesPrefetched = !firstCustomer;
|
||
if (firstCustomer) {
|
||
try {
|
||
const messageResult = await getMessages({
|
||
startDate: range.startDate,
|
||
endDate: range.endDate,
|
||
shopName,
|
||
goodsId: firstGoods.goodsId,
|
||
uid: firstCustomer.uid,
|
||
});
|
||
messages = messageResult.rows || [];
|
||
messagesPrefetched = true;
|
||
} catch (error) {
|
||
console.warn('[CsQuality] 首屏聊天预取失败:', error.message);
|
||
}
|
||
}
|
||
result.initial = {
|
||
goodsId: firstGoods.goodsId,
|
||
customerUid: firstCustomer?.uid || null,
|
||
customers,
|
||
messages,
|
||
messagesPrefetched,
|
||
};
|
||
}
|
||
return result;
|
||
}
|
||
|
||
const params = { startDate: range.startDate, endExclusiveDate: range.endExclusiveDate };
|
||
const conditions = [buildDateWhere('g', range)];
|
||
if (shopName) {
|
||
params.shopName = `%${shopName}%`;
|
||
conditions.push('g.[shopName] LIKE @shopName');
|
||
}
|
||
if (scopeGoodsId) {
|
||
params.goodsId = scopeGoodsId;
|
||
conditions.push('g.[goodsId] = @goodsId');
|
||
}
|
||
|
||
const cached = await getCachedCsQualityPayload(
|
||
'goods',
|
||
{ startDate: range.startDate, endDate: range.endDate, shopName, scopeGoodsId },
|
||
'cs-quality-goods',
|
||
() => reportDatabase.query(
|
||
`SELECT TOP 5000
|
||
g.[goodsId] AS [goodsId],
|
||
MAX(NULLIF(g.[goodsName], N'')) AS [goodsName],
|
||
MAX(NULLIF(g.[hdThumbUrl], N'')) AS [hdThumbUrl],
|
||
MAX(NULLIF(g.[shopName], N'')) AS [shopName],
|
||
COUNT_BIG(1) AS [messageCount],
|
||
COUNT(DISTINCT g.[uid]) AS [userCount],
|
||
COUNT(DISTINCT g.[csname]) AS [csCount],
|
||
MIN(TRY_CONVERT(DATETIME2, g.[msgTime])) AS [chatStartAt],
|
||
MAX(TRY_CONVERT(DATETIME2, g.[msgTime])) AS [chatEndAt]
|
||
FROM ${CHAT_TABLE} g WITH (NOLOCK)
|
||
WHERE ${conditions.join(' AND ')}
|
||
GROUP BY g.[goodsId]
|
||
ORDER BY COUNT(DISTINCT g.[uid]) DESC, COUNT_BIG(1) DESC`,
|
||
params,
|
||
{ requestTimeout: 120000 }
|
||
),
|
||
{ shouldCache: (value) => Array.isArray(value) && value.length > 0 }
|
||
);
|
||
|
||
return {
|
||
tableName: 'rpt.pdd_GoodsChatMessages',
|
||
range,
|
||
rows: cached.value || [],
|
||
cache: { hit: cached.hit },
|
||
};
|
||
}
|
||
|
||
async function getCustomers(options = {}) {
|
||
const goodsId = normalizeGoodsId(options.goodsId);
|
||
const range = resolveDateRange(options.startDate, options.endDate);
|
||
const shopName = normalizeText(options.shopName, 200);
|
||
const requestedScopeGoodsId = normalizeText(options.snapshotScopeGoodsId, 80);
|
||
const scopeGoodsId = requestedScopeGoodsId === goodsId ? goodsId : '';
|
||
const canUseSnapshot = range.dayCount <= CS_QUALITY_SNAPSHOT_MAX_DAYS || Boolean(scopeGoodsId);
|
||
if (canUseSnapshot) {
|
||
const snapshot = await getChatDimensionSnapshot(options, range, scopeGoodsId);
|
||
return {
|
||
range,
|
||
rows: snapshot.customersByGoods?.[goodsId] || [],
|
||
cache: { hit: snapshot.cacheHit },
|
||
};
|
||
}
|
||
|
||
const params = { goodsId, startDate: range.startDate, endExclusiveDate: range.endExclusiveDate };
|
||
const conditions = [buildDateWhere('g', range), 'g.[goodsId] = @goodsId'];
|
||
if (shopName) {
|
||
params.shopName = `%${shopName}%`;
|
||
conditions.push('g.[shopName] LIKE @shopName');
|
||
}
|
||
const cached = await getCachedCsQualityPayload(
|
||
'customers',
|
||
{ startDate: range.startDate, endDate: range.endDate, shopName, goodsId },
|
||
'cs-quality-customers',
|
||
() => reportDatabase.query(
|
||
`SELECT TOP 5000
|
||
g.[uid] AS [uid],
|
||
MAX(NULLIF(g.[nickname], N'')) AS [nickname],
|
||
MAX(NULLIF(g.[csname], N'')) AS [csname],
|
||
COUNT_BIG(1) AS [messageCount],
|
||
MIN(TRY_CONVERT(DATETIME2, g.[msgTime])) AS [firstMsgTime],
|
||
MAX(TRY_CONVERT(DATETIME2, g.[msgTime])) AS [lastMsgTime]
|
||
FROM ${CHAT_TABLE} g WITH (NOLOCK)
|
||
WHERE ${conditions.join(' AND ')}
|
||
GROUP BY g.[uid]
|
||
ORDER BY COUNT_BIG(1) DESC`,
|
||
params,
|
||
{ requestTimeout: 120000 }
|
||
),
|
||
{ shouldCache: (value) => Array.isArray(value) && value.length > 0 }
|
||
);
|
||
return { range, rows: cached.value || [], cache: { hit: cached.hit } };
|
||
}
|
||
|
||
async function getMessages(options = {}) {
|
||
const goodsId = normalizeGoodsId(options.goodsId);
|
||
const range = resolveDateRange(options.startDate, options.endDate);
|
||
const uid = normalizeText(options.uid, 200);
|
||
const shopName = normalizeText(options.shopName, 200);
|
||
const params = { goodsId, startDate: range.startDate, endExclusiveDate: range.endExclusiveDate };
|
||
const conditions = [buildDateWhere('g', range), 'g.[goodsId] = @goodsId'];
|
||
if (uid) {
|
||
params.uid = uid;
|
||
conditions.push('g.[uid] = @uid');
|
||
}
|
||
if (shopName) {
|
||
params.shopName = `%${shopName}%`;
|
||
conditions.push('g.[shopName] LIKE @shopName');
|
||
}
|
||
const loader = () => reportDatabase.query(
|
||
`SELECT TOP 20000
|
||
g.[shopName] AS [shopName], g.[goodsId] AS [goodsId], g.[goodsName] AS [goodsName],
|
||
g.[uid] AS [uid], g.[nickname] AS [nickname], g.[msgId] AS [msgId],
|
||
g.[msgTime] AS [msgTime], g.[msgType] AS [msgType],
|
||
CASE WHEN ISNULL(g.[direction], 0) = 1 THEN N'客服' ELSE N'买家' END AS [directionLabel],
|
||
g.[csname] AS [csname], g.[content] AS [content]
|
||
FROM ${CHAT_TABLE} g WITH (NOLOCK)
|
||
WHERE ${conditions.join(' AND ')}
|
||
ORDER BY TRY_CONVERT(DATETIME2, g.[msgTime]) ASC, g.[id] ASC`,
|
||
params,
|
||
{ requestTimeout: 120000 }
|
||
);
|
||
if (!uid) return { range, rows: await loader() };
|
||
|
||
const cached = await getCachedCsQualityPayload(
|
||
'messages',
|
||
{ startDate: range.startDate, endDate: range.endDate, shopName, goodsId, uid },
|
||
'cs-quality-messages',
|
||
loader,
|
||
{
|
||
memory: 300,
|
||
redis: 900,
|
||
shouldCache: (value) => Array.isArray(value) && value.length > 0,
|
||
}
|
||
);
|
||
return { range, rows: cached.value || [], cache: { hit: cached.hit } };
|
||
}
|
||
|
||
async function getProductProfile(options = {}) {
|
||
const goodsId = normalizeGoodsId(options.goodsId);
|
||
const range = resolveDateRange(options.startDate, options.endDate);
|
||
const params = { goodsId, startDate: range.startDate, endDate: range.endDate };
|
||
const [latestRows, metricRows, chatRows] = await Promise.all([
|
||
reportDatabase.query(
|
||
`SELECT TOP 1
|
||
d.[goodsId] AS [goodsId], d.[goodsName] AS [goodsName], d.[shopName] AS [shopName],
|
||
d.[hdThumbUrl] AS [hdThumbUrl], d.[cate1Name] AS [cate1Name], d.[cate2Name] AS [cate2Name], d.[cate3Name] AS [cate3Name],
|
||
d.[createTime] AS [metricDate]
|
||
FROM ${GOODS_TABLE} d WITH (NOLOCK)
|
||
WHERE d.[goodsId] = TRY_CONVERT(BIGINT, @goodsId) AND d.[createTime] <= @endDate
|
||
ORDER BY TRY_CONVERT(DATE, d.[createTime]) DESC, d.[createdAt] DESC`,
|
||
params,
|
||
{ requestTimeout: 120000 }
|
||
),
|
||
reportDatabase.query(
|
||
`SELECT
|
||
COUNT_BIG(1) AS [metricDays],
|
||
SUM(TRY_CONVERT(DECIMAL(18, 4), REPLACE(d.[goodsUv], N',', N''))) AS [goodsUv],
|
||
SUM(TRY_CONVERT(DECIMAL(18, 4), REPLACE(d.[goodsPv], N',', N''))) AS [goodsPv],
|
||
SUM(TRY_CONVERT(DECIMAL(18, 4), REPLACE(d.[payOrdrAmt], N',', N''))) AS [payOrdrAmt],
|
||
SUM(TRY_CONVERT(DECIMAL(18, 4), REPLACE(d.[payOrdrGoodsQty], N',', N''))) AS [payOrdrGoodsQty],
|
||
SUM(TRY_CONVERT(DECIMAL(18, 4), REPLACE(d.[payOrdrCnt], N',', N''))) AS [payOrdrCnt],
|
||
SUM(TRY_CONVERT(DECIMAL(18, 4), REPLACE(d.[payOrdrUsrCnt], N',', N''))) AS [payOrdrUsrCnt],
|
||
SUM(TRY_CONVERT(DECIMAL(18, 4), REPLACE(d.[goodsFavCnt], N',', N''))) AS [goodsFavCnt],
|
||
AVG(TRY_CONVERT(DECIMAL(18, 4), REPLACE(d.[goodsVcr], N'%',''))) AS [goodsVcr],
|
||
AVG(TRY_CONVERT(DECIMAL(18, 4), REPLACE(d.[ordrVstrRto], N'%',''))) AS [ordrVstrRto],
|
||
AVG(TRY_CONVERT(DECIMAL(18, 4), REPLACE(d.[payOrdrRto], N'%',''))) AS [payOrdrRto],
|
||
AVG(TRY_CONVERT(DECIMAL(18, 4), REPLACE(d.[goodsPtHelpRate], N'%',''))) AS [goodsPtHelpRate]
|
||
FROM ${GOODS_TABLE} d WITH (NOLOCK)
|
||
WHERE d.[goodsId] = TRY_CONVERT(BIGINT, @goodsId)
|
||
AND d.[createTime] >= @startDate AND d.[createTime] <= @endDate`,
|
||
params,
|
||
{ requestTimeout: 120000 }
|
||
),
|
||
reportDatabase.query(
|
||
`SELECT COUNT_BIG(1) AS [messageCount], COUNT(DISTINCT g.[uid]) AS [userCount],
|
||
MIN(TRY_CONVERT(DATETIME2, g.[msgTime])) AS [chatStartAt],
|
||
MAX(TRY_CONVERT(DATETIME2, g.[msgTime])) AS [chatEndAt]
|
||
FROM ${CHAT_TABLE} g WITH (NOLOCK)
|
||
WHERE g.[goodsId] = @goodsId AND g.[createTime] >= @startDate AND g.[createTime] < @endExclusiveDate`,
|
||
{ goodsId, startDate: range.startDate, endExclusiveDate: range.endExclusiveDate },
|
||
{ requestTimeout: 120000 }
|
||
),
|
||
]);
|
||
|
||
const metrics = metricRows[0] || {};
|
||
return {
|
||
range,
|
||
product: latestRows[0] || { goodsId },
|
||
metrics: {
|
||
metricDays: Number(metrics.metricDays || 0),
|
||
goodsUv: formatMetric(metrics.goodsUv, 0), goodsPv: formatMetric(metrics.goodsPv, 0),
|
||
payOrdrAmt: formatMetric(metrics.payOrdrAmt), payOrdrGoodsQty: formatMetric(metrics.payOrdrGoodsQty, 0),
|
||
payOrdrCnt: formatMetric(metrics.payOrdrCnt, 0), payOrdrUsrCnt: formatMetric(metrics.payOrdrUsrCnt, 0),
|
||
goodsFavCnt: formatMetric(metrics.goodsFavCnt, 0), goodsVcr: formatMetric(metrics.goodsVcr),
|
||
ordrVstrRto: formatMetric(metrics.ordrVstrRto), payOrdrRto: formatMetric(metrics.payOrdrRto),
|
||
goodsPtHelpRate: formatMetric(metrics.goodsPtHelpRate),
|
||
},
|
||
chatSummary: chatRows[0] || { messageCount: 0, userCount: 0 },
|
||
};
|
||
}
|
||
|
||
async function getHistoryClient() {
|
||
if (!historyClientPromise) {
|
||
historyClientPromise = cloudDatabase.createPinnedQueryClient({
|
||
preferredProfile: 'public',
|
||
verifySql: `SELECT HAS_PERMS_BY_NAME(N'app', N'SCHEMA', N'INSERT') AS canInsert`,
|
||
verifyResult: (rows) => Number(rows?.[0]?.canInsert) === 1,
|
||
verifyFailureMessage: '公网业务数据库 app schema 没有写入权限',
|
||
}).catch((error) => {
|
||
historyClientPromise = null;
|
||
throw error;
|
||
});
|
||
}
|
||
return historyClientPromise;
|
||
}
|
||
|
||
async function ensureHistorySchema() {
|
||
if (!historySchemaPromise) {
|
||
historySchemaPromise = getHistoryClient().then((client) => client.query(
|
||
`IF OBJECT_ID(N'app.pdd_chat_ai_analysis_history', N'U') IS NULL
|
||
BEGIN
|
||
CREATE TABLE ${HISTORY_TABLE} (
|
||
id BIGINT IDENTITY(1,1) NOT NULL PRIMARY KEY,
|
||
analysis_id NVARCHAR(64) NOT NULL,
|
||
status NVARCHAR(20) NOT NULL,
|
||
goods_id NVARCHAR(80) NOT NULL,
|
||
goods_name NVARCHAR(500) NULL,
|
||
shop_name NVARCHAR(255) NULL,
|
||
product_image_url NVARCHAR(2000) NULL,
|
||
chat_start_date DATE NOT NULL,
|
||
chat_end_date DATE NOT NULL,
|
||
source_message_count INT NOT NULL DEFAULT 0,
|
||
source_customer_count INT NOT NULL DEFAULT 0,
|
||
product_metrics_json NVARCHAR(MAX) NULL,
|
||
request_prompt NVARCHAR(MAX) NULL,
|
||
ai_provider NVARCHAR(80) NULL,
|
||
ai_model NVARCHAR(120) NULL,
|
||
ai_response_json NVARCHAR(MAX) NULL,
|
||
ai_raw_response_json NVARCHAR(MAX) NULL,
|
||
conversation_type NVARCHAR(30) NULL,
|
||
analysis_json NVARCHAR(MAX) NULL,
|
||
error_message NVARCHAR(2000) NULL,
|
||
duration_ms INT NULL,
|
||
prompt_tokens INT NULL,
|
||
completion_tokens INT NULL,
|
||
total_tokens INT NULL,
|
||
progress_stage NVARCHAR(40) NULL,
|
||
progress_current INT NULL,
|
||
progress_total INT NULL,
|
||
progress_percent INT NULL,
|
||
progress_message NVARCHAR(500) NULL,
|
||
progress_updated_at DATETIME2(3) NULL,
|
||
created_by_user_id NVARCHAR(100) NULL,
|
||
created_by_name NVARCHAR(100) NULL,
|
||
created_at DATETIME2(3) NOT NULL DEFAULT SYSUTCDATETIME(),
|
||
updated_at DATETIME2(3) NOT NULL DEFAULT SYSUTCDATETIME()
|
||
);
|
||
END
|
||
IF COL_LENGTH(N'app.pdd_chat_ai_analysis_history', N'progress_stage') IS NULL
|
||
ALTER TABLE ${HISTORY_TABLE} ADD progress_stage NVARCHAR(40) NULL;
|
||
IF COL_LENGTH(N'app.pdd_chat_ai_analysis_history', N'progress_current') IS NULL
|
||
ALTER TABLE ${HISTORY_TABLE} ADD progress_current INT NULL;
|
||
IF COL_LENGTH(N'app.pdd_chat_ai_analysis_history', N'progress_total') IS NULL
|
||
ALTER TABLE ${HISTORY_TABLE} ADD progress_total INT NULL;
|
||
IF COL_LENGTH(N'app.pdd_chat_ai_analysis_history', N'progress_percent') IS NULL
|
||
ALTER TABLE ${HISTORY_TABLE} ADD progress_percent INT NULL;
|
||
IF COL_LENGTH(N'app.pdd_chat_ai_analysis_history', N'progress_message') IS NULL
|
||
ALTER TABLE ${HISTORY_TABLE} ADD progress_message NVARCHAR(500) NULL;
|
||
IF COL_LENGTH(N'app.pdd_chat_ai_analysis_history', N'progress_updated_at') IS NULL
|
||
ALTER TABLE ${HISTORY_TABLE} ADD progress_updated_at DATETIME2(3) NULL;
|
||
IF NOT EXISTS (SELECT 1 FROM sys.indexes WHERE name = N'UX_pdd_chat_ai_analysis_history_analysis_id' AND object_id = OBJECT_ID(N'app.pdd_chat_ai_analysis_history'))
|
||
CREATE UNIQUE INDEX UX_pdd_chat_ai_analysis_history_analysis_id ON ${HISTORY_TABLE}(analysis_id);
|
||
IF NOT EXISTS (SELECT 1 FROM sys.indexes WHERE name = N'IX_pdd_chat_ai_analysis_history_goods_date' AND object_id = OBJECT_ID(N'app.pdd_chat_ai_analysis_history'))
|
||
CREATE INDEX IX_pdd_chat_ai_analysis_history_goods_date ON ${HISTORY_TABLE}(goods_id, chat_start_date, chat_end_date, created_at DESC);
|
||
IF NOT EXISTS (SELECT 1 FROM sys.indexes WHERE name = N'IX_pdd_chat_ai_analysis_history_created_at' AND object_id = OBJECT_ID(N'app.pdd_chat_ai_analysis_history'))
|
||
CREATE INDEX IX_pdd_chat_ai_analysis_history_created_at ON ${HISTORY_TABLE}(created_at DESC);`,
|
||
{},
|
||
{ requestTimeout: 120000 }
|
||
)).catch((error) => {
|
||
historySchemaPromise = null;
|
||
throw error;
|
||
});
|
||
}
|
||
await historySchemaPromise;
|
||
}
|
||
|
||
function resolveAiProvider(config = {}) {
|
||
const hint = normalizeText(
|
||
config.provider || config.aiProvider || config.model || config.baseUrl || config.base_url,
|
||
500
|
||
).toLowerCase();
|
||
return hint.includes('agnes') ? AGNES_PROVIDER : QWEN_PROVIDER;
|
||
}
|
||
|
||
function resolveAiConfig(raw) {
|
||
const config = raw && typeof raw === 'object' ? raw : {};
|
||
const provider = resolveAiProvider(config);
|
||
const isAgnes = provider === AGNES_PROVIDER;
|
||
return {
|
||
provider,
|
||
baseUrl: normalizeText(
|
||
config.baseUrl || config.base_url
|
||
|| (isAgnes ? process.env.AGNES_AI_BASE_URL : process.env.QWEN_AI_BASE_URL)
|
||
|| (isAgnes ? DEFAULT_AGNES_BASE_URL : DEFAULT_QWEN_BASE_URL),
|
||
500
|
||
).replace(/\/+$/, ''),
|
||
apiKey: normalizeText(
|
||
config.apiKey || config.api_key
|
||
|| (isAgnes
|
||
? process.env.AGNES_API_KEY
|
||
: process.env.QWEN_API_KEY || process.env.DASHSCOPE_API_KEY),
|
||
4000
|
||
),
|
||
model: normalizeText(
|
||
config.model
|
||
|| (isAgnes ? process.env.AGNES_AI_MODEL : process.env.QWEN_AI_MODEL)
|
||
|| (isAgnes ? DEFAULT_AGNES_MODEL : DEFAULT_QWEN_MODEL),
|
||
120
|
||
),
|
||
timeoutMs: boundedInteger(
|
||
config.timeoutMs || config.timeout_ms
|
||
|| (isAgnes ? process.env.AGNES_AI_TIMEOUT_MS : process.env.QWEN_AI_TIMEOUT_MS),
|
||
isAgnes ? 600000 : 180000,
|
||
30000,
|
||
600000
|
||
),
|
||
batchMaxChars: boundedInteger(
|
||
config.batchMaxChars || config.batch_max_chars || process.env.CS_QUALITY_BATCH_MAX_CHARS,
|
||
DEFAULT_BATCH_MAX_CHARS,
|
||
10000,
|
||
200000
|
||
),
|
||
batchConcurrency: boundedInteger(
|
||
config.batchConcurrency || config.batch_concurrency || process.env.CS_QUALITY_BATCH_CONCURRENCY,
|
||
DEFAULT_BATCH_CONCURRENCY,
|
||
1,
|
||
5
|
||
),
|
||
batchMaxTokens: boundedInteger(
|
||
config.batchMaxTokens || config.batch_max_tokens || process.env.CS_QUALITY_BATCH_MAX_TOKENS,
|
||
DEFAULT_BATCH_MAX_TOKENS,
|
||
1000,
|
||
16000
|
||
),
|
||
mergeMaxTokens: boundedInteger(
|
||
config.mergeMaxTokens || config.merge_max_tokens || process.env.CS_QUALITY_MERGE_MAX_TOKENS,
|
||
DEFAULT_MERGE_MAX_TOKENS,
|
||
1000,
|
||
24000
|
||
),
|
||
mergeMaxBatches: boundedInteger(
|
||
config.mergeMaxBatches || config.merge_max_batches || process.env.CS_QUALITY_MERGE_MAX_BATCHES,
|
||
DEFAULT_MERGE_MAX_BATCHES,
|
||
0,
|
||
50
|
||
),
|
||
requestRetryCount: boundedInteger(
|
||
config.requestRetryCount || config.request_retry_count || process.env.CS_QUALITY_AI_REQUEST_RETRY_COUNT,
|
||
DEFAULT_AI_REQUEST_RETRY_COUNT,
|
||
0,
|
||
4
|
||
),
|
||
retryBaseDelayMs: boundedInteger(
|
||
config.retryBaseDelayMs || config.retry_base_delay_ms || process.env.CS_QUALITY_AI_RETRY_BASE_DELAY_MS,
|
||
DEFAULT_AI_RETRY_BASE_DELAY_MS,
|
||
250,
|
||
10000
|
||
),
|
||
};
|
||
}
|
||
|
||
async function getAiConfig() {
|
||
for (const key of AI_CONFIG_KEYS) {
|
||
const rows = await database.local.query('SELECT config_value AS configValue FROM system_config WHERE config_key = ? LIMIT 1', [key]);
|
||
if (rows[0]?.configValue) {
|
||
const stored = parseJson(rows[0].configValue, {});
|
||
if (stored?.enabled === false) continue;
|
||
const config = resolveAiConfig(stored);
|
||
if (config.apiKey) return config;
|
||
}
|
||
}
|
||
const config = resolveAiConfig({ provider: process.env.CS_QUALITY_AI_PROVIDER });
|
||
if (!config.apiKey) {
|
||
const error = new Error('AI质检服务尚未配置，请联系管理员');
|
||
error.statusCode = 503;
|
||
throw error;
|
||
}
|
||
return config;
|
||
}
|
||
|
||
function parseModelJson(content) {
|
||
const text = String(content || '').trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '').trim();
|
||
try { return JSON.parse(text); } catch (_) {
|
||
const start = text.indexOf('{');
|
||
const end = text.lastIndexOf('}');
|
||
if (start >= 0 && end > start) return JSON.parse(text.slice(start, end + 1));
|
||
throw new Error('AI服务返回内容格式异常');
|
||
}
|
||
}
|
||
|
||
function normalizeAnalysis(raw, sourceCounts, options = {}) {
|
||
const data = raw && typeof raw === 'object' ? raw : {};
|
||
const inputResults = Array.isArray(data.results) ? data.results : [];
|
||
const allowedConversationIds = new Set(
|
||
(Array.isArray(options.allowedConversationIds) ? options.allowedConversationIds : [])
|
||
.map((value) => normalizeText(value, 100))
|
||
.filter(Boolean)
|
||
);
|
||
const results = inputResults.map((item) => {
|
||
const consultationType = String(item?.consultation_type || item?.consultationType || '').includes('售后') ? '售后' : '售前';
|
||
let primaryReason = normalizeText(item?.primary_reason || item?.primaryReason, 100) || '未知';
|
||
let secondaryReason = normalizeText(item?.secondary_reason || item?.secondaryReason, 100);
|
||
if (consultationType === '售后') {
|
||
secondaryReason = AFTER_SALE_LABELS.has(secondaryReason) ? secondaryReason : '其他';
|
||
primaryReason = AFTER_SALE_PRIMARY[secondaryReason] || '其他售后';
|
||
} else {
|
||
primaryReason = PRE_SALE_MAP.get(secondaryReason) || '未知';
|
||
if (!PRE_SALE_MAP.has(secondaryReason)) secondaryReason = '其他问题';
|
||
}
|
||
const evidenceSource = Array.isArray(item?.evidence) ? item.evidence : (item?.evidence ? [{ text: item.evidence }] : []);
|
||
const evidence = evidenceSource.slice(0, 3).map((entry) => ({
|
||
conversation_id: normalizeText(entry?.conversation_id || entry?.conversationId || '', 100),
|
||
nickname: normalizeText(entry?.nickname, 100),
|
||
message_time: normalizeText(entry?.message_time || entry?.messageTime, 40),
|
||
text: normalizeText(entry?.text || entry?.content || entry, 1000),
|
||
})).filter((entry) => entry.text);
|
||
const affectedConversationIdSource = Array.isArray(item?.affected_conversation_ids)
|
||
? item.affected_conversation_ids
|
||
: Array.isArray(item?.affectedConversationIds)
|
||
? item.affectedConversationIds
|
||
: [];
|
||
const affectedConversationIds = Array.from(new Set([
|
||
...affectedConversationIdSource,
|
||
...evidence.map((entry) => entry.conversation_id),
|
||
]
|
||
.map((value) => normalizeText(value, 100))
|
||
.filter((value) => value && (allowedConversationIds.size === 0 || allowedConversationIds.has(value)))));
|
||
const areas = Array.isArray(item?.product_improvement_areas)
|
||
? item.product_improvement_areas.filter((area) => IMPROVEMENT_AREAS.has(area))
|
||
: [];
|
||
const imageUrls = Array.isArray(item?.image_urls)
|
||
? item.image_urls.filter((url) => /^https?:\/\//i.test(String(url)) && IMAGE_URL_PATTERN.test(String(url))).slice(0, 5)
|
||
: [];
|
||
return {
|
||
consultation_type: consultationType,
|
||
primary_reason: primaryReason,
|
||
secondary_reason: secondaryReason,
|
||
occurrence_count: Math.max(1, Number(item?.occurrence_count) || 1),
|
||
affected_customer_count: Math.max(affectedConversationIds.length, Number(item?.affected_customer_count) || 1),
|
||
affected_conversation_ids: affectedConversationIds,
|
||
buyer_intent: normalizeText(item?.buyer_intent, 500),
|
||
evidence,
|
||
image_urls: imageUrls,
|
||
product_improvement_areas: areas,
|
||
improvement_suggestion: normalizeText(item?.improvement_suggestion, 1000),
|
||
confidence: Math.min(1, Math.max(0, Number(item?.confidence) || 0)),
|
||
};
|
||
}).filter((item) => item.evidence.length || item.buyer_intent);
|
||
const hasPre = results.some((item) => item.consultation_type === '售前');
|
||
const hasAfter = results.some((item) => item.consultation_type === '售后');
|
||
return {
|
||
schema_version: HISTORY_SCHEMA_VERSION,
|
||
conversation_type: hasPre && hasAfter ? '混合' : hasAfter ? '售后' : hasPre ? '售前' : '无有效咨询',
|
||
summary: {
|
||
conversation_count: Number(data.summary?.conversation_count) || sourceCounts.customerCount,
|
||
pre_sale_conversation_count: Number(data.summary?.pre_sale_conversation_count) || 0,
|
||
after_sale_conversation_count: Number(data.summary?.after_sale_conversation_count) || 0,
|
||
mixed_conversation_count: Number(data.summary?.mixed_conversation_count) || 0,
|
||
main_findings: Array.isArray(data.summary?.main_findings) ? data.summary.main_findings.map((item) => normalizeText(item, 300)).filter(Boolean).slice(0, 10) : [],
|
||
},
|
||
results,
|
||
};
|
||
}
|
||
|
||
function formatConversation(uid, items) {
|
||
const header = `【会话ID：${uid}；买家昵称：${normalizeText(items[0]?.nickname, 100)}】`;
|
||
const lines = items.map((row) => (
|
||
`[${normalizeText(row.msgTime, 40)}][${row.directionLabel}][客服：${normalizeText(row.csname, 100)}] ${normalizeText(row.content, 2000)}`
|
||
));
|
||
return `${header}\n${lines.join('\n')}`;
|
||
}
|
||
|
||
function buildConversationGroups(rows = []) {
|
||
const groups = new Map();
|
||
rows.forEach((row, index) => {
|
||
const key = normalizeText(row.uid, 100) || `unknown-${normalizeText(row.msgId, 100) || index}`;
|
||
if (!groups.has(key)) groups.set(key, []);
|
||
groups.get(key).push(row);
|
||
});
|
||
return Array.from(groups.entries()).map(([conversationId, items]) => {
|
||
const text = formatConversation(conversationId, items);
|
||
const dates = items.map((item) => extractMessageDate(item.msgTime)).filter(Boolean).sort();
|
||
return {
|
||
conversationId,
|
||
messageCount: items.length,
|
||
text,
|
||
charCount: text.length,
|
||
startDate: dates[0] || null,
|
||
endDate: dates[dates.length - 1] || null,
|
||
};
|
||
});
|
||
}
|
||
|
||
function buildChatText(rows) {
|
||
return buildConversationGroups(rows).map((group) => group.text).join('\n\n');
|
||
}
|
||
|
||
function createChatBatches(rows, maxChars = DEFAULT_BATCH_MAX_CHARS) {
|
||
const limit = boundedInteger(maxChars, DEFAULT_BATCH_MAX_CHARS, 1000, 1000000);
|
||
const conversationGroups = buildConversationGroups(rows);
|
||
const batches = [];
|
||
let current = [];
|
||
let currentChars = 0;
|
||
|
||
const flush = () => {
|
||
if (!current.length) return;
|
||
const text = current.map((group) => group.text).join('\n\n');
|
||
batches.push({
|
||
index: batches.length + 1,
|
||
text,
|
||
charCount: text.length,
|
||
messageCount: current.reduce((sum, group) => sum + group.messageCount, 0),
|
||
customerCount: current.length,
|
||
conversationIds: current.map((group) => group.conversationId),
|
||
oversizedConversation: current.length === 1 && current[0].charCount > limit,
|
||
startDate: current.map((group) => group.startDate).filter(Boolean).sort()[0] || null,
|
||
endDate: current.map((group) => group.endDate).filter(Boolean).sort().at(-1) || null,
|
||
});
|
||
current = [];
|
||
currentChars = 0;
|
||
};
|
||
|
||
for (const group of conversationGroups) {
|
||
const separatorLength = current.length ? 2 : 0;
|
||
if (current.length && currentChars + separatorLength + group.charCount > limit) flush();
|
||
current.push(group);
|
||
currentChars += (current.length > 1 ? 2 : 0) + group.charCount;
|
||
}
|
||
flush();
|
||
return batches;
|
||
}
|
||
|
||
function analysisResultKey(item = {}) {
|
||
return [item.consultation_type, item.primary_reason, item.secondary_reason].join('|');
|
||
}
|
||
|
||
function mergeBatchAnalysesLocally(analyses, sourceCounts) {
|
||
const resultMap = new Map();
|
||
const findings = [];
|
||
const summary = {
|
||
conversation_count: sourceCounts.customerCount,
|
||
pre_sale_conversation_count: 0,
|
||
after_sale_conversation_count: 0,
|
||
mixed_conversation_count: 0,
|
||
main_findings: findings,
|
||
};
|
||
|
||
for (const analysis of analyses) {
|
||
const batchSummary = analysis?.summary || {};
|
||
summary.pre_sale_conversation_count += Number(batchSummary.pre_sale_conversation_count) || 0;
|
||
summary.after_sale_conversation_count += Number(batchSummary.after_sale_conversation_count) || 0;
|
||
summary.mixed_conversation_count += Number(batchSummary.mixed_conversation_count) || 0;
|
||
for (const finding of batchSummary.main_findings || []) {
|
||
const normalizedFinding = normalizeText(finding, 300);
|
||
if (normalizedFinding && !findings.includes(normalizedFinding) && findings.length < 10) findings.push(normalizedFinding);
|
||
}
|
||
|
||
for (const item of analysis?.results || []) {
|
||
const key = analysisResultKey(item);
|
||
const existing = resultMap.get(key);
|
||
if (!existing) {
|
||
resultMap.set(key, {
|
||
...item,
|
||
evidence: [...(item.evidence || [])],
|
||
affected_conversation_ids: [...(item.affected_conversation_ids || [])],
|
||
image_urls: [...(item.image_urls || [])],
|
||
product_improvement_areas: [...(item.product_improvement_areas || [])],
|
||
});
|
||
continue;
|
||
}
|
||
existing.occurrence_count += Number(item.occurrence_count) || 0;
|
||
existing.affected_customer_count += Number(item.affected_customer_count) || 0;
|
||
existing.affected_conversation_ids = Array.from(new Set([
|
||
...(existing.affected_conversation_ids || []),
|
||
...(item.affected_conversation_ids || []),
|
||
]));
|
||
existing.confidence = Math.max(Number(existing.confidence) || 0, Number(item.confidence) || 0);
|
||
for (const evidence of item.evidence || []) {
|
||
const evidenceKey = `${evidence.conversation_id}|${evidence.message_time}|${evidence.text}`;
|
||
const exists = existing.evidence.some((entry) => `${entry.conversation_id}|${entry.message_time}|${entry.text}` === evidenceKey);
|
||
if (!exists && existing.evidence.length < 3) existing.evidence.push(evidence);
|
||
}
|
||
existing.image_urls = Array.from(new Set([...existing.image_urls, ...(item.image_urls || [])])).slice(0, 5);
|
||
existing.product_improvement_areas = Array.from(new Set([
|
||
...existing.product_improvement_areas,
|
||
...(item.product_improvement_areas || []),
|
||
]));
|
||
}
|
||
}
|
||
|
||
const results = Array.from(resultMap.values());
|
||
const hasPre = results.some((item) => item.consultation_type === '售前');
|
||
const hasAfter = results.some((item) => item.consultation_type === '售后');
|
||
return {
|
||
schema_version: HISTORY_SCHEMA_VERSION,
|
||
conversation_type: hasPre && hasAfter ? '混合' : hasAfter ? '售后' : hasPre ? '售前' : '无有效咨询',
|
||
summary,
|
||
results,
|
||
};
|
||
}
|
||
|
||
function reconcileMergedAnalysis(modelAnalysis, localAnalysis, sourceCounts) {
|
||
const localByKey = new Map(localAnalysis.results.map((item) => [analysisResultKey(item), item]));
|
||
const reconciled = [];
|
||
const seen = new Set();
|
||
for (const item of modelAnalysis.results) {
|
||
const key = analysisResultKey(item);
|
||
const local = localByKey.get(key);
|
||
if (!local || seen.has(key)) continue;
|
||
seen.add(key);
|
||
reconciled.push({
|
||
...item,
|
||
occurrence_count: local.occurrence_count,
|
||
affected_customer_count: local.affected_customer_count,
|
||
affected_conversation_ids: [...(local.affected_conversation_ids || [])],
|
||
});
|
||
}
|
||
for (const local of localAnalysis.results) {
|
||
const key = analysisResultKey(local);
|
||
if (!seen.has(key)) reconciled.push(local);
|
||
}
|
||
const hasPre = reconciled.some((item) => item.consultation_type === '售前');
|
||
const hasAfter = reconciled.some((item) => item.consultation_type === '售后');
|
||
return {
|
||
...modelAnalysis,
|
||
conversation_type: hasPre && hasAfter ? '混合' : hasAfter ? '售后' : hasPre ? '售前' : '无有效咨询',
|
||
summary: {
|
||
...modelAnalysis.summary,
|
||
conversation_count: sourceCounts.customerCount,
|
||
pre_sale_conversation_count: localAnalysis.summary.pre_sale_conversation_count,
|
||
after_sale_conversation_count: localAnalysis.summary.after_sale_conversation_count,
|
||
mixed_conversation_count: localAnalysis.summary.mixed_conversation_count,
|
||
},
|
||
results: reconciled,
|
||
};
|
||
}
|
||
|
||
function normalizeUsage(usage = {}) {
|
||
const promptTokens = Number(usage.prompt_tokens ?? usage.input_tokens) || 0;
|
||
const completionTokens = Number(usage.completion_tokens ?? usage.output_tokens) || 0;
|
||
return {
|
||
prompt_tokens: promptTokens,
|
||
completion_tokens: completionTokens,
|
||
total_tokens: Number(usage.total_tokens) || promptTokens + completionTokens,
|
||
};
|
||
}
|
||
|
||
function sumUsages(usages = []) {
|
||
return usages.reduce((total, usage) => {
|
||
const normalized = normalizeUsage(usage);
|
||
total.prompt_tokens += normalized.prompt_tokens;
|
||
total.completion_tokens += normalized.completion_tokens;
|
||
total.total_tokens += normalized.total_tokens;
|
||
return total;
|
||
}, { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 });
|
||
}
|
||
|
||
function buildMergePrompt({ product, sourceCounts, localAnalysis }) {
|
||
return [
|
||
`请汇总商品ID ${product.goodsId} 的分批聊天质检结果。`,
|
||
`完整数据共 ${sourceCounts.customerCount} 个客户、${sourceCounts.messageCount} 条消息。`,
|
||
'每个客户只存在于一个批次。请优化买家诉求概括、改进建议和主要发现，但必须遵守以下规则：',
|
||
'1. 不得新增或删除“咨询类型+一级原因+二级原因”的组合。',
|
||
'2. occurrence_count 和 affected_customer_count 必须原样保留。',
|
||
'3. 证据只能从输入中选择，不得改写、拼接或虚构。',
|
||
'4. 只能输出系统要求的合法 JSON。',
|
||
'',
|
||
`待汇总结果：${JSON.stringify(localAnalysis)}`,
|
||
].join('\n');
|
||
}
|
||
|
||
function getAiErrorDetail(error) {
|
||
const detail = error?.response?.data?.error?.message
|
||
|| error?.response?.data?.message
|
||
|| error?.response?.data?.error
|
||
|| error?.message;
|
||
const text = typeof detail === 'string' && detail.trim()
|
||
? detail
|
||
: detail && typeof detail === 'object'
|
||
? JSON.stringify(detail)
|
||
: error?.code || '未知错误';
|
||
return normalizeText(text, 1000)
|
||
.replace(/Bearer\s+\S+/gi, 'Bearer [redacted]')
|
||
.replace(/sk-[A-Za-z0-9_-]{12,}/g, '[redacted]');
|
||
}
|
||
|
||
function isRetryableAiError(error) {
|
||
const status = Number(error?.response?.status || error?.statusCode || 0);
|
||
if ([408, 425, 429].includes(status) || status >= 500) return true;
|
||
const code = normalizeText(error?.code, 100).toUpperCase();
|
||
return [
|
||
'ETIMEDOUT',
|
||
'ECONNABORTED',
|
||
'ECONNRESET',
|
||
'ECONNREFUSED',
|
||
'EAI_AGAIN',
|
||
'ENOTFOUND',
|
||
'EPIPE',
|
||
'UND_ERR_CONNECT_TIMEOUT',
|
||
'AI_RESPONSE_INVALID',
|
||
].includes(code);
|
||
}
|
||
|
||
function getAiRetryDelayMs(error, retryNumber, baseDelayMs = DEFAULT_AI_RETRY_BASE_DELAY_MS) {
|
||
const headers = error?.response?.headers;
|
||
const retryAfter = typeof headers?.get === 'function'
|
||
? headers.get('retry-after')
|
||
: headers?.['retry-after'];
|
||
if (retryAfter !== undefined && retryAfter !== null && String(retryAfter).trim()) {
|
||
const seconds = Number(retryAfter);
|
||
if (Number.isFinite(seconds) && seconds >= 0) {
|
||
return Math.min(Math.ceil(seconds * 1000), MAX_AI_RETRY_DELAY_MS);
|
||
}
|
||
const retryAt = Date.parse(String(retryAfter));
|
||
if (Number.isFinite(retryAt)) {
|
||
return Math.min(Math.max(retryAt - Date.now(), 0), MAX_AI_RETRY_DELAY_MS);
|
||
}
|
||
}
|
||
const base = boundedInteger(baseDelayMs, DEFAULT_AI_RETRY_BASE_DELAY_MS, 250, 10000);
|
||
return Math.min(base * (2 ** Math.max(0, Number(retryNumber) - 1)), MAX_AI_RETRY_DELAY_MS);
|
||
}
|
||
|
||
function sleep(milliseconds) {
|
||
return new Promise((resolve) => setTimeout(resolve, milliseconds));
|
||
}
|
||
|
||
function buildAiRequestPayload(config, messages, maxCompletionTokens) {
|
||
const payload = {
|
||
model: config.model,
|
||
messages,
|
||
temperature: 0,
|
||
stream: false,
|
||
};
|
||
if (config.provider === AGNES_PROVIDER) {
|
||
return { ...payload, max_tokens: maxCompletionTokens };
|
||
}
|
||
return {
|
||
...payload,
|
||
response_format: { type: 'json_object' },
|
||
max_completion_tokens: maxCompletionTokens,
|
||
enable_thinking: false,
|
||
};
|
||
}
|
||
|
||
async function requestAiJson(config, messages, maxCompletionTokens, context = {}) {
|
||
const maxAttempts = boundedInteger(config.requestRetryCount, DEFAULT_AI_REQUEST_RETRY_COUNT, 0, 4) + 1;
|
||
const requestStartedAt = Date.now();
|
||
|
||
for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
|
||
const attemptStartedAt = Date.now();
|
||
try {
|
||
const response = await axios.post(`${config.baseUrl}/chat/completions`, buildAiRequestPayload(
|
||
config,
|
||
messages,
|
||
maxCompletionTokens
|
||
), {
|
||
headers: { Authorization: `Bearer ${config.apiKey}`, 'Content-Type': 'application/json' },
|
||
timeout: config.timeoutMs,
|
||
maxBodyLength: 20 * 1024 * 1024,
|
||
});
|
||
const rawResponse = response.data || {};
|
||
const content = rawResponse?.choices?.[0]?.message?.content || '';
|
||
let parsed;
|
||
try {
|
||
parsed = parseModelJson(content);
|
||
} catch (parseError) {
|
||
parseError.code = 'AI_RESPONSE_INVALID';
|
||
throw parseError;
|
||
}
|
||
return {
|
||
rawResponse,
|
||
parsed,
|
||
usage: normalizeUsage(rawResponse.usage),
|
||
request: { attempts: attempt, durationMs: Date.now() - requestStartedAt },
|
||
};
|
||
} catch (error) {
|
||
const status = Number(error?.response?.status || 0) || null;
|
||
const code = normalizeText(error?.response?.data?.error?.code || error?.code || 'AI_REQUEST_FAILED', 100);
|
||
const detail = getAiErrorDetail(error);
|
||
const retryable = isRetryableAiError(error);
|
||
const diagnostic = {
|
||
operation: normalizeText(context.operation, 40) || 'analysis',
|
||
batchIndex: Number(context.batchIndex) || null,
|
||
batchTotal: Number(context.batchTotal) || null,
|
||
attempt,
|
||
maxAttempts,
|
||
status,
|
||
code,
|
||
durationMs: Date.now() - attemptStartedAt,
|
||
detail,
|
||
};
|
||
|
||
if (retryable && attempt < maxAttempts) {
|
||
const delayMs = getAiRetryDelayMs(error, attempt, config.retryBaseDelayMs);
|
||
console.warn('[CsQuality] AI 请求暂时失败，准备重试:', { ...diagnostic, delayMs });
|
||
if (typeof context.onRetry === 'function') {
|
||
try {
|
||
await context.onRetry({
|
||
attempt,
|
||
nextAttempt: attempt + 1,
|
||
maxAttempts,
|
||
delayMs,
|
||
code,
|
||
status,
|
||
});
|
||
} catch (progressError) {
|
||
console.warn('[CsQuality] 更新 AI 重试进度失败:', progressError.message);
|
||
}
|
||
}
|
||
await sleep(delayMs);
|
||
continue;
|
||
}
|
||
|
||
console.error('[CsQuality] AI 服务请求失败:', diagnostic);
|
||
const timedOut = ['ETIMEDOUT', 'ECONNABORTED', 'UND_ERR_CONNECT_TIMEOUT'].includes(code.toUpperCase());
|
||
const authorizationFailed = [401, 403].includes(status);
|
||
const rateLimited = status === 429;
|
||
const wrapped = new Error(
|
||
authorizationFailed
|
||
? 'AI质检服务配置校验失败，请联系管理员'
|
||
: rateLimited
|
||
? 'AI分析任务较多，请稍后重试'
|
||
: timedOut
|
||
? 'AI分析请求超时，请稍后重试'
|
||
: 'AI分析请求失败，请稍后重试'
|
||
);
|
||
wrapped.statusCode = status || (timedOut ? 504 : 502);
|
||
wrapped.code = code;
|
||
wrapped.internalDetail = detail;
|
||
wrapped.attempts = attempt;
|
||
wrapped.requestDurationMs = Date.now() - requestStartedAt;
|
||
wrapped.aiStatus = status;
|
||
wrapped.operation = diagnostic.operation;
|
||
throw wrapped;
|
||
}
|
||
}
|
||
|
||
throw new Error('AI分析请求失败，请稍后重试');
|
||
}
|
||
|
||
async function mapWithConcurrency(items, concurrency, mapper) {
|
||
const results = new Array(items.length);
|
||
let nextIndex = 0;
|
||
let firstError = null;
|
||
const worker = async () => {
|
||
while (nextIndex < items.length && !firstError) {
|
||
const index = nextIndex;
|
||
nextIndex += 1;
|
||
try {
|
||
results[index] = await mapper(items[index], index);
|
||
} catch (error) {
|
||
firstError ||= error;
|
||
}
|
||
}
|
||
};
|
||
await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
|
||
if (firstError) throw firstError;
|
||
return results;
|
||
}
|
||
|
||
async function insertHistory(client, payload) {
|
||
const rows = await client.query(
|
||
`INSERT INTO ${HISTORY_TABLE} (
|
||
analysis_id, status, goods_id, goods_name, shop_name, product_image_url,
|
||
chat_start_date, chat_end_date, source_message_count, source_customer_count,
|
||
product_metrics_json, request_prompt, ai_provider, ai_model, conversation_type,
|
||
progress_stage, progress_current, progress_total, progress_percent, progress_message, progress_updated_at,
|
||
created_by_user_id, created_by_name
|
||
) OUTPUT INSERTED.id
|
||
VALUES (@analysisId, @status, @goodsId, @goodsName, @shopName, @productImageUrl,
|
||
@chatStartDate, @chatEndDate, @messageCount, @customerCount,
|
||
@metricsJson, @prompt, @provider, @model, @conversationType,
|
||
@progressStage, @progressCurrent, @progressTotal, @progressPercent, @progressMessage, SYSUTCDATETIME(),
|
||
@createdByUserId, @createdByName)`,
|
||
payload,
|
||
{ requestTimeout: 120000 }
|
||
);
|
||
return rows[0]?.id;
|
||
}
|
||
|
||
async function updateHistoryContext(client, id, payload) {
|
||
await client.query(
|
||
`UPDATE ${HISTORY_TABLE}
|
||
SET goods_name = @goodsName, shop_name = @shopName, product_image_url = @productImageUrl,
|
||
source_message_count = @messageCount, source_customer_count = @customerCount,
|
||
product_metrics_json = @metricsJson, request_prompt = @prompt,
|
||
ai_provider = @provider, ai_model = @model, updated_at = SYSUTCDATETIME()
|
||
WHERE id = @id`,
|
||
{ id, ...payload },
|
||
{ requestTimeout: 120000 }
|
||
);
|
||
}
|
||
|
||
async function updateHistoryProgress(client, id, payload) {
|
||
await client.query(
|
||
`UPDATE ${HISTORY_TABLE}
|
||
SET status = @status, progress_stage = @progressStage,
|
||
progress_current = @progressCurrent, progress_total = @progressTotal,
|
||
progress_percent = @progressPercent, progress_message = @progressMessage,
|
||
progress_updated_at = SYSUTCDATETIME(), updated_at = SYSUTCDATETIME()
|
||
WHERE id = @id`,
|
||
{ id, ...payload },
|
||
{ requestTimeout: 120000 }
|
||
);
|
||
}
|
||
|
||
async function updateHistory(client, id, payload) {
|
||
await client.query(
|
||
`UPDATE ${HISTORY_TABLE}
|
||
SET status = @status, ai_response_json = @aiResponseJson, ai_raw_response_json = @aiRawResponseJson,
|
||
conversation_type = @conversationType, analysis_json = @analysisJson, error_message = @errorMessage,
|
||
duration_ms = @durationMs, prompt_tokens = @promptTokens, completion_tokens = @completionTokens,
|
||
total_tokens = @totalTokens, progress_stage = @progressStage,
|
||
progress_current = @progressCurrent, progress_total = @progressTotal,
|
||
progress_percent = @progressPercent, progress_message = @progressMessage,
|
||
progress_updated_at = SYSUTCDATETIME(), updated_at = SYSUTCDATETIME()
|
||
WHERE id = @id`,
|
||
{ id, ...payload },
|
||
{ requestTimeout: 120000 }
|
||
);
|
||
}
|
||
|
||
function sanitizePublicError(value) {
|
||
return normalizeText(value, 2000)
|
||
.replace(/千问(?:模型)?/gi, 'AI服务')
|
||
.replace(/qwen[\w.:-]*/gi, 'AI服务')
|
||
.replace(/aliyun-model-studio/gi, 'AI服务')
|
||
.replace(/dashscope/gi, 'AI服务')
|
||
.replace(/(?:api|apihub)\.agnes-ai\.(?:cn|com)/gi, 'AI服务')
|
||
.replace(/agnes(?:-ai)?[\w.:-]*/gi, 'AI服务');
|
||
}
|
||
|
||
function createProgressReporter(client, historyId) {
|
||
let lastPercent = 0;
|
||
let writeQueue = Promise.resolve();
|
||
return (progress = {}) => {
|
||
lastPercent = Math.max(lastPercent, boundedInteger(progress.percent, lastPercent, 0, 100));
|
||
const payload = {
|
||
status: progress.status || 'running',
|
||
progressStage: normalizeText(progress.stage, 40) || 'running',
|
||
progressCurrent: Math.max(0, Number(progress.current) || 0),
|
||
progressTotal: Math.max(0, Number(progress.total) || 0),
|
||
progressPercent: lastPercent,
|
||
progressMessage: normalizeText(progress.message, 500) || '正在处理聊天记录',
|
||
};
|
||
writeQueue = writeQueue.then(() => updateHistoryProgress(client, historyId, payload));
|
||
return writeQueue;
|
||
};
|
||
}
|
||
|
||
async function createQueuedAnalysisHistory(input = {}, actor = {}) {
|
||
const goodsId = normalizeGoodsId(input.goodsId);
|
||
const range = resolveDateRange(input.startDate, input.endDate);
|
||
await ensureHistorySchema();
|
||
const client = await getHistoryClient();
|
||
const analysisId = crypto.randomUUID();
|
||
const historyId = await insertHistory(client, {
|
||
analysisId, status: 'queued', goodsId, goodsName: normalizeText(input.goodsName, 500) || null,
|
||
shopName: normalizeText(input.shopName, 255) || null,
|
||
productImageUrl: normalizeText(input.hdThumbUrl, 2000) || null,
|
||
chatStartDate: range.startDate, chatEndDate: range.endDate,
|
||
messageCount: 0, customerCount: 0, metricsJson: null,
|
||
prompt: null, provider: null, model: null, conversationType: null,
|
||
progressStage: 'queued', progressCurrent: 0, progressTotal: 0, progressPercent: 0,
|
||
progressMessage: '质检任务已创建，正在等待处理',
|
||
createdByUserId: normalizeText(actor.sub || actor.id, 100) || null, createdByName: normalizeText(actor.name || actor.username, 100) || null,
|
||
});
|
||
if (!historyId) throw new Error('创建质检任务失败，请稍后重试');
|
||
return { client, historyId, analysisId, goodsId, range, startedAt: Date.now() };
|
||
}
|
||
|
||
async function startAnalysisJob(input = {}, actor = {}) {
|
||
const queued = await createQueuedAnalysisHistory(input, actor);
|
||
const normalizedInput = {
|
||
...input,
|
||
goodsId: queued.goodsId,
|
||
startDate: queued.range.startDate,
|
||
endDate: queued.range.endDate,
|
||
};
|
||
setImmediate(() => {
|
||
runAnalysis(normalizedInput, actor, queued).catch((error) => {
|
||
console.error('[CsQuality] 后台质检任务失败:', {
|
||
analysisId: queued.analysisId,
|
||
message: error.message,
|
||
detail: error.internalDetail || null,
|
||
});
|
||
});
|
||
});
|
||
return {
|
||
historyId: queued.historyId,
|
||
analysisId: queued.analysisId,
|
||
status: 'queued',
|
||
range: queued.range,
|
||
createdAt: new Date(queued.startedAt).toISOString(),
|
||
progress: {
|
||
stage: 'queued', current: 0, total: 0, percent: 0,
|
||
message: '质检任务已创建，正在等待处理',
|
||
},
|
||
};
|
||
}
|
||
|
||
async function runAnalysis(input = {}, actor = {}, runtime = {}) {
|
||
const state = runtime.historyId
|
||
? {
|
||
client: runtime.client || await getHistoryClient(),
|
||
historyId: runtime.historyId,
|
||
analysisId: runtime.analysisId,
|
||
goodsId: normalizeGoodsId(input.goodsId),
|
||
range: resolveDateRange(input.startDate, input.endDate),
|
||
startedAt: runtime.startedAt || Date.now(),
|
||
}
|
||
: await createQueuedAnalysisHistory(input, actor);
|
||
const { client, historyId, analysisId, goodsId, range, startedAt } = state;
|
||
const reportProgress = createProgressReporter(client, historyId);
|
||
let progressTotal = 0;
|
||
let progressCurrent = 0;
|
||
|
||
try {
|
||
await reportProgress({ stage: 'preparing', percent: 3, message: '正在核对商品与时间范围' });
|
||
const [profile, config] = await Promise.all([
|
||
getProductProfile({ goodsId, startDate: range.startDate, endDate: range.endDate }),
|
||
getAiConfig(),
|
||
]);
|
||
const sourceCounts = {
|
||
messageCount: Number(profile.chatSummary?.messageCount || 0),
|
||
customerCount: Number(profile.chatSummary?.userCount || 0),
|
||
};
|
||
if (!sourceCounts.messageCount) throw new Error('所选日期内没有该商品的聊天记录');
|
||
if (sourceCounts.messageCount > MAX_ANALYSIS_MESSAGES) {
|
||
throw new Error(`聊天记录共${sourceCounts.messageCount}条，超过单次分析上限${MAX_ANALYSIS_MESSAGES}条，请缩短日期范围`);
|
||
}
|
||
await reportProgress({
|
||
stage: 'loading', percent: 10,
|
||
message: `已统计 ${sourceCounts.customerCount} 个客户、${sourceCounts.messageCount} 条消息，正在读取聊天内容`,
|
||
});
|
||
|
||
const messageResult = await getMessages({ goodsId, startDate: range.startDate, endDate: range.endDate });
|
||
const chatText = buildChatText(messageResult.rows);
|
||
if (chatText.length > MAX_ANALYSIS_TEXT_LENGTH) throw new Error('聊天内容过长，请缩短日期范围后再分析');
|
||
await reportProgress({ stage: 'grouping', percent: 16, message: '正在按客户整理完整会话，避免上下文被截断' });
|
||
|
||
const product = {
|
||
...profile.product,
|
||
goodsId,
|
||
goodsName: profile.product.goodsName || input.goodsName || '',
|
||
shopName: profile.product.shopName || input.shopName || '',
|
||
};
|
||
const batches = createChatBatches(messageResult.rows, config.batchMaxChars);
|
||
if (!batches.length) throw new Error('所选日期内没有可分析的客户会话');
|
||
progressTotal = batches.length;
|
||
const requestMetadata = JSON.stringify({
|
||
mode: 'segmented-conversations',
|
||
provider: config.provider,
|
||
model: config.model,
|
||
batchMaxChars: config.batchMaxChars,
|
||
batchConcurrency: config.batchConcurrency,
|
||
batches: batches.map((batch) => ({
|
||
index: batch.index,
|
||
messageCount: batch.messageCount,
|
||
customerCount: batch.customerCount,
|
||
charCount: batch.charCount,
|
||
conversationIds: batch.conversationIds,
|
||
oversizedConversation: batch.oversizedConversation,
|
||
startDate: batch.startDate,
|
||
endDate: batch.endDate,
|
||
})),
|
||
});
|
||
await updateHistoryContext(client, historyId, {
|
||
goodsName: product.goodsName,
|
||
shopName: product.shopName,
|
||
productImageUrl: product.hdThumbUrl || input.hdThumbUrl || null,
|
||
messageCount: sourceCounts.messageCount,
|
||
customerCount: sourceCounts.customerCount,
|
||
metricsJson: JSON.stringify(profile.metrics),
|
||
prompt: requestMetadata,
|
||
provider: config.provider,
|
||
model: config.model,
|
||
});
|
||
await reportProgress({
|
||
stage: 'batching', total: progressTotal, percent: 20,
|
||
message: `已拆分为 ${progressTotal} 批，准备开始分析`,
|
||
});
|
||
|
||
const batchResponses = await mapWithConcurrency(batches, config.batchConcurrency, async (batch) => {
|
||
await reportProgress({
|
||
stage: 'analyzing', current: progressCurrent, total: progressTotal,
|
||
percent: 20 + Math.floor((progressCurrent / progressTotal) * 64),
|
||
message: `正在分析 ${formatBatchDateRange(batch)} 的聊天记录（第 ${batch.index}/${progressTotal} 批）`,
|
||
});
|
||
const prompt = buildUserPrompt({
|
||
product,
|
||
metrics: profile.metrics,
|
||
chatText: batch.text,
|
||
startDate: range.startDate,
|
||
endDate: range.endDate,
|
||
});
|
||
let response;
|
||
try {
|
||
response = await requestAiJson(config, [
|
||
{ role: 'system', content: buildSystemPrompt() },
|
||
{
|
||
role: 'user',
|
||
content: `${prompt}\n\n这是分批质检中的第 ${batch.index}/${batches.length} 批，仅分析本批提供的完整客户会话。`,
|
||
},
|
||
], config.batchMaxTokens, {
|
||
operation: 'batch-analysis',
|
||
batchIndex: batch.index,
|
||
batchTotal: progressTotal,
|
||
onRetry: ({ nextAttempt, maxAttempts, delayMs }) => reportProgress({
|
||
stage: 'retrying', current: progressCurrent, total: progressTotal,
|
||
percent: 20 + Math.floor((progressCurrent / progressTotal) * 64),
|
||
message: `第 ${batch.index}/${progressTotal} 批连接波动，将在 ${Math.max(1, Math.ceil(delayMs / 1000))} 秒后进行第 ${nextAttempt}/${maxAttempts} 次尝试`,
|
||
}),
|
||
});
|
||
} catch (error) {
|
||
error.failedBatch = {
|
||
index: batch.index,
|
||
total: progressTotal,
|
||
messageCount: batch.messageCount,
|
||
customerCount: batch.customerCount,
|
||
charCount: batch.charCount,
|
||
startDate: batch.startDate,
|
||
endDate: batch.endDate,
|
||
};
|
||
throw error;
|
||
}
|
||
const batchResponse = {
|
||
batch: {
|
||
index: batch.index,
|
||
messageCount: batch.messageCount,
|
||
customerCount: batch.customerCount,
|
||
charCount: batch.charCount,
|
||
conversationIds: batch.conversationIds,
|
||
startDate: batch.startDate,
|
||
endDate: batch.endDate,
|
||
},
|
||
analysis: normalizeAnalysis(response.parsed, {
|
||
messageCount: batch.messageCount,
|
||
customerCount: batch.customerCount,
|
||
}, {
|
||
allowedConversationIds: batch.conversationIds,
|
||
}),
|
||
rawResponse: response.rawResponse,
|
||
usage: response.usage,
|
||
};
|
||
progressCurrent += 1;
|
||
await reportProgress({
|
||
stage: 'analyzing', current: progressCurrent, total: progressTotal,
|
||
percent: 20 + Math.floor((progressCurrent / progressTotal) * 64),
|
||
message: progressCurrent < progressTotal
|
||
? `已完成 ${progressCurrent}/${progressTotal} 批，正在继续处理其余聊天记录`
|
||
: `已完成全部 ${progressTotal} 批聊天记录，正在整理诊断结果`,
|
||
});
|
||
return batchResponse;
|
||
});
|
||
|
||
await reportProgress({
|
||
stage: 'merging', current: progressTotal, total: progressTotal, percent: 88,
|
||
message: '批次分析完成，正在合并诊断结果',
|
||
});
|
||
const localAnalysis = mergeBatchAnalysesLocally(
|
||
batchResponses.map((response) => response.analysis),
|
||
sourceCounts
|
||
);
|
||
let normalized = localAnalysis;
|
||
let mergeResponse = null;
|
||
let mergeFallback = false;
|
||
let mergeError = null;
|
||
const mergeSkipped = batchResponses.length > 1 && (
|
||
config.mergeMaxBatches === 0 || batchResponses.length > config.mergeMaxBatches
|
||
);
|
||
if (batchResponses.length > 1 && !mergeSkipped) {
|
||
try {
|
||
mergeResponse = await requestAiJson(config, [
|
||
{ role: 'system', content: buildSystemPrompt() },
|
||
{ role: 'user', content: buildMergePrompt({ product, sourceCounts, localAnalysis }) },
|
||
], config.mergeMaxTokens, {
|
||
operation: 'merge-analysis',
|
||
onRetry: ({ nextAttempt, maxAttempts, delayMs }) => reportProgress({
|
||
stage: 'retrying', current: progressTotal, total: progressTotal, percent: 88,
|
||
message: `汇总连接波动，将在 ${Math.max(1, Math.ceil(delayMs / 1000))} 秒后进行第 ${nextAttempt}/${maxAttempts} 次尝试`,
|
||
}),
|
||
});
|
||
const modelAnalysis = normalizeAnalysis(mergeResponse.parsed, sourceCounts, {
|
||
allowedConversationIds: batches.flatMap((batch) => batch.conversationIds),
|
||
});
|
||
normalized = reconcileMergedAnalysis(modelAnalysis, localAnalysis, sourceCounts);
|
||
} catch (error) {
|
||
mergeFallback = true;
|
||
mergeError = normalizeText(error.internalDetail || error.message, 1000);
|
||
console.warn('[CsQuality] 智能汇总请求失败，使用已完成批次生成结果:', mergeError);
|
||
}
|
||
}
|
||
|
||
await reportProgress({
|
||
stage: 'validating', current: progressTotal, total: progressTotal, percent: 94,
|
||
message: mergeFallback
|
||
? '智能汇总耗时较长，正在使用已完成批次校验结果'
|
||
: '正在校验问题分类和影响客户数',
|
||
});
|
||
|
||
const usage = sumUsages([
|
||
...batchResponses.map((response) => response.usage),
|
||
...(mergeResponse ? [mergeResponse.usage] : []),
|
||
]);
|
||
const rawResponse = {
|
||
provider: config.provider,
|
||
model: config.model,
|
||
batching: {
|
||
batchCount: batches.length,
|
||
batchMaxChars: config.batchMaxChars,
|
||
concurrency: config.batchConcurrency,
|
||
mergeFallback,
|
||
mergeSkipped,
|
||
mergeError,
|
||
},
|
||
batches: batchResponses.map((response) => ({
|
||
batch: response.batch,
|
||
response: response.rawResponse,
|
||
})),
|
||
mergeResponse: mergeResponse?.rawResponse || null,
|
||
};
|
||
await reportProgress({
|
||
stage: 'saving', current: progressTotal, total: progressTotal, percent: 98,
|
||
message: '正在保存质检结果',
|
||
});
|
||
await updateHistory(client, historyId, {
|
||
status: 'succeeded', aiResponseJson: JSON.stringify(normalized), aiRawResponseJson: JSON.stringify(rawResponse),
|
||
conversationType: normalized.conversation_type, analysisJson: JSON.stringify(normalized), errorMessage: null,
|
||
durationMs: Date.now() - startedAt, promptTokens: usage.prompt_tokens || null,
|
||
completionTokens: usage.completion_tokens || null, totalTokens: usage.total_tokens || null,
|
||
progressStage: 'completed', progressCurrent: progressTotal, progressTotal,
|
||
progressPercent: 100, progressMessage: '质检完成',
|
||
});
|
||
return {
|
||
historyId,
|
||
analysisId,
|
||
range,
|
||
product,
|
||
metrics: profile.metrics,
|
||
chatSummary: profile.chatSummary,
|
||
sourceCounts,
|
||
ai: {
|
||
usage,
|
||
durationMs: Date.now() - startedAt,
|
||
batching: {
|
||
batchCount: batches.length,
|
||
batchMaxChars: config.batchMaxChars,
|
||
concurrency: config.batchConcurrency,
|
||
mergeFallback,
|
||
mergeSkipped,
|
||
},
|
||
},
|
||
analysis: normalized,
|
||
};
|
||
} catch (error) {
|
||
const publicError = sanitizePublicError(error.message) || 'AI质检失败，请稍后重试';
|
||
const failureDiagnostic = {
|
||
type: 'cs-quality-failure',
|
||
analysisId,
|
||
operation: normalizeText(error.operation, 40) || null,
|
||
code: normalizeText(error.code, 100) || null,
|
||
status: Number(error.aiStatus || error.statusCode || 0) || null,
|
||
attempts: Number(error.attempts || 0) || null,
|
||
requestDurationMs: Number(error.requestDurationMs || 0) || null,
|
||
detail: getAiErrorDetail({ message: error.internalDetail || error.message, code: error.code }),
|
||
failedBatch: error.failedBatch || null,
|
||
};
|
||
console.error('[CsQuality] 质检任务执行失败:', failureDiagnostic);
|
||
await updateHistory(client, historyId, {
|
||
status: 'failed', aiResponseJson: null, aiRawResponseJson: JSON.stringify(failureDiagnostic), conversationType: null, analysisJson: null,
|
||
errorMessage: publicError,
|
||
durationMs: Date.now() - startedAt, promptTokens: null, completionTokens: null, totalTokens: null,
|
||
progressStage: 'failed', progressCurrent, progressTotal,
|
||
progressPercent: 100, progressMessage: '质检未完成，请查看失败原因后重试',
|
||
}).catch((updateError) => console.error('[CsQuality] 保存 AI 失败记录失败:', updateError.message));
|
||
error.message = publicError;
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
function sqlDateToText(value) {
|
||
if (value instanceof Date && Number.isFinite(value.getTime())) return value.toISOString().slice(0, 10);
|
||
const match = String(value || '').match(/\d{4}-\d{2}-\d{2}/);
|
||
return match?.[0] || null;
|
||
}
|
||
|
||
function serializeAnalysisJob(row) {
|
||
const status = normalizeText(row.status, 20) || 'failed';
|
||
const analysis = parseJson(row.analysisJson, null) || parseJson(row.aiResponseJson, null);
|
||
const metrics = parseJson(row.metricsJson, {});
|
||
const requestMetadata = parseJson(row.requestPrompt, {});
|
||
const messageCount = Number(row.messageCount || 0);
|
||
const customerCount = Number(row.customerCount || 0);
|
||
const range = {
|
||
startDate: sqlDateToText(row.chatStartDate),
|
||
endDate: sqlDateToText(row.chatEndDate),
|
||
};
|
||
const product = {
|
||
goodsId: row.goodsId,
|
||
goodsName: row.goodsName,
|
||
shopName: row.shopName,
|
||
hdThumbUrl: row.productImageUrl,
|
||
};
|
||
const progress = {
|
||
stage: normalizeText(row.progressStage, 40) || status,
|
||
current: Math.max(0, Number(row.progressCurrent || 0)),
|
||
total: Math.max(0, Number(row.progressTotal || 0)),
|
||
percent: status === 'succeeded' ? 100 : Math.min(100, Math.max(0, Number(row.progressPercent || 0))),
|
||
message: sanitizePublicError(row.progressMessage)
|
||
|| (status === 'succeeded' ? '质检完成' : status === 'failed' ? '质检未完成' : '正在处理聊天记录'),
|
||
updatedAt: row.progressUpdatedAt || row.updatedAt || null,
|
||
};
|
||
const job = {
|
||
historyId: row.id,
|
||
analysisId: row.analysisId,
|
||
status,
|
||
range,
|
||
product,
|
||
messageCount,
|
||
customerCount,
|
||
durationMs: Number(row.durationMs || 0) || null,
|
||
errorMessage: sanitizePublicError(row.errorMessage),
|
||
createdAt: row.createdAt,
|
||
updatedAt: row.updatedAt,
|
||
progress,
|
||
};
|
||
if (status === 'succeeded' && analysis) {
|
||
job.result = {
|
||
historyId: row.id,
|
||
analysisId: row.analysisId,
|
||
range,
|
||
product,
|
||
metrics,
|
||
chatSummary: { messageCount, userCount: customerCount },
|
||
sourceCounts: { messageCount, customerCount },
|
||
ai: {
|
||
durationMs: Number(row.durationMs || 0),
|
||
usage: {
|
||
prompt_tokens: Number(row.promptTokens || 0),
|
||
completion_tokens: Number(row.completionTokens || 0),
|
||
total_tokens: Number(row.totalTokens || 0),
|
||
},
|
||
batching: { batchCount: Array.isArray(requestMetadata.batches) ? requestMetadata.batches.length : progress.total },
|
||
},
|
||
analysis,
|
||
};
|
||
}
|
||
return job;
|
||
}
|
||
|
||
async function getAnalysisJob(analysisId) {
|
||
const normalizedId = normalizeText(analysisId, 64);
|
||
if (!normalizedId) {
|
||
const error = new Error('质检任务编号不能为空');
|
||
error.statusCode = 400;
|
||
throw error;
|
||
}
|
||
await ensureHistorySchema();
|
||
const client = await getHistoryClient();
|
||
const rows = await client.query(
|
||
`SELECT TOP 1
|
||
id, analysis_id AS [analysisId], status,
|
||
goods_id AS [goodsId], goods_name AS [goodsName], shop_name AS [shopName], product_image_url AS [productImageUrl],
|
||
chat_start_date AS [chatStartDate], chat_end_date AS [chatEndDate],
|
||
source_message_count AS [messageCount], source_customer_count AS [customerCount],
|
||
product_metrics_json AS [metricsJson], request_prompt AS [requestPrompt],
|
||
ai_response_json AS [aiResponseJson], analysis_json AS [analysisJson], error_message AS [errorMessage],
|
||
duration_ms AS [durationMs], prompt_tokens AS [promptTokens], completion_tokens AS [completionTokens], total_tokens AS [totalTokens],
|
||
progress_stage AS [progressStage], progress_current AS [progressCurrent], progress_total AS [progressTotal],
|
||
progress_percent AS [progressPercent], progress_message AS [progressMessage], progress_updated_at AS [progressUpdatedAt],
|
||
created_at AS [createdAt], updated_at AS [updatedAt]
|
||
FROM ${HISTORY_TABLE} WHERE analysis_id = @analysisId`,
|
||
{ analysisId: normalizedId },
|
||
{ requestTimeout: 120000 }
|
||
);
|
||
if (!rows[0]) {
|
||
const error = new Error('质检任务不存在');
|
||
error.statusCode = 404;
|
||
throw error;
|
||
}
|
||
const row = rows[0];
|
||
const lastProgressAt = Date.parse(row.progressUpdatedAt || row.updatedAt || row.createdAt || '');
|
||
if (['queued', 'running'].includes(row.status)
|
||
&& Number.isFinite(lastProgressAt)
|
||
&& Date.now() - lastProgressAt > CS_QUALITY_JOB_STALE_MS) {
|
||
const errorMessage = '质检任务长时间没有更新，可能因服务重启而中断，请重新发起';
|
||
await client.query(
|
||
`UPDATE ${HISTORY_TABLE}
|
||
SET status = N'failed', error_message = @errorMessage,
|
||
progress_stage = N'failed', progress_percent = 100, progress_message = @progressMessage,
|
||
duration_ms = COALESCE(duration_ms, DATEDIFF_BIG(MILLISECOND, created_at, SYSUTCDATETIME())),
|
||
progress_updated_at = SYSUTCDATETIME(), updated_at = SYSUTCDATETIME()
|
||
WHERE id = @id AND status IN (N'queued', N'running')`,
|
||
{ id: row.id, errorMessage, progressMessage: '质检任务已中断，请重新发起' },
|
||
{ requestTimeout: 120000 }
|
||
);
|
||
row.status = 'failed';
|
||
row.errorMessage = errorMessage;
|
||
row.progressStage = 'failed';
|
||
row.progressPercent = 100;
|
||
row.progressMessage = '质检任务已中断，请重新发起';
|
||
}
|
||
return serializeAnalysisJob(row);
|
||
}
|
||
|
||
async function listHistory(options = {}) {
|
||
await ensureHistorySchema();
|
||
const client = await getHistoryClient();
|
||
const page = Math.max(1, Number(options.page) || 1);
|
||
const pageSize = Math.min(100, Math.max(1, Number(options.pageSize) || 20));
|
||
const offset = (page - 1) * pageSize;
|
||
const params = { offset, pageSize };
|
||
const conditions = ['1=1'];
|
||
if (normalizeText(options.goodsId, 80)) { params.goodsId = `%${normalizeText(options.goodsId, 80)}%`; conditions.push('h.goods_id LIKE @goodsId'); }
|
||
if (normalizeText(options.shopName, 200)) { params.shopName = `%${normalizeText(options.shopName, 200)}%`; conditions.push('h.shop_name LIKE @shopName'); }
|
||
const [countRows, rows] = await Promise.all([
|
||
client.query(
|
||
`SELECT COUNT_BIG(1) AS [total] FROM ${HISTORY_TABLE} h WHERE ${conditions.join(' AND ')}`,
|
||
params,
|
||
{ requestTimeout: 120000 }
|
||
),
|
||
client.query(
|
||
`SELECT id, analysis_id AS [analysisId], status, goods_id AS [goodsId], goods_name AS [goodsName], shop_name AS [shopName], product_image_url AS [productImageUrl],
|
||
chat_start_date AS [chatStartDate], chat_end_date AS [chatEndDate], source_message_count AS [messageCount], source_customer_count AS [customerCount],
|
||
conversation_type AS [conversationType], error_message AS [errorMessage], duration_ms AS [durationMs],
|
||
progress_current AS [progressCurrent], progress_total AS [progressTotal], progress_percent AS [progressPercent], progress_message AS [progressMessage],
|
||
created_by_name AS [createdByName], created_at AS [createdAt]
|
||
FROM ${HISTORY_TABLE} h WHERE ${conditions.join(' AND ')} ORDER BY h.created_at DESC OFFSET @offset ROWS FETCH NEXT @pageSize ROWS ONLY`,
|
||
params,
|
||
{ requestTimeout: 120000 }
|
||
),
|
||
]);
|
||
return {
|
||
page,
|
||
pageSize,
|
||
total: Number(countRows?.[0]?.total || 0),
|
||
rows: (rows || []).map((row) => ({
|
||
...row,
|
||
errorMessage: sanitizePublicError(row.errorMessage),
|
||
progressMessage: sanitizePublicError(row.progressMessage),
|
||
})),
|
||
};
|
||
}
|
||
|
||
async function getHistoryDetail(id) {
|
||
await ensureHistorySchema();
|
||
const client = await getHistoryClient();
|
||
const rows = await client.query(
|
||
`SELECT TOP 1
|
||
id, analysis_id, status, goods_id, goods_name, shop_name, product_image_url,
|
||
chat_start_date, chat_end_date, source_message_count, source_customer_count,
|
||
product_metrics_json, ai_response_json, conversation_type, analysis_json, error_message,
|
||
duration_ms, prompt_tokens, completion_tokens, total_tokens,
|
||
progress_stage, progress_current, progress_total, progress_percent, progress_message, progress_updated_at,
|
||
created_by_user_id, created_by_name, created_at, updated_at
|
||
FROM ${HISTORY_TABLE} WHERE id = @id`,
|
||
{ id: Number(id) },
|
||
{ requestTimeout: 120000 }
|
||
);
|
||
if (!rows[0]) return null;
|
||
const row = rows[0];
|
||
return {
|
||
...row,
|
||
error_message: sanitizePublicError(row.error_message),
|
||
progress_message: sanitizePublicError(row.progress_message),
|
||
analysis: parseJson(row.analysis_json, null),
|
||
metrics: parseJson(row.product_metrics_json, {}),
|
||
aiResponse: parseJson(row.ai_response_json, null),
|
||
};
|
||
}
|
||
|
||
module.exports = {
|
||
QWEN_PROVIDER,
|
||
AGNES_PROVIDER,
|
||
DEFAULT_QWEN_BASE_URL,
|
||
DEFAULT_QWEN_MODEL,
|
||
DEFAULT_AGNES_BASE_URL,
|
||
DEFAULT_AGNES_MODEL,
|
||
getGoods,
|
||
getChatDataMeta,
|
||
getCustomers,
|
||
getMessages,
|
||
getProductProfile,
|
||
startAnalysisJob,
|
||
getAnalysisJob,
|
||
runAnalysis,
|
||
listHistory,
|
||
getHistoryDetail,
|
||
_test: {
|
||
resolveAiConfig,
|
||
buildAiRequestPayload,
|
||
parseModelJson,
|
||
mapChatDataMeta,
|
||
aggregateChatDimensionRows,
|
||
buildConversationGroups,
|
||
createChatBatches,
|
||
normalizeAnalysis,
|
||
mergeBatchAnalysesLocally,
|
||
reconcileMergedAnalysis,
|
||
normalizeUsage,
|
||
sumUsages,
|
||
getAiErrorDetail,
|
||
isRetryableAiError,
|
||
getAiRetryDelayMs,
|
||
sanitizePublicError,
|
||
},
|
||
};
|