forked from lunanting/cangku
2151 lines
83 KiB
JavaScript
2151 lines
83 KiB
JavaScript
const cloudDb = require('../config/cloudDatabase');
|
||
const planningDatabase = require('./planningDatabase');
|
||
const {
|
||
getPlanningMayProductDataSummary,
|
||
MAY_PRODUCT_SNAPSHOT_TABLE,
|
||
MAY_PRODUCT_REVIEW_SNAPSHOT_TABLE,
|
||
} = require('./planningMayProductDataService');
|
||
|
||
const CHANNEL_ID_READ_TABLE = 'channel_id_daily_read';
|
||
const TMALL_LISTING_MAP_TABLE = 'jst_skumap_qmcust_add';
|
||
const PDD_LISTING_MAP_TABLE = 'jst_skumap_pdd';
|
||
const GENERIC_LISTING_MAP_TABLE = 'jst_skumap';
|
||
const SHOP_INFO_TABLE = 'jst_shopInfo';
|
||
const TARGET_MANAGEMENT_TABLE = 'op_TargetManagement';
|
||
const MAY_CHANNEL_ACTIVE_SKU_TABLE = 'planning_may_channel_active_sku_index_di';
|
||
const MAY_CHANNEL_SHOP_SNAPSHOT_TABLE = 'planning_may_channel_shop_snapshot_di';
|
||
const MAY_CHANNEL_LAYOUT_SNAPSHOT_TABLE = 'planning_may_channel_layout_snapshot_di';
|
||
const MAY_CHANNEL_INSIGHT_CALC_VERSION = 'may-channel-insight-v20260430-v9';
|
||
const TMALL_LISTING_SHOP_CHUNK_SIZE = Number.parseInt(process.env.PLANNING_MAY_CHANNEL_TMALL_LISTING_SHOP_CHUNK_SIZE || '20', 10);
|
||
const PDD_LISTING_SHOP_CHUNK_SIZE = Number.parseInt(process.env.PLANNING_MAY_CHANNEL_PDD_LISTING_SHOP_CHUNK_SIZE || '200', 10);
|
||
const GENERIC_LISTING_SHOP_CHUNK_SIZE = Number.parseInt(process.env.PLANNING_MAY_CHANNEL_GENERIC_LISTING_SHOP_CHUNK_SIZE || '10', 10);
|
||
const HIGH_INVENTORY_THRESHOLD = Number.parseInt(process.env.PLANNING_MAY_HIGH_INVENTORY_THRESHOLD || '50', 10);
|
||
const LOW_ITEM_ID_THRESHOLD = Number.parseInt(process.env.PLANNING_MAY_LOW_ITEM_ID_THRESHOLD || '1', 10);
|
||
const LOW_PROMOTION_ROI_THRESHOLD = Number.parseFloat(process.env.PLANNING_MAY_LOW_PROMOTION_ROI_THRESHOLD || '2');
|
||
let mayChannelInsightRefreshPromise = null;
|
||
let mayChannelInsightRefreshKey = '';
|
||
|
||
const MAJOR_CHANNELS = Object.freeze([
|
||
{ key: '1688', label: '1688' },
|
||
{ key: 'taobao', label: '淘宝' },
|
||
{ key: 'tmall', label: '天猫' },
|
||
{ key: 'pdd', label: '拼多多' },
|
||
{ key: 'jd', label: '京东' },
|
||
{ key: 'douyin', label: '抖音' },
|
||
{ key: 'vip', label: '唯品会' },
|
||
]);
|
||
|
||
function escapeIdentifier(identifier) {
|
||
return `\`${String(identifier).replace(/`/g, '``')}\``;
|
||
}
|
||
|
||
function toNumber(value, fallback = 0) {
|
||
const numeric = Number(value);
|
||
return Number.isFinite(numeric) ? numeric : fallback;
|
||
}
|
||
|
||
function normalizeText(value) {
|
||
return String(value ?? '').trim();
|
||
}
|
||
|
||
function formatDateOnly(value) {
|
||
if (!value) {
|
||
return '';
|
||
}
|
||
if (value instanceof Date) {
|
||
const year = value.getFullYear();
|
||
const month = String(value.getMonth() + 1).padStart(2, '0');
|
||
const day = String(value.getDate()).padStart(2, '0');
|
||
return `${year}-${month}-${day}`;
|
||
}
|
||
const text = String(value).trim();
|
||
const match = text.match(/^(\d{4}-\d{2}-\d{2})/);
|
||
return match ? match[1] : text;
|
||
}
|
||
|
||
function buildNotDiscontinuedCondition(columnExpression) {
|
||
return `LOCATE('停产', REPLACE(COALESCE(NULLIF(TRIM(${columnExpression}), ''), ''), '''', '')) = 0`;
|
||
}
|
||
|
||
function buildChannelLabelExpression(alias = 'd') {
|
||
const source = `LOWER(CONCAT_WS(' ', ${alias}.channel_name, ${alias}.shop_name))`;
|
||
const sourceRaw = `CONCAT_WS(' ', ${alias}.channel_name, ${alias}.shop_name)`;
|
||
return `
|
||
CASE
|
||
WHEN ${source} LIKE '%1688%' OR ${sourceRaw} LIKE '%阿里巴巴%' THEN '1688'
|
||
WHEN ${source} LIKE '%c2m%' OR ${sourceRaw} LIKE '%淘工厂%' THEN '淘工厂'
|
||
WHEN ${sourceRaw} LIKE '%天猫%' OR ${source} LIKE '%tmall%' THEN '天猫'
|
||
WHEN ${sourceRaw} LIKE '%淘宝%' THEN '淘宝'
|
||
WHEN ${sourceRaw} LIKE '%拼多多%' OR ${sourceRaw} LIKE '%多多%' OR ${source} LIKE '%pdd%' THEN '拼多多'
|
||
WHEN ${sourceRaw} LIKE '%京东%' OR ${sourceRaw} LIKE '%京喜%' OR ${source} LIKE '%jd%' THEN '京东'
|
||
WHEN ${sourceRaw} LIKE '%抖音%' OR ${source} LIKE '%douyin%' THEN '抖音'
|
||
WHEN ${sourceRaw} LIKE '%得物%' OR ${source} LIKE '%dewu%' THEN '得物'
|
||
WHEN ${sourceRaw} LIKE '%唯品会%' OR ${source} LIKE '%vip%' THEN '唯品会'
|
||
WHEN ${sourceRaw} LIKE '%视频号%' OR ${source} LIKE '%weixin%' OR ${source} LIKE '%wechat%' THEN '视频号小店'
|
||
ELSE COALESCE(NULLIF(TRIM(${alias}.channel_name), ''), '其他')
|
||
END
|
||
`;
|
||
}
|
||
|
||
function buildMajorChannelCountSelects() {
|
||
return MAJOR_CHANNELS.map((channel) => {
|
||
return `SUM(CASE WHEN c.channel_label = '${channel.label}' THEN 1 ELSE 0 END) AS channel_${channel.key}_row_count`;
|
||
}).join(',\n ');
|
||
}
|
||
|
||
function buildMissingChannelNamesExpression(prefix = 'c') {
|
||
return `CONCAT_WS('、',
|
||
${MAJOR_CHANNELS.map((channel) => `IF(COALESCE(${prefix}.channel_${channel.key}_row_count, 0) = 0, '${channel.label}', NULL)`).join(',\n ')}
|
||
)`;
|
||
}
|
||
|
||
function buildMissingChannelCountExpression(prefix = 'c') {
|
||
return `(${MAJOR_CHANNELS.map((channel) => `IF(COALESCE(${prefix}.channel_${channel.key}_row_count, 0) = 0, 1, 0)`).join(' + ')})`;
|
||
}
|
||
|
||
function chunkArray(items = [], chunkSize = 300) {
|
||
const normalizedSize = Math.max(Number(chunkSize) || 300, 1);
|
||
const chunks = [];
|
||
for (let index = 0; index < items.length; index += normalizedSize) {
|
||
chunks.push(items.slice(index, index + normalizedSize));
|
||
}
|
||
return chunks;
|
||
}
|
||
|
||
function buildInsightSnapshotKey(snapshotMeta = {}) {
|
||
return [
|
||
formatDateOnly(snapshotMeta.snapshotDate),
|
||
normalizeText(snapshotMeta.snapshotBatchId),
|
||
MAY_CHANNEL_INSIGHT_CALC_VERSION,
|
||
].filter(Boolean).join('__');
|
||
}
|
||
|
||
function normalizeShopKey(value) {
|
||
return normalizeText(value).replace(/[\s_-]+/g, '').toLowerCase();
|
||
}
|
||
|
||
function normalizeShopDisplayName(value) {
|
||
return normalizeText(value).replace(/-/g, '_');
|
||
}
|
||
|
||
function normalizeComparableShopKey(value) {
|
||
return normalizeShopKey(normalizeText(value).replace(/(?:（作废）|\(作废\))$/u, ''));
|
||
}
|
||
|
||
function resolveChannelLabelFromText(channelName = '', shopName = '') {
|
||
const source = `${normalizeText(channelName)} ${normalizeText(shopName)}`.toLowerCase();
|
||
const sourceRaw = `${normalizeText(channelName)} ${normalizeText(shopName)}`;
|
||
if (source.includes('1688') || sourceRaw.includes('阿里巴巴')) return '1688';
|
||
if (source.includes('c2m') || sourceRaw.includes('淘工厂')) return '淘工厂';
|
||
if (sourceRaw.includes('天猫') || source.includes('tmall')) return '天猫';
|
||
if (sourceRaw.includes('淘宝')) return '淘宝';
|
||
if (sourceRaw.includes('拼多多') || sourceRaw.includes('多多') || source.includes('pdd')) return '拼多多';
|
||
if (sourceRaw.includes('京东') || sourceRaw.includes('京喜') || source.includes('jd')) return '京东';
|
||
if (sourceRaw.includes('抖音') || source.includes('douyin')) return '抖音';
|
||
if (sourceRaw.includes('得物') || source.includes('dewu')) return '得物';
|
||
if (sourceRaw.includes('唯品会') || source.includes('vip')) return '唯品会';
|
||
if (sourceRaw.includes('视频号') || source.includes('weixin') || source.includes('wechat')) return '视频号小店';
|
||
return normalizeText(channelName) || '其他';
|
||
}
|
||
|
||
function resolveListingSourceBucket(channelName = '', shopName = '') {
|
||
const normalizedChannelName = normalizeText(channelName);
|
||
const resolvedChannelName = resolveChannelLabelFromText(normalizedChannelName, shopName);
|
||
if (resolvedChannelName === '拼多多') {
|
||
return 'pdd_listing';
|
||
}
|
||
if (['天猫', '淘宝', '1688', '淘工厂'].includes(resolvedChannelName)) {
|
||
return 'qmcust_listing';
|
||
}
|
||
return 'generic_listing';
|
||
}
|
||
|
||
function deriveProductCodeFromSku(value) {
|
||
const skuCode = normalizeText(value).toUpperCase().replace(/[-_].*$/u, '');
|
||
if (!skuCode) {
|
||
return '';
|
||
}
|
||
const match = skuCode.match(/^([A-Z]+[0-9]+)/u);
|
||
return match ? match[1] : skuCode;
|
||
}
|
||
|
||
function buildMayCoverageMatcher(mayRows = []) {
|
||
const exactCodeSet = new Set();
|
||
const prefixCodeSet = new Set();
|
||
|
||
(mayRows || []).forEach((row) => {
|
||
const maySkuCode = normalizeText(row.maySkuCode || row.may_sku_code).toUpperCase();
|
||
const productCode = normalizeText(row.productCode || row.product_code).toUpperCase();
|
||
const spuCode = normalizeText(row.spuCode || row.spu_code).toUpperCase();
|
||
const derivedProductCode = deriveProductCodeFromSku(maySkuCode);
|
||
|
||
[maySkuCode, productCode, spuCode]
|
||
.map((value) => normalizeText(value).toUpperCase())
|
||
.filter(Boolean)
|
||
.forEach((value) => exactCodeSet.add(value));
|
||
|
||
[productCode, spuCode, derivedProductCode]
|
||
.map((value) => normalizeText(value).toUpperCase())
|
||
.filter((value) => value && value.length >= 5)
|
||
.forEach((value) => prefixCodeSet.add(value));
|
||
});
|
||
|
||
const prefixCodes = Array.from(prefixCodeSet)
|
||
.sort((left, right) => right.length - left.length || left.localeCompare(right, 'en'));
|
||
|
||
return {
|
||
matchesSkuCode(value) {
|
||
const skuCode = normalizeText(value).toUpperCase();
|
||
if (!skuCode) {
|
||
return false;
|
||
}
|
||
if (exactCodeSet.has(skuCode)) {
|
||
return true;
|
||
}
|
||
return prefixCodes.some((prefix) => skuCode.startsWith(prefix));
|
||
},
|
||
matchesAnySkuCode(values = []) {
|
||
return (values || []).some((value) => this.matchesSkuCode(value));
|
||
},
|
||
};
|
||
}
|
||
|
||
function shouldPreferRawSkuIdentity(row = {}) {
|
||
const channelSource = normalizeText(row.channelName).toLowerCase();
|
||
return channelSource.includes('抖音')
|
||
|| channelSource.includes('douyin')
|
||
|| channelSource.includes('toutiao')
|
||
|| channelSource.includes('fxg');
|
||
}
|
||
|
||
function getPreferredListingSkuIdentity(row = {}) {
|
||
if (shouldPreferRawSkuIdentity(row)) {
|
||
const shortVideoCandidate = [
|
||
row.rawSkuCode,
|
||
row.outerSkuCode,
|
||
row.linkSkuCode,
|
||
row.shopItemId,
|
||
]
|
||
.map((value) => normalizeText(value).toUpperCase())
|
||
.find(Boolean);
|
||
if (shortVideoCandidate) {
|
||
return shortVideoCandidate;
|
||
}
|
||
}
|
||
const codeCandidate = getListingSkuCandidates(row)[0];
|
||
if (codeCandidate) {
|
||
return codeCandidate;
|
||
}
|
||
return normalizeText(row.shopSkuId).toUpperCase();
|
||
}
|
||
|
||
function getListingSkuCandidates(row = {}) {
|
||
const candidateValues = shouldPreferRawSkuIdentity(row)
|
||
? [row.rawSkuCode, row.outerSkuCode, row.linkSkuCode, row.skuCode]
|
||
: [row.skuCode, row.rawSkuCode, row.outerSkuCode, row.linkSkuCode];
|
||
return Array.from(
|
||
new Set(
|
||
candidateValues
|
||
.map((value) => normalizeText(value).toUpperCase())
|
||
.filter(Boolean)
|
||
)
|
||
);
|
||
}
|
||
|
||
function buildCurrentListingPredicate(alias = 'm', options = {}) {
|
||
const enabledExpr = `TRY_CONVERT(INT, ${alias}.enabled)`;
|
||
if (options.allowNullEnabled) {
|
||
return `(
|
||
ISNULL(${enabledExpr}, 0) = 1
|
||
OR (${enabledExpr} IS NULL AND ${alias}.pull_off_time IS NULL AND COALESCE(${alias}.shop_created, ${alias}.created) IS NOT NULL)
|
||
)`;
|
||
}
|
||
return `ISNULL(${enabledExpr}, 0) = 1`;
|
||
}
|
||
|
||
function createShopCoverageAccumulator(channelName = '', shopName = '', shopKey = '') {
|
||
return {
|
||
channelName: normalizeText(channelName),
|
||
shopName: normalizeShopDisplayName(shopName),
|
||
shopKey: normalizeShopKey(shopKey || shopName),
|
||
skuSet: new Set(),
|
||
itemSet: new Set(),
|
||
maySkuSet: new Set(),
|
||
mayItemSet: new Set(),
|
||
};
|
||
}
|
||
|
||
function materializeShopCoverageSummary(summary = {}) {
|
||
return {
|
||
channelName: normalizeText(summary.channelName),
|
||
shopName: normalizeText(summary.shopName),
|
||
shopKey: normalizeShopKey(summary.shopKey || summary.shopName),
|
||
skuCount: summary.skuSet?.size || 0,
|
||
itemIdCount: summary.itemSet?.size || 0,
|
||
maySkuCount: summary.maySkuSet?.size || 0,
|
||
mayItemIdCount: summary.mayItemSet?.size || 0,
|
||
maySkuSet: summary.maySkuSet || new Set(),
|
||
mayItemSet: summary.mayItemSet || new Set(),
|
||
};
|
||
}
|
||
|
||
async function queryDominantShopNameMap(shopCodes = []) {
|
||
const shopCodeMap = new Map();
|
||
const uniqueShopCodes = Array.from(new Set((shopCodes || []).map(normalizeText).filter(Boolean)));
|
||
if (uniqueShopCodes.length === 0) {
|
||
return shopCodeMap;
|
||
}
|
||
|
||
for (const shopCodeChunk of chunkArray(uniqueShopCodes, 200)) {
|
||
const params = {};
|
||
const placeholders = shopCodeChunk.map((shopCode, index) => {
|
||
const key = `shopCode${index}`;
|
||
params[key] = shopCode;
|
||
return `@${key}`;
|
||
});
|
||
|
||
const rows = await cloudDb.query(
|
||
`
|
||
WITH named AS (
|
||
SELECT
|
||
LTRIM(RTRIM(CAST(undefined9 AS NVARCHAR(100)))) AS shopCode,
|
||
LTRIM(RTRIM(CAST(undefined8 AS NVARCHAR(255)))) AS shopName,
|
||
COUNT(*) AS nameCount
|
||
FROM dbo.jst_goods_profit_kpi_items_afs
|
||
WHERE LTRIM(RTRIM(CAST(undefined9 AS NVARCHAR(100)))) IN (${placeholders.join(', ')})
|
||
AND LTRIM(RTRIM(CAST(undefined8 AS NVARCHAR(255)))) <> N''
|
||
GROUP BY
|
||
LTRIM(RTRIM(CAST(undefined9 AS NVARCHAR(100)))),
|
||
LTRIM(RTRIM(CAST(undefined8 AS NVARCHAR(255))))
|
||
),
|
||
ranked AS (
|
||
SELECT
|
||
shopCode,
|
||
shopName,
|
||
ROW_NUMBER() OVER (PARTITION BY shopCode ORDER BY nameCount DESC, shopName ASC) AS rn
|
||
FROM named
|
||
)
|
||
SELECT shopCode, shopName
|
||
FROM ranked
|
||
WHERE rn = 1
|
||
`,
|
||
params,
|
||
{ requestTimeout: 600000, maxAttempts: 2 }
|
||
);
|
||
|
||
rows.forEach((row) => {
|
||
const shopCode = normalizeText(row.shopCode);
|
||
const shopName = normalizeText(row.shopName);
|
||
if (shopCode && shopName && !shopCodeMap.has(shopCode)) {
|
||
shopCodeMap.set(shopCode, shopName);
|
||
}
|
||
});
|
||
}
|
||
|
||
return shopCodeMap;
|
||
}
|
||
|
||
function buildShopNameVariants(shopName = '') {
|
||
const normalized = normalizeText(shopName);
|
||
if (!normalized) {
|
||
return [];
|
||
}
|
||
const baseVariants = [
|
||
normalized,
|
||
normalized.replace(/_/g, '-'),
|
||
normalized.replace(/-/g, '_'),
|
||
].filter(Boolean);
|
||
const withDeprecatedSuffix = baseVariants.flatMap((value) => [
|
||
value,
|
||
`${value}（作废）`,
|
||
`${value}(作废)`,
|
||
]);
|
||
return Array.from(new Set(withDeprecatedSuffix.filter(Boolean)));
|
||
}
|
||
|
||
async function queryRelevantShopInfoMap(shopNames = []) {
|
||
const shopCodeNameMap = new Map();
|
||
const candidateNames = Array.from(new Set(
|
||
(shopNames || [])
|
||
.flatMap((shopName) => buildShopNameVariants(shopName))
|
||
.map(normalizeText)
|
||
.filter(Boolean)
|
||
));
|
||
|
||
if (candidateNames.length === 0) {
|
||
return shopCodeNameMap;
|
||
}
|
||
|
||
for (const shopNameChunk of chunkArray(candidateNames, 200)) {
|
||
const params = {};
|
||
const placeholders = shopNameChunk.map((shopName, index) => {
|
||
const key = `shopName${index}`;
|
||
params[key] = shopName;
|
||
return `@${key}`;
|
||
});
|
||
|
||
const rows = await cloudDb.query(
|
||
`
|
||
SELECT DISTINCT
|
||
LTRIM(RTRIM(CAST(shop_id AS NVARCHAR(100)))) AS shopCode,
|
||
LTRIM(RTRIM(CAST(shop_name AS NVARCHAR(255)))) AS shopName
|
||
FROM dbo.${SHOP_INFO_TABLE} WITH (NOLOCK)
|
||
WHERE LTRIM(RTRIM(CAST(shop_name AS NVARCHAR(255)))) IN (${placeholders.join(', ')})
|
||
AND LTRIM(RTRIM(CAST(shop_id AS NVARCHAR(100)))) <> N''
|
||
`,
|
||
params,
|
||
{ requestTimeout: 120000, maxAttempts: 2 }
|
||
);
|
||
|
||
rows.forEach((row) => {
|
||
const shopCode = normalizeText(row.shopCode);
|
||
const shopName = normalizeText(row.shopName);
|
||
if (shopCode && shopName && !shopCodeNameMap.has(shopCode)) {
|
||
shopCodeNameMap.set(shopCode, shopName);
|
||
}
|
||
});
|
||
}
|
||
|
||
return shopCodeNameMap;
|
||
}
|
||
|
||
async function queryShopOnlineItemSetMap(shopNames = []) {
|
||
const resultMap = new Map();
|
||
const candidateNames = Array.from(new Set(
|
||
(shopNames || [])
|
||
.flatMap((shopName) => buildShopNameVariants(shopName))
|
||
.map(normalizeText)
|
||
.filter(Boolean)
|
||
));
|
||
|
||
if (candidateNames.length === 0) {
|
||
return resultMap;
|
||
}
|
||
|
||
for (const shopNameChunk of chunkArray(candidateNames, 200)) {
|
||
const params = {};
|
||
const placeholders = shopNameChunk.map((shopName, index) => {
|
||
const key = `targetShopName${index}`;
|
||
params[key] = shopName;
|
||
return `@${key}`;
|
||
});
|
||
|
||
const rows = await cloudDb.query(
|
||
`
|
||
SELECT DISTINCT
|
||
LTRIM(RTRIM(CAST(shopname AS NVARCHAR(255)))) AS shopName,
|
||
LTRIM(RTRIM(CAST(shopproid AS NVARCHAR(100)))) AS itemId
|
||
FROM dbo.${TARGET_MANAGEMENT_TABLE} WITH (NOLOCK)
|
||
WHERE LTRIM(RTRIM(CAST(shopname AS NVARCHAR(255)))) IN (${placeholders.join(', ')})
|
||
AND LTRIM(RTRIM(CAST(shopproid AS NVARCHAR(100)))) NOT IN (N'', N'未上架')
|
||
AND COALESCE(NULLIF(LTRIM(RTRIM(CAST(linkStatus AS NVARCHAR(40)))), N''), N'当前在线') NOT LIKE N'%下架%'
|
||
`,
|
||
params,
|
||
{ requestTimeout: 120000, maxAttempts: 2 }
|
||
);
|
||
|
||
rows.forEach((row) => {
|
||
const shopKey = normalizeComparableShopKey(row.shopName);
|
||
const itemId = normalizeText(row.itemId);
|
||
if (!shopKey || !itemId) {
|
||
return;
|
||
}
|
||
const itemSet = resultMap.get(shopKey) || new Set();
|
||
itemSet.add(itemId);
|
||
resultMap.set(shopKey, itemSet);
|
||
});
|
||
}
|
||
|
||
return resultMap;
|
||
}
|
||
|
||
async function queryFallbackShopCoverageSummaryMap(snapshotMeta, coverageMatcher) {
|
||
const summaryMap = new Map();
|
||
if (!snapshotMeta?.sourceLatestBizDate || !coverageMatcher) {
|
||
return summaryMap;
|
||
}
|
||
|
||
const channelLabelExpression = buildChannelLabelExpression('d');
|
||
const rows = await planningDatabase.query(
|
||
`
|
||
SELECT DISTINCT
|
||
d.channel_label AS channelName,
|
||
COALESCE(NULLIF(TRIM(d.shop_name), ''), '未识别店铺') AS shopName,
|
||
COALESCE(NULLIF(TRIM(d.shop_key), ''), NULLIF(TRIM(d.shop_name), '')) AS shopKey,
|
||
UPPER(TRIM(d.primary_sku_code)) AS skuCode,
|
||
NULLIF(TRIM(d.item_id), '') AS itemId
|
||
FROM (
|
||
SELECT
|
||
d.*,
|
||
${channelLabelExpression} AS channel_label
|
||
FROM ${escapeIdentifier(CHANNEL_ID_READ_TABLE)} d
|
||
WHERE d.stat_date BETWEEN DATE_SUB(?, INTERVAL 29 DAY) AND ?
|
||
AND NULLIF(TRIM(d.primary_sku_code), '') IS NOT NULL
|
||
) d
|
||
`,
|
||
[snapshotMeta.sourceLatestBizDate, snapshotMeta.sourceLatestBizDate]
|
||
);
|
||
|
||
rows.forEach((row) => {
|
||
const channelName = normalizeText(row.channelName);
|
||
const shopName = normalizeText(row.shopName);
|
||
const shopKey = normalizeShopKey(row.shopKey || row.shopName);
|
||
if (!channelName || !shopKey) {
|
||
return;
|
||
}
|
||
|
||
const key = `${channelName}__${shopKey}`;
|
||
const summary = summaryMap.get(key) || createShopCoverageAccumulator(channelName, shopName, shopKey);
|
||
const skuCode = normalizeText(row.skuCode).toUpperCase();
|
||
const itemId = normalizeText(row.itemId);
|
||
|
||
if (skuCode) {
|
||
summary.skuSet.add(skuCode);
|
||
if (coverageMatcher.matchesSkuCode(skuCode)) {
|
||
summary.maySkuSet.add(skuCode);
|
||
if (itemId) {
|
||
summary.mayItemSet.add(itemId);
|
||
}
|
||
}
|
||
}
|
||
if (itemId) {
|
||
summary.itemSet.add(itemId);
|
||
}
|
||
summaryMap.set(key, summary);
|
||
});
|
||
|
||
return summaryMap;
|
||
}
|
||
|
||
async function queryHistoricalShopBaseCountMap(snapshotMeta) {
|
||
const resultMap = new Map();
|
||
if (!snapshotMeta?.snapshotDate || !snapshotMeta?.snapshotBatchId) {
|
||
return resultMap;
|
||
}
|
||
|
||
const rows = await planningDatabase.query(
|
||
`
|
||
SELECT
|
||
channel_name AS channelName,
|
||
shop_name AS shopName,
|
||
shop_key AS shopKey,
|
||
sku_count AS skuCount,
|
||
item_id_count AS itemIdCount,
|
||
generated_at AS generatedAt
|
||
FROM ${escapeIdentifier(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE)}
|
||
WHERE stat_date = ?
|
||
AND snapshot_batch_id = ?
|
||
AND calc_version <> ?
|
||
ORDER BY generated_at DESC, id DESC
|
||
`,
|
||
[snapshotMeta.snapshotDate, snapshotMeta.snapshotBatchId, MAY_CHANNEL_INSIGHT_CALC_VERSION]
|
||
);
|
||
|
||
rows.forEach((row) => {
|
||
const channelName = normalizeText(row.channelName);
|
||
const shopKey = normalizeShopKey(row.shopKey || row.shopName);
|
||
const key = `${channelName}__${shopKey}`;
|
||
if (!channelName || !shopKey || resultMap.has(key)) {
|
||
return;
|
||
}
|
||
resultMap.set(key, {
|
||
skuCount: toNumber(row.skuCount, 0),
|
||
itemIdCount: toNumber(row.itemIdCount, 0),
|
||
generatedAt: row.generatedAt || null,
|
||
});
|
||
});
|
||
|
||
return resultMap;
|
||
}
|
||
|
||
function normalizeShopCoverageFilterOptions(options = {}) {
|
||
const channels = new Set(
|
||
(options.channels || [])
|
||
.map((value) => normalizeText(value))
|
||
.filter(Boolean)
|
||
);
|
||
const shopKeys = new Set(
|
||
(options.shopKeys || [])
|
||
.map((value) => normalizeShopKey(value))
|
||
.filter(Boolean)
|
||
);
|
||
return { channels, shopKeys };
|
||
}
|
||
|
||
function matchesShopCoverageFilters(summary = {}, filters = {}) {
|
||
const channelName = normalizeText(summary.channelName);
|
||
const shopKey = normalizeShopKey(summary.shopKey || summary.shopName);
|
||
if (filters.channels?.size && !filters.channels.has(channelName)) {
|
||
return false;
|
||
}
|
||
if (filters.shopKeys?.size && !filters.shopKeys.has(shopKey)) {
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
function filterShopCoverageSummaryMap(summaryMap = new Map(), filters = {}) {
|
||
if (!(summaryMap instanceof Map)) {
|
||
return new Map();
|
||
}
|
||
if (!filters.channels?.size && !filters.shopKeys?.size) {
|
||
return summaryMap;
|
||
}
|
||
const filteredMap = new Map();
|
||
summaryMap.forEach((summary, key) => {
|
||
if (matchesShopCoverageFilters(summary, filters)) {
|
||
filteredMap.set(key, summary);
|
||
}
|
||
});
|
||
return filteredMap;
|
||
}
|
||
|
||
async function queryShopListingSummaryMap(snapshotMeta, options = {}) {
|
||
const resultMap = new Map();
|
||
if (!snapshotMeta?.snapshotDate || !snapshotMeta?.snapshotBatchId) {
|
||
return resultMap;
|
||
}
|
||
const coverageFilters = normalizeShopCoverageFilterOptions(options);
|
||
|
||
const mayRows = await planningDatabase.query(
|
||
`SELECT DISTINCT
|
||
UPPER(TRIM(s.may_sku_code)) AS maySkuCode,
|
||
UPPER(TRIM(COALESCE(s.product_code, ''))) AS productCode,
|
||
UPPER(TRIM(COALESCE(s.spu_code, ''))) AS spuCode
|
||
FROM ${escapeIdentifier(MAY_PRODUCT_SNAPSHOT_TABLE)} s
|
||
WHERE s.stat_date = ?
|
||
AND s.snapshot_batch_id = ?
|
||
AND NULLIF(TRIM(s.may_sku_code), '') IS NOT NULL
|
||
AND ${buildNotDiscontinuedCondition('s.may_sales_status')}`,
|
||
[snapshotMeta.snapshotDate, snapshotMeta.snapshotBatchId]
|
||
);
|
||
const coverageMatcher = buildMayCoverageMatcher(mayRows);
|
||
const fallbackSummaryMap = filterShopCoverageSummaryMap(
|
||
await queryFallbackShopCoverageSummaryMap(snapshotMeta, coverageMatcher),
|
||
coverageFilters
|
||
);
|
||
const relevantShopCodeNameMap = await queryRelevantShopInfoMap(
|
||
Array.from(fallbackSummaryMap.values()).map((summary) => summary.shopName)
|
||
);
|
||
const shopOnlineItemSetMap = await queryShopOnlineItemSetMap(
|
||
Array.from(fallbackSummaryMap.values()).map((summary) => summary.shopName)
|
||
);
|
||
const relevantShopCodes = Array.from(relevantShopCodeNameMap.keys());
|
||
const fallbackChannelByShopKey = new Map(
|
||
Array.from(fallbackSummaryMap.values()).map((summary) => [
|
||
normalizeShopKey(summary.shopName || summary.shopKey),
|
||
normalizeText(summary.channelName),
|
||
])
|
||
);
|
||
const relevantNumericShopCodes = relevantShopCodes
|
||
.map((shopCode) => {
|
||
const shopName = relevantShopCodeNameMap.get(shopCode) || '';
|
||
const fallbackChannelName = fallbackChannelByShopKey.get(normalizeShopKey(shopName)) || '';
|
||
return {
|
||
shopCode,
|
||
numericShopCode: Number.parseInt(shopCode, 10),
|
||
channelName: fallbackChannelName || resolveChannelLabelFromText('', shopName),
|
||
shopName,
|
||
};
|
||
})
|
||
.filter((item) => Number.isFinite(item.numericShopCode));
|
||
const tmallNumericShopCodes = relevantNumericShopCodes
|
||
.filter((item) => resolveListingSourceBucket(item.channelName, item.shopName) === 'qmcust_listing')
|
||
.map((item) => item.numericShopCode);
|
||
const pddNumericShopCodes = relevantNumericShopCodes
|
||
.filter((item) => resolveListingSourceBucket(item.channelName, item.shopName) === 'pdd_listing')
|
||
.map((item) => item.numericShopCode);
|
||
const genericNumericShopCodes = relevantNumericShopCodes
|
||
.filter((item) => resolveListingSourceBucket(item.channelName, item.shopName) === 'generic_listing')
|
||
.map((item) => item.numericShopCode);
|
||
if (relevantShopCodes.length === 0) {
|
||
const historicalBaseMap = await queryHistoricalShopBaseCountMap(snapshotMeta);
|
||
fallbackSummaryMap.forEach((summary, key) => {
|
||
const materialized = materializeShopCoverageSummary(summary);
|
||
const historical = historicalBaseMap.get(key);
|
||
if (historical) {
|
||
materialized.skuCount = historical.skuCount;
|
||
materialized.itemIdCount = historical.itemIdCount;
|
||
}
|
||
resultMap.set(key, materialized);
|
||
});
|
||
return resultMap;
|
||
}
|
||
|
||
let accumulatedListingRowCount = 0;
|
||
try {
|
||
const matchedShopKeys = new Set(
|
||
Array.from(relevantShopCodeNameMap.values())
|
||
.map((shopName) => normalizeShopKey(shopName))
|
||
.filter(Boolean)
|
||
);
|
||
fallbackSummaryMap.forEach((summary, key) => {
|
||
if (!matchedShopKeys.has(normalizeShopKey(summary.shopName || summary.shopKey))) {
|
||
return;
|
||
}
|
||
if (!resultMap.has(key)) {
|
||
resultMap.set(
|
||
key,
|
||
createShopCoverageAccumulator(summary.channelName, summary.shopName, summary.shopKey)
|
||
);
|
||
}
|
||
});
|
||
|
||
const accumulateChunkRows = (chunkRows = []) => {
|
||
chunkRows.forEach((row) => {
|
||
const shopCode = normalizeText(row.shopCode);
|
||
const rawShopName = relevantShopCodeNameMap.get(shopCode) || '';
|
||
const channelName = resolveChannelLabelFromText(row.channelName, rawShopName);
|
||
const normalizedShopName = normalizeShopDisplayName(rawShopName);
|
||
const shopKey = normalizeShopKey(rawShopName || shopCode);
|
||
if (!channelName || !shopKey) {
|
||
return;
|
||
}
|
||
|
||
const shopItemId = normalizeText(row.shopItemId);
|
||
const onlineItemSet = shopOnlineItemSetMap.get(normalizeComparableShopKey(rawShopName));
|
||
if (onlineItemSet?.size && (!shopItemId || !onlineItemSet.has(shopItemId))) {
|
||
return;
|
||
}
|
||
|
||
const key = `${channelName}__${shopKey}`;
|
||
const summary = resultMap.get(key) || createShopCoverageAccumulator(channelName, normalizedShopName, shopKey);
|
||
const skuIdentity = getPreferredListingSkuIdentity(row);
|
||
const matchesMayCoverage = coverageMatcher.matchesAnySkuCode(getListingSkuCandidates(row));
|
||
|
||
if (skuIdentity) {
|
||
summary.skuSet.add(skuIdentity);
|
||
if (matchesMayCoverage) {
|
||
summary.maySkuSet.add(skuIdentity);
|
||
}
|
||
}
|
||
if (shopItemId) {
|
||
summary.itemSet.add(shopItemId);
|
||
if (matchesMayCoverage) {
|
||
summary.mayItemSet.add(shopItemId);
|
||
}
|
||
}
|
||
resultMap.set(key, summary);
|
||
});
|
||
};
|
||
|
||
if (tmallNumericShopCodes.length > 0) {
|
||
for (const shopCodeChunk of chunkArray(tmallNumericShopCodes, TMALL_LISTING_SHOP_CHUNK_SIZE)) {
|
||
const params = {};
|
||
const placeholders = shopCodeChunk.map((shopCode, index) => {
|
||
const key = `tmallShopCode${index}`;
|
||
params[key] = shopCode;
|
||
return `@${key}`;
|
||
});
|
||
|
||
console.log(`[PlanningMayChannelInsight] listingChunk start source=qmcust_listing shops=${shopCodeChunk.length} accumulatedRows=${accumulatedListingRowCount}`);
|
||
const tmallRows = await cloudDb.query(
|
||
`
|
||
SELECT
|
||
CAST(m.shop_id AS NVARCHAR(100)) AS shopCode,
|
||
CAST(m.channel AS NVARCHAR(100)) AS channelName,
|
||
CAST(m.shop_i_id AS NVARCHAR(255)) AS shopItemId,
|
||
CAST(m.shop_sku_id AS NVARCHAR(255)) AS shopSkuId,
|
||
UPPER(CAST(m.sku_id AS NVARCHAR(255))) AS skuCode,
|
||
UPPER(CAST(m.raw_sku_id AS NVARCHAR(255))) AS rawSkuCode,
|
||
UPPER(CAST(m.outer_sku_code AS NVARCHAR(255))) AS outerSkuCode,
|
||
UPPER(CAST(m.link_sku_id AS NVARCHAR(255))) AS linkSkuCode
|
||
FROM dbo.${TMALL_LISTING_MAP_TABLE} m WITH (NOLOCK)
|
||
WHERE m.shop_id IN (${placeholders.join(', ')})
|
||
AND m.channel IN (N'Taobao', N'Tmall', N'淘宝', N'天猫', N'Alibaba', N'1688', N'C2M', N'淘工厂', N'Tfx', N'淘分销')
|
||
AND ISNULL(m.enabled, 0) = 1
|
||
`,
|
||
params,
|
||
{ requestTimeout: 600000, maxAttempts: 2 }
|
||
);
|
||
accumulateChunkRows(tmallRows);
|
||
accumulatedListingRowCount += tmallRows.length;
|
||
console.log(`[PlanningMayChannelInsight] listingChunk done source=qmcust_listing shops=${shopCodeChunk.length} chunkRows=${tmallRows.length} accumulatedRows=${accumulatedListingRowCount}`);
|
||
}
|
||
}
|
||
|
||
const indexedSourceQueries = [
|
||
{
|
||
name: 'pdd_listing',
|
||
shopCodes: pddNumericShopCodes,
|
||
chunkSize: PDD_LISTING_SHOP_CHUNK_SIZE,
|
||
sql: (placeholderSql) => `
|
||
SELECT
|
||
CAST(m.shop_id AS NVARCHAR(100)) AS shopCode,
|
||
CAST(COALESCE(m.channel, N'拼多多') AS NVARCHAR(100)) AS channelName,
|
||
CAST(m.shop_i_id AS NVARCHAR(255)) AS shopItemId,
|
||
CAST(m.shop_sku_id AS NVARCHAR(255)) AS shopSkuId,
|
||
UPPER(CAST(m.sku_id AS NVARCHAR(255))) AS skuCode,
|
||
UPPER(CAST(m.raw_sku_id AS NVARCHAR(255))) AS rawSkuCode,
|
||
UPPER(CAST(m.outer_sku_code AS NVARCHAR(255))) AS outerSkuCode,
|
||
UPPER(CAST(m.link_sku_id AS NVARCHAR(255))) AS linkSkuCode
|
||
FROM dbo.${PDD_LISTING_MAP_TABLE} m WITH (NOLOCK)
|
||
WHERE m.shop_id IN (${placeholderSql})
|
||
AND (
|
||
ISNULL(m.enabled, 0) = 1
|
||
OR (m.enabled IS NULL AND m.pull_off_time IS NULL AND COALESCE(m.shop_created, m.created) IS NOT NULL)
|
||
)
|
||
`,
|
||
},
|
||
{
|
||
name: 'generic_listing',
|
||
shopCodes: genericNumericShopCodes,
|
||
chunkSize: GENERIC_LISTING_SHOP_CHUNK_SIZE,
|
||
sql: (placeholderSql) => `
|
||
SELECT
|
||
CAST(m.shop_id AS NVARCHAR(100)) AS shopCode,
|
||
CAST(m.channel AS NVARCHAR(100)) AS channelName,
|
||
CAST(m.shop_i_id AS NVARCHAR(255)) AS shopItemId,
|
||
CAST(m.shop_sku_id AS NVARCHAR(255)) AS shopSkuId,
|
||
UPPER(CAST(m.sku_id AS NVARCHAR(255))) AS skuCode,
|
||
UPPER(CAST(m.raw_sku_id AS NVARCHAR(255))) AS rawSkuCode,
|
||
UPPER(CAST(m.outer_sku_code AS NVARCHAR(255))) AS outerSkuCode,
|
||
UPPER(CAST(m.link_sku_id AS NVARCHAR(255))) AS linkSkuCode
|
||
FROM dbo.${GENERIC_LISTING_MAP_TABLE} m WITH (NOLOCK)
|
||
WHERE m.shop_id IN (${placeholderSql})
|
||
AND (
|
||
ISNULL(m.enabled, 0) = 1
|
||
OR (m.enabled IS NULL AND m.pull_off_time IS NULL AND COALESCE(m.shop_created, m.created) IS NOT NULL)
|
||
)
|
||
AND ISNULL(m.channel, N'') NOT IN (N'Taobao', N'Tmall', N'淘宝', N'天猫', N'Pinduoduo', N'拼多多')
|
||
`,
|
||
},
|
||
];
|
||
|
||
for (const sourceQuery of indexedSourceQueries) {
|
||
for (const shopCodeChunk of chunkArray(sourceQuery.shopCodes, sourceQuery.chunkSize)) {
|
||
const params = {};
|
||
const placeholders = shopCodeChunk.map((shopCode, index) => {
|
||
const key = `shopCode${index}`;
|
||
params[key] = shopCode;
|
||
return `@${key}`;
|
||
});
|
||
|
||
console.log(`[PlanningMayChannelInsight] listingChunk start source=${sourceQuery.name} shops=${shopCodeChunk.length} accumulatedRows=${accumulatedListingRowCount}`);
|
||
const chunkRows = await cloudDb.query(
|
||
sourceQuery.sql(placeholders.join(', ')),
|
||
params,
|
||
{ requestTimeout: 600000, maxAttempts: 2 }
|
||
);
|
||
|
||
accumulateChunkRows(chunkRows);
|
||
accumulatedListingRowCount += chunkRows.length;
|
||
console.log(`[PlanningMayChannelInsight] listingChunk done source=${sourceQuery.name} shops=${shopCodeChunk.length} chunkRows=${chunkRows.length} accumulatedRows=${accumulatedListingRowCount}`);
|
||
}
|
||
}
|
||
} catch (error) {
|
||
console.warn('[PlanningMayChannelInsight] 读取当前铺货映射失败，回退近30天渠道活跃SKU覆盖:', error.message || error);
|
||
const historicalBaseMap = await queryHistoricalShopBaseCountMap(snapshotMeta);
|
||
fallbackSummaryMap.forEach((summary, key) => {
|
||
const materialized = materializeShopCoverageSummary(summary);
|
||
const historical = historicalBaseMap.get(key);
|
||
if (historical) {
|
||
materialized.skuCount = historical.skuCount;
|
||
materialized.itemIdCount = historical.itemIdCount;
|
||
}
|
||
resultMap.set(key, materialized);
|
||
});
|
||
return resultMap;
|
||
}
|
||
|
||
const materializedResultMap = new Map();
|
||
resultMap.forEach((summary, key) => {
|
||
materializedResultMap.set(key, materializeShopCoverageSummary(summary));
|
||
});
|
||
|
||
fallbackSummaryMap.forEach((summary, key) => {
|
||
if (!materializedResultMap.has(key)) {
|
||
materializedResultMap.set(key, materializeShopCoverageSummary(summary));
|
||
}
|
||
});
|
||
|
||
return materializedResultMap;
|
||
}
|
||
|
||
function createShopMetricAccumulator() {
|
||
return {
|
||
skuSet: new Set(),
|
||
activeSkuSet: new Set(),
|
||
itemSet: new Set(),
|
||
activeItemSet: new Set(),
|
||
salesAmount30d: 0,
|
||
transactionAmount30d: 0,
|
||
salesQty30d: 0,
|
||
afterSaleAmount30d: 0,
|
||
refundCount30d: 0,
|
||
orderCount30d: 0,
|
||
promotionFee30d: 0,
|
||
grossCostAmount30d: 0,
|
||
};
|
||
}
|
||
|
||
async function queryShopCurrentMetricMaps(snapshotMeta, listingSummaryMap = new Map()) {
|
||
const shopMetricMap = new Map();
|
||
const mayMetricMap = new Map();
|
||
if (!snapshotMeta?.sourceLatestBizDate || !(listingSummaryMap instanceof Map) || listingSummaryMap.size === 0) {
|
||
return {
|
||
shopMetricMap,
|
||
mayMetricMap,
|
||
};
|
||
}
|
||
|
||
const channelLabelExpression = buildChannelLabelExpression('d');
|
||
const rows = await planningDatabase.query(
|
||
`
|
||
SELECT
|
||
d.channel_label AS channelName,
|
||
COALESCE(NULLIF(TRIM(d.shop_name), ''), '未识别店铺') AS shopName,
|
||
COALESCE(NULLIF(TRIM(d.shop_key), ''), NULLIF(TRIM(d.shop_name), '')) AS shopKey,
|
||
NULLIF(TRIM(d.item_id), '') AS itemId,
|
||
UPPER(TRIM(d.primary_sku_code)) AS skuCode,
|
||
SUM(COALESCE(d.transaction_amount, 0)) AS salesAmount30d,
|
||
SUM(COALESCE(d.transaction_amount, 0)) AS transactionAmount30d,
|
||
SUM(COALESCE(d.goods_count, 0)) AS salesQty30d,
|
||
SUM(COALESCE(d.after_sale_amount, 0)) AS afterSaleAmount30d,
|
||
SUM(COALESCE(d.refund_count, 0)) AS refundCount30d,
|
||
SUM(COALESCE(d.order_count, 0)) AS orderCount30d,
|
||
SUM(COALESCE(d.gross_cost_amount, 0)) AS grossCostAmount30d,
|
||
SUM(
|
||
CASE
|
||
WHEN COALESCE(d.push_fee_amount, 0) + COALESCE(d.marketing_fee_amount, 0) > 0
|
||
THEN COALESCE(d.push_fee_amount, 0) + COALESCE(d.marketing_fee_amount, 0)
|
||
ELSE COALESCE(d.fee_amount, 0)
|
||
END
|
||
) AS promotionFee30d
|
||
FROM (
|
||
SELECT
|
||
d.*,
|
||
${channelLabelExpression} AS channel_label
|
||
FROM ${escapeIdentifier(CHANNEL_ID_READ_TABLE)} d
|
||
WHERE d.stat_date BETWEEN DATE_SUB(?, INTERVAL 29 DAY) AND ?
|
||
) d
|
||
WHERE NULLIF(TRIM(d.item_id), '') IS NOT NULL
|
||
GROUP BY
|
||
d.channel_label,
|
||
COALESCE(NULLIF(TRIM(d.shop_name), ''), '未识别店铺'),
|
||
COALESCE(NULLIF(TRIM(d.shop_key), ''), NULLIF(TRIM(d.shop_name), '')),
|
||
NULLIF(TRIM(d.item_id), ''),
|
||
UPPER(TRIM(d.primary_sku_code))
|
||
`,
|
||
[snapshotMeta.sourceLatestBizDate, snapshotMeta.sourceLatestBizDate]
|
||
);
|
||
|
||
rows.forEach((row) => {
|
||
const key = `${normalizeText(row.channelName)}__${normalizeShopKey(row.shopKey || row.shopName)}`;
|
||
const listingSummary = listingSummaryMap.get(key);
|
||
if (!listingSummary) {
|
||
return;
|
||
}
|
||
const itemId = normalizeText(row.itemId);
|
||
const skuCode = normalizeText(row.skuCode).toUpperCase();
|
||
const hasActivity = toNumber(row.salesAmount30d, 0) > 0 || toNumber(row.salesQty30d, 0) > 0;
|
||
const metric = shopMetricMap.get(key) || createShopMetricAccumulator();
|
||
metric.salesAmount30d += toNumber(row.salesAmount30d, 0);
|
||
metric.transactionAmount30d += toNumber(row.transactionAmount30d, 0);
|
||
metric.salesQty30d += toNumber(row.salesQty30d, 0);
|
||
metric.afterSaleAmount30d += toNumber(row.afterSaleAmount30d, 0);
|
||
metric.refundCount30d += toNumber(row.refundCount30d, 0);
|
||
metric.orderCount30d += toNumber(row.orderCount30d, 0);
|
||
metric.promotionFee30d += toNumber(row.promotionFee30d, 0);
|
||
metric.grossCostAmount30d += toNumber(row.grossCostAmount30d, 0);
|
||
if (itemId) {
|
||
metric.itemSet.add(itemId);
|
||
if (hasActivity) {
|
||
metric.activeItemSet.add(itemId);
|
||
}
|
||
}
|
||
if (skuCode) {
|
||
metric.skuSet.add(skuCode);
|
||
if (hasActivity) {
|
||
metric.activeSkuSet.add(skuCode);
|
||
}
|
||
}
|
||
shopMetricMap.set(key, metric);
|
||
|
||
if (!listingSummary.mayItemSet?.has(itemId)) {
|
||
return;
|
||
}
|
||
const mayMetric = mayMetricMap.get(key) || createShopMetricAccumulator();
|
||
mayMetric.salesAmount30d += toNumber(row.salesAmount30d, 0);
|
||
mayMetric.transactionAmount30d += toNumber(row.transactionAmount30d, 0);
|
||
mayMetric.salesQty30d += toNumber(row.salesQty30d, 0);
|
||
mayMetric.afterSaleAmount30d += toNumber(row.afterSaleAmount30d, 0);
|
||
mayMetric.refundCount30d += toNumber(row.refundCount30d, 0);
|
||
mayMetric.orderCount30d += toNumber(row.orderCount30d, 0);
|
||
mayMetric.promotionFee30d += toNumber(row.promotionFee30d, 0);
|
||
mayMetric.grossCostAmount30d += toNumber(row.grossCostAmount30d, 0);
|
||
if (itemId) {
|
||
mayMetric.itemSet.add(itemId);
|
||
if (hasActivity) {
|
||
mayMetric.activeItemSet.add(itemId);
|
||
}
|
||
}
|
||
if (skuCode) {
|
||
mayMetric.skuSet.add(skuCode);
|
||
if (hasActivity) {
|
||
mayMetric.activeSkuSet.add(skuCode);
|
||
}
|
||
}
|
||
mayMetricMap.set(key, mayMetric);
|
||
});
|
||
|
||
return {
|
||
shopMetricMap,
|
||
mayMetricMap,
|
||
};
|
||
}
|
||
|
||
async function applyShopListingSummary(snapshotMeta, listingSummaryMap = new Map(), shopCurrentMetricMap = new Map(), shopCurrentMayMetricMap = new Map()) {
|
||
if (!snapshotMeta?.snapshotDate || !snapshotMeta?.snapshotBatchId || !(listingSummaryMap instanceof Map) || listingSummaryMap.size === 0) {
|
||
return 0;
|
||
}
|
||
|
||
const snapshotRows = await planningDatabase.query(
|
||
`SELECT
|
||
id,
|
||
channel_name AS channelName,
|
||
shop_name AS shopName,
|
||
shop_key AS shopKey
|
||
FROM ${escapeIdentifier(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE)}
|
||
WHERE stat_date = ?
|
||
AND snapshot_batch_id = ?
|
||
AND calc_version = ?`,
|
||
[snapshotMeta.snapshotDate, snapshotMeta.snapshotBatchId, MAY_CHANNEL_INSIGHT_CALC_VERSION]
|
||
);
|
||
|
||
const updates = [];
|
||
snapshotRows.forEach((row) => {
|
||
const channelName = normalizeText(row.channelName);
|
||
const normalizedKey = normalizeShopKey(row.shopKey || row.shopName);
|
||
const shopMetricKey = `${channelName}__${normalizedKey}`;
|
||
const summary = listingSummaryMap.get(shopMetricKey);
|
||
if (!summary) {
|
||
return;
|
||
}
|
||
|
||
const currentMetric = shopCurrentMetricMap.get(shopMetricKey) || createShopMetricAccumulator();
|
||
const currentMayMetric = shopCurrentMayMetricMap.get(shopMetricKey) || createShopMetricAccumulator();
|
||
updates.push([
|
||
toNumber(summary.skuCount, 0),
|
||
toNumber(summary.itemIdCount, 0),
|
||
currentMetric.activeSkuSet.size,
|
||
currentMetric.activeItemSet.size,
|
||
toNumber(currentMetric.salesAmount30d, 0),
|
||
toNumber(currentMetric.transactionAmount30d, 0),
|
||
toNumber(currentMetric.afterSaleAmount30d, 0),
|
||
toNumber(currentMetric.salesQty30d, 0),
|
||
toNumber(currentMetric.refundCount30d, 0),
|
||
toNumber(currentMetric.orderCount30d, 0),
|
||
toNumber(currentMetric.promotionFee30d, 0),
|
||
toNumber(currentMetric.grossCostAmount30d, 0),
|
||
toNumber(summary.maySkuCount, 0),
|
||
toNumber(summary.mayItemIdCount, 0),
|
||
currentMayMetric.activeSkuSet.size,
|
||
currentMayMetric.activeItemSet.size,
|
||
toNumber(currentMayMetric.salesAmount30d, 0),
|
||
toNumber(currentMayMetric.salesQty30d, 0),
|
||
toNumber(currentMayMetric.promotionFee30d, 0),
|
||
toNumber(currentMayMetric.afterSaleAmount30d, 0),
|
||
row.id,
|
||
]);
|
||
});
|
||
|
||
if (updates.length === 0) {
|
||
return 0;
|
||
}
|
||
|
||
await planningDatabase.withTransaction(async (connection) => {
|
||
for (const [
|
||
skuCount,
|
||
itemIdCount,
|
||
activeSkuCount,
|
||
activeItemIdCount,
|
||
salesAmount30d,
|
||
transactionAmount30d,
|
||
afterSaleAmount30d,
|
||
salesQty30d,
|
||
refundCount30d,
|
||
orderCount30d,
|
||
promotionFee30d,
|
||
grossCostAmount30d,
|
||
maySkuCount,
|
||
mayItemIdCount,
|
||
mayActiveSkuCount,
|
||
mayActiveItemIdCount,
|
||
maySalesAmount30d,
|
||
maySalesQty30d,
|
||
mayPromotionFee30d,
|
||
mayAfterSaleAmount30d,
|
||
id,
|
||
] of updates) {
|
||
await connection.query(
|
||
`UPDATE ${escapeIdentifier(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE)}
|
||
SET sku_count = ?,
|
||
item_id_count = ?,
|
||
active_sku_count = ?,
|
||
active_item_id_count = ?,
|
||
sales_amount_30d = ?,
|
||
transaction_amount_30d = ?,
|
||
after_sale_amount_30d = ?,
|
||
sales_qty_30d = ?,
|
||
refund_count_30d = ?,
|
||
order_count_30d = ?,
|
||
promotion_fee_30d = ?,
|
||
gross_cost_amount_30d = ?,
|
||
may_sku_count = ?,
|
||
may_item_id_count = ?,
|
||
may_active_sku_count = ?,
|
||
may_active_item_id_count = ?,
|
||
may_sales_amount_30d = ?,
|
||
may_sales_qty_30d = ?,
|
||
may_promotion_fee_30d = ?,
|
||
may_after_sale_amount_30d = ?
|
||
WHERE id = ?`,
|
||
[
|
||
skuCount,
|
||
itemIdCount,
|
||
activeSkuCount,
|
||
activeItemIdCount,
|
||
salesAmount30d,
|
||
transactionAmount30d,
|
||
afterSaleAmount30d,
|
||
salesQty30d,
|
||
refundCount30d,
|
||
orderCount30d,
|
||
promotionFee30d,
|
||
grossCostAmount30d,
|
||
maySkuCount,
|
||
mayItemIdCount,
|
||
mayActiveSkuCount,
|
||
mayActiveItemIdCount,
|
||
maySalesAmount30d,
|
||
maySalesQty30d,
|
||
mayPromotionFee30d,
|
||
mayAfterSaleAmount30d,
|
||
id,
|
||
]
|
||
);
|
||
}
|
||
});
|
||
|
||
return updates.length;
|
||
}
|
||
|
||
async function repairPlanningMayChannelInsightShopCoverage(options = {}) {
|
||
await ensurePlanningMayChannelInsightSchema();
|
||
const requestedSnapshotMeta = await resolveMaySnapshotMeta();
|
||
const snapshotMeta = requestedSnapshotMeta
|
||
? (await getExistingInsightMeta(requestedSnapshotMeta)) || (await getLatestAvailableInsightMeta()) || requestedSnapshotMeta
|
||
: await getLatestAvailableInsightMeta();
|
||
if (!snapshotMeta) {
|
||
return {
|
||
success: false,
|
||
message: 'MAY商品快照尚未生成，无法修复店铺覆盖数据。',
|
||
updatedRows: 0,
|
||
};
|
||
}
|
||
|
||
const shopListingSummaryMap = await queryShopListingSummaryMap(snapshotMeta, options);
|
||
const { shopMetricMap, mayMetricMap } = await queryShopCurrentMetricMaps(snapshotMeta, shopListingSummaryMap);
|
||
const updatedRows = await applyShopListingSummary(snapshotMeta, shopListingSummaryMap, shopMetricMap, mayMetricMap);
|
||
return {
|
||
success: true,
|
||
statDate: snapshotMeta.snapshotDate,
|
||
snapshotBatchId: snapshotMeta.snapshotBatchId,
|
||
sourceLatestBizDate: snapshotMeta.sourceLatestBizDate,
|
||
requestedSnapshotDate: requestedSnapshotMeta?.snapshotDate || '',
|
||
requestedSnapshotBatchId: requestedSnapshotMeta?.snapshotBatchId || '',
|
||
calcVersion: MAY_CHANNEL_INSIGHT_CALC_VERSION,
|
||
updatedRows,
|
||
filteredChannels: (options.channels || []).map((value) => normalizeText(value)).filter(Boolean),
|
||
filteredShopKeys: (options.shopKeys || []).map((value) => normalizeShopKey(value)).filter(Boolean),
|
||
};
|
||
}
|
||
|
||
async function ensureColumnCollation(tableName, columnName, columnDefinition, expectedCollation) {
|
||
const [column] = await planningDatabase.query(
|
||
`SELECT COLLATION_NAME AS collationName
|
||
FROM information_schema.COLUMNS
|
||
WHERE TABLE_SCHEMA = DATABASE()
|
||
AND TABLE_NAME = ?
|
||
AND COLUMN_NAME = ?
|
||
LIMIT 1`,
|
||
[tableName, columnName]
|
||
);
|
||
|
||
if (column?.collationName && column.collationName !== expectedCollation) {
|
||
await planningDatabase.execute(
|
||
`ALTER TABLE ${escapeIdentifier(tableName)}
|
||
MODIFY ${escapeIdentifier(columnName)} ${columnDefinition}`
|
||
);
|
||
}
|
||
}
|
||
|
||
async function ensurePlanningTableColumn(tableName, columnName, columnDefinition) {
|
||
const rows = await planningDatabase.query(
|
||
`SHOW COLUMNS FROM ${escapeIdentifier(tableName)} LIKE ?`,
|
||
[columnName]
|
||
);
|
||
if (Array.isArray(rows) && rows.length > 0) {
|
||
return;
|
||
}
|
||
await planningDatabase.execute(
|
||
`ALTER TABLE ${escapeIdentifier(tableName)} ADD COLUMN ${escapeIdentifier(columnName)} ${columnDefinition}`
|
||
);
|
||
}
|
||
|
||
async function ensurePlanningMayChannelInsightSchema() {
|
||
await planningDatabase.execute(`
|
||
CREATE TABLE IF NOT EXISTS ${escapeIdentifier(MAY_CHANNEL_ACTIVE_SKU_TABLE)} (
|
||
stat_date DATE NOT NULL,
|
||
snapshot_batch_id VARCHAR(80) NOT NULL,
|
||
calc_version VARCHAR(80) NOT NULL,
|
||
sku_key VARCHAR(160) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL,
|
||
may_sku_code VARCHAR(120) NOT NULL,
|
||
category_name VARCHAR(255) NULL,
|
||
may_sku_image_url TEXT NULL,
|
||
may_sales_status VARCHAR(80) NULL,
|
||
review_action VARCHAR(80) NULL,
|
||
may_inventory_quantity DECIMAL(18, 4) NOT NULL DEFAULT 0,
|
||
may_goods_id_count INT NOT NULL DEFAULT 0,
|
||
may_performance_amount DECIMAL(18, 2) NOT NULL DEFAULT 0,
|
||
may_promotion_fee_30d DECIMAL(18, 2) NOT NULL DEFAULT 0,
|
||
generated_at DATETIME NOT NULL,
|
||
CONSTRAINT pk_may_channel_active_sku PRIMARY KEY (stat_date, snapshot_batch_id, calc_version, sku_key),
|
||
INDEX idx_may_channel_active_sku_code (sku_key),
|
||
INDEX idx_may_channel_active_sku_status (stat_date, snapshot_batch_id, calc_version, may_sales_status)
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
||
`);
|
||
await ensureColumnCollation(
|
||
MAY_CHANNEL_ACTIVE_SKU_TABLE,
|
||
'sku_key',
|
||
'VARCHAR(160) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL',
|
||
'utf8mb4_general_ci'
|
||
);
|
||
|
||
await planningDatabase.execute(`
|
||
CREATE TABLE IF NOT EXISTS ${escapeIdentifier(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE)} (
|
||
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
|
||
stat_date DATE NOT NULL,
|
||
snapshot_batch_id VARCHAR(80) NOT NULL,
|
||
source_latest_biz_date DATE NULL,
|
||
channel_name VARCHAR(120) NOT NULL,
|
||
shop_name VARCHAR(255) NOT NULL,
|
||
shop_key VARCHAR(255) NULL,
|
||
sku_count INT NOT NULL DEFAULT 0,
|
||
item_id_count INT NOT NULL DEFAULT 0,
|
||
active_sku_count INT NOT NULL DEFAULT 0,
|
||
active_item_id_count INT NOT NULL DEFAULT 0,
|
||
sales_amount_30d DECIMAL(18, 2) NOT NULL DEFAULT 0,
|
||
transaction_amount_30d DECIMAL(18, 2) NOT NULL DEFAULT 0,
|
||
after_sale_amount_30d DECIMAL(18, 2) NOT NULL DEFAULT 0,
|
||
sales_qty_30d DECIMAL(18, 4) NOT NULL DEFAULT 0,
|
||
refund_count_30d DECIMAL(18, 4) NOT NULL DEFAULT 0,
|
||
order_count_30d DECIMAL(18, 4) NOT NULL DEFAULT 0,
|
||
promotion_fee_30d DECIMAL(18, 2) NOT NULL DEFAULT 0,
|
||
gross_cost_amount_30d DECIMAL(18, 2) NOT NULL DEFAULT 0,
|
||
may_sku_count INT NOT NULL DEFAULT 0,
|
||
may_item_id_count INT NOT NULL DEFAULT 0,
|
||
may_active_sku_count INT NOT NULL DEFAULT 0,
|
||
may_active_item_id_count INT NOT NULL DEFAULT 0,
|
||
may_sales_amount_30d DECIMAL(18, 2) NOT NULL DEFAULT 0,
|
||
may_sales_qty_30d DECIMAL(18, 4) NOT NULL DEFAULT 0,
|
||
may_promotion_fee_30d DECIMAL(18, 2) NOT NULL DEFAULT 0,
|
||
may_after_sale_amount_30d DECIMAL(18, 2) NOT NULL DEFAULT 0,
|
||
generated_at DATETIME NOT NULL,
|
||
calc_version VARCHAR(80) NOT NULL,
|
||
UNIQUE KEY uk_may_channel_shop_snapshot (stat_date, snapshot_batch_id, calc_version, channel_name, shop_name),
|
||
INDEX idx_may_channel_shop_sales (stat_date, snapshot_batch_id, sales_amount_30d),
|
||
INDEX idx_may_channel_shop_channel (stat_date, snapshot_batch_id, channel_name)
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
||
`);
|
||
await Promise.all([
|
||
ensurePlanningTableColumn(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE, 'may_sku_count', 'INT NOT NULL DEFAULT 0 COMMENT \'MAY覆盖SKU数\''),
|
||
ensurePlanningTableColumn(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE, 'may_item_id_count', 'INT NOT NULL DEFAULT 0 COMMENT \'MAY覆盖ID数\''),
|
||
ensurePlanningTableColumn(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE, 'may_active_sku_count', 'INT NOT NULL DEFAULT 0 COMMENT \'MAY动销SKU数\''),
|
||
ensurePlanningTableColumn(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE, 'may_active_item_id_count', 'INT NOT NULL DEFAULT 0 COMMENT \'MAY动销ID数\''),
|
||
ensurePlanningTableColumn(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE, 'may_sales_amount_30d', 'DECIMAL(18, 2) NOT NULL DEFAULT 0 COMMENT \'MAY覆盖30天销售额\''),
|
||
ensurePlanningTableColumn(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE, 'may_sales_qty_30d', 'DECIMAL(18, 4) NOT NULL DEFAULT 0 COMMENT \'MAY覆盖30天销量\''),
|
||
ensurePlanningTableColumn(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE, 'may_promotion_fee_30d', 'DECIMAL(18, 2) NOT NULL DEFAULT 0 COMMENT \'MAY覆盖30天推广费\''),
|
||
ensurePlanningTableColumn(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE, 'may_after_sale_amount_30d', 'DECIMAL(18, 2) NOT NULL DEFAULT 0 COMMENT \'MAY覆盖30天售后金额\''),
|
||
]);
|
||
|
||
await planningDatabase.execute(`
|
||
CREATE TABLE IF NOT EXISTS ${escapeIdentifier(MAY_CHANNEL_LAYOUT_SNAPSHOT_TABLE)} (
|
||
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
|
||
stat_date DATE NOT NULL,
|
||
snapshot_batch_id VARCHAR(80) NOT NULL,
|
||
source_latest_biz_date DATE NULL,
|
||
may_sku_code VARCHAR(120) NOT NULL,
|
||
category_name VARCHAR(255) NULL,
|
||
may_sku_image_url TEXT NULL,
|
||
may_sales_status VARCHAR(80) NULL,
|
||
review_action VARCHAR(80) NULL,
|
||
may_inventory_quantity DECIMAL(18, 4) NOT NULL DEFAULT 0,
|
||
may_goods_id_count INT NOT NULL DEFAULT 0,
|
||
may_performance_amount DECIMAL(18, 2) NOT NULL DEFAULT 0,
|
||
may_promotion_fee_30d DECIMAL(18, 2) NOT NULL DEFAULT 0,
|
||
promotion_roi DECIMAL(18, 4) NULL,
|
||
covered_channel_count INT NOT NULL DEFAULT 0,
|
||
covered_shop_count INT NOT NULL DEFAULT 0,
|
||
covered_item_id_count INT NOT NULL DEFAULT 0,
|
||
covered_channel_names TEXT NULL,
|
||
covered_shop_names MEDIUMTEXT NULL,
|
||
missing_channel_names TEXT NULL,
|
||
missing_channel_count INT NOT NULL DEFAULT 0,
|
||
layout_label VARCHAR(80) NOT NULL DEFAULT '布局健康',
|
||
layout_reason TEXT NULL,
|
||
risk_score DECIMAL(10, 2) NOT NULL DEFAULT 0,
|
||
sales_amount_30d DECIMAL(18, 2) NOT NULL DEFAULT 0,
|
||
sales_qty_30d DECIMAL(18, 4) NOT NULL DEFAULT 0,
|
||
promotion_fee_30d DECIMAL(18, 2) NOT NULL DEFAULT 0,
|
||
after_sale_amount_30d DECIMAL(18, 2) NOT NULL DEFAULT 0,
|
||
generated_at DATETIME NOT NULL,
|
||
calc_version VARCHAR(80) NOT NULL,
|
||
UNIQUE KEY uk_may_channel_layout_snapshot (stat_date, snapshot_batch_id, calc_version, may_sku_code),
|
||
INDEX idx_may_channel_layout_label (stat_date, snapshot_batch_id, layout_label),
|
||
INDEX idx_may_channel_layout_risk (stat_date, snapshot_batch_id, risk_score),
|
||
INDEX idx_may_channel_layout_sku (may_sku_code)
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
||
`);
|
||
}
|
||
|
||
async function resolveMaySnapshotMeta() {
|
||
const summary = await getPlanningMayProductDataSummary();
|
||
if (!summary?.snapshotBatchId || !summary?.snapshotDate) {
|
||
return null;
|
||
}
|
||
return {
|
||
snapshotDate: formatDateOnly(summary.snapshotDate),
|
||
snapshotBatchId: summary.snapshotBatchId,
|
||
sourceLatestBizDate: formatDateOnly(summary.sourceLatestBizDate || summary.snapshotDate),
|
||
totalRows: toNumber(summary.totalRows, 0),
|
||
};
|
||
}
|
||
|
||
async function getExistingInsightMeta(snapshotMeta) {
|
||
if (!snapshotMeta?.snapshotDate || !snapshotMeta?.snapshotBatchId) {
|
||
return null;
|
||
}
|
||
const [row] = await planningDatabase.query(
|
||
`SELECT
|
||
COUNT(*) AS totalRows,
|
||
MAX(generated_at) AS generatedAt
|
||
FROM ${escapeIdentifier(MAY_CHANNEL_LAYOUT_SNAPSHOT_TABLE)}
|
||
WHERE stat_date = ?
|
||
AND snapshot_batch_id = ?
|
||
AND calc_version = ?`,
|
||
[snapshotMeta.snapshotDate, snapshotMeta.snapshotBatchId, MAY_CHANNEL_INSIGHT_CALC_VERSION]
|
||
);
|
||
const totalRows = toNumber(row?.totalRows, 0);
|
||
if (totalRows <= 0) {
|
||
return null;
|
||
}
|
||
return {
|
||
snapshotDate: formatDateOnly(snapshotMeta.snapshotDate),
|
||
snapshotBatchId: snapshotMeta.snapshotBatchId,
|
||
sourceLatestBizDate: formatDateOnly(snapshotMeta.sourceLatestBizDate || snapshotMeta.snapshotDate),
|
||
totalRows,
|
||
generatedAt: row?.generatedAt || null,
|
||
calcVersion: MAY_CHANNEL_INSIGHT_CALC_VERSION,
|
||
};
|
||
}
|
||
|
||
async function getLatestAvailableInsightMeta() {
|
||
const [row] = await planningDatabase.query(
|
||
`SELECT
|
||
stat_date AS snapshotDate,
|
||
snapshot_batch_id AS snapshotBatchId,
|
||
MAX(source_latest_biz_date) AS sourceLatestBizDate,
|
||
COUNT(*) AS totalRows,
|
||
MAX(generated_at) AS generatedAt,
|
||
MAX(calc_version) AS calcVersion
|
||
FROM ${escapeIdentifier(MAY_CHANNEL_LAYOUT_SNAPSHOT_TABLE)}
|
||
WHERE calc_version = ?
|
||
GROUP BY stat_date, snapshot_batch_id
|
||
HAVING COUNT(*) > 0
|
||
ORDER BY generatedAt DESC
|
||
LIMIT 1`,
|
||
[MAY_CHANNEL_INSIGHT_CALC_VERSION]
|
||
);
|
||
|
||
const totalRows = toNumber(row?.totalRows, 0);
|
||
if (totalRows <= 0) {
|
||
return null;
|
||
}
|
||
|
||
return {
|
||
snapshotDate: formatDateOnly(row.snapshotDate),
|
||
snapshotBatchId: normalizeText(row.snapshotBatchId),
|
||
sourceLatestBizDate: formatDateOnly(row.sourceLatestBizDate || row.snapshotDate),
|
||
totalRows,
|
||
generatedAt: row.generatedAt || null,
|
||
calcVersion: normalizeText(row.calcVersion) || MAY_CHANNEL_INSIGHT_CALC_VERSION,
|
||
};
|
||
}
|
||
|
||
function schedulePlanningMayChannelInsightRefresh(snapshotMeta) {
|
||
const refreshKey = buildInsightSnapshotKey(snapshotMeta);
|
||
if (!refreshKey) {
|
||
return false;
|
||
}
|
||
if (mayChannelInsightRefreshPromise) {
|
||
return mayChannelInsightRefreshKey === refreshKey;
|
||
}
|
||
|
||
mayChannelInsightRefreshKey = refreshKey;
|
||
mayChannelInsightRefreshPromise = (async () => {
|
||
try {
|
||
const result = await refreshPlanningMayChannelInsightSnapshot();
|
||
console.log('[PlanningMayChannelInsight] 后台刷新完成:', JSON.stringify(result));
|
||
} catch (error) {
|
||
console.error('[PlanningMayChannelInsight] 后台刷新失败:', error);
|
||
} finally {
|
||
mayChannelInsightRefreshPromise = null;
|
||
mayChannelInsightRefreshKey = '';
|
||
}
|
||
})();
|
||
return true;
|
||
}
|
||
|
||
async function refreshPlanningMayChannelInsightSnapshot() {
|
||
await ensurePlanningMayChannelInsightSchema();
|
||
const snapshotMeta = await resolveMaySnapshotMeta();
|
||
if (!snapshotMeta) {
|
||
return {
|
||
success: false,
|
||
message: 'MAY商品快照尚未生成，无法构建渠道布局洞察。',
|
||
totalRows: 0,
|
||
};
|
||
}
|
||
|
||
const channelLabelExpression = buildChannelLabelExpression('d');
|
||
const missingChannelNamesExpression = buildMissingChannelNamesExpression('c');
|
||
const missingChannelCountExpression = buildMissingChannelCountExpression('c');
|
||
const generatedAt = new Date();
|
||
const shopListingSummaryMap = await queryShopListingSummaryMap(snapshotMeta);
|
||
const { shopMetricMap, mayMetricMap } = await queryShopCurrentMetricMaps(snapshotMeta, shopListingSummaryMap);
|
||
|
||
await planningDatabase.execute(
|
||
`DELETE FROM ${escapeIdentifier(MAY_CHANNEL_ACTIVE_SKU_TABLE)}
|
||
WHERE stat_date = ?
|
||
AND snapshot_batch_id = ?
|
||
AND calc_version = ?`,
|
||
[snapshotMeta.snapshotDate, snapshotMeta.snapshotBatchId, MAY_CHANNEL_INSIGHT_CALC_VERSION]
|
||
);
|
||
await planningDatabase.execute(
|
||
`DELETE FROM ${escapeIdentifier(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE)}
|
||
WHERE stat_date = ?
|
||
AND snapshot_batch_id = ?
|
||
AND calc_version = ?`,
|
||
[snapshotMeta.snapshotDate, snapshotMeta.snapshotBatchId, MAY_CHANNEL_INSIGHT_CALC_VERSION]
|
||
);
|
||
await planningDatabase.execute(
|
||
`DELETE FROM ${escapeIdentifier(MAY_CHANNEL_LAYOUT_SNAPSHOT_TABLE)}
|
||
WHERE stat_date = ?
|
||
AND snapshot_batch_id = ?
|
||
AND calc_version = ?`,
|
||
[snapshotMeta.snapshotDate, snapshotMeta.snapshotBatchId, MAY_CHANNEL_INSIGHT_CALC_VERSION]
|
||
);
|
||
|
||
await planningDatabase.execute(
|
||
`
|
||
INSERT INTO ${escapeIdentifier(MAY_CHANNEL_ACTIVE_SKU_TABLE)} (
|
||
stat_date,
|
||
snapshot_batch_id,
|
||
calc_version,
|
||
sku_key,
|
||
may_sku_code,
|
||
category_name,
|
||
may_sku_image_url,
|
||
may_sales_status,
|
||
review_action,
|
||
may_inventory_quantity,
|
||
may_goods_id_count,
|
||
may_performance_amount,
|
||
may_promotion_fee_30d,
|
||
generated_at
|
||
)
|
||
SELECT
|
||
? AS stat_date,
|
||
? AS snapshot_batch_id,
|
||
? AS calc_version,
|
||
UPPER(TRIM(s.may_sku_code)) AS sku_key,
|
||
MAX(s.may_sku_code) AS may_sku_code,
|
||
MAX(s.category_name) AS category_name,
|
||
MAX(s.may_sku_image_url) AS may_sku_image_url,
|
||
MAX(s.may_sales_status) AS may_sales_status,
|
||
MAX(r.review_action) AS review_action,
|
||
MAX(COALESCE(s.may_inventory_quantity, 0)) AS may_inventory_quantity,
|
||
MAX(COALESCE(s.may_goods_id_count, 0)) AS may_goods_id_count,
|
||
MAX(COALESCE(s.may_performance_amount, 0)) AS may_performance_amount,
|
||
MAX(COALESCE(s.may_promotion_fee_30d, 0)) AS may_promotion_fee_30d,
|
||
? AS generated_at
|
||
FROM ${escapeIdentifier(MAY_PRODUCT_SNAPSHOT_TABLE)} s
|
||
LEFT JOIN ${escapeIdentifier(MAY_PRODUCT_REVIEW_SNAPSHOT_TABLE)} r
|
||
ON r.stat_date = s.stat_date
|
||
AND r.snapshot_batch_id = s.snapshot_batch_id
|
||
AND r.may_sku_code = s.may_sku_code
|
||
WHERE s.stat_date = ?
|
||
AND s.snapshot_batch_id = ?
|
||
AND NULLIF(TRIM(s.may_sku_code), '') IS NOT NULL
|
||
AND ${buildNotDiscontinuedCondition('s.may_sales_status')}
|
||
GROUP BY UPPER(TRIM(s.may_sku_code))
|
||
`,
|
||
[
|
||
snapshotMeta.snapshotDate,
|
||
snapshotMeta.snapshotBatchId,
|
||
MAY_CHANNEL_INSIGHT_CALC_VERSION,
|
||
generatedAt,
|
||
snapshotMeta.snapshotDate,
|
||
snapshotMeta.snapshotBatchId,
|
||
]
|
||
);
|
||
|
||
await planningDatabase.execute(
|
||
`
|
||
INSERT INTO ${escapeIdentifier(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE)} (
|
||
stat_date,
|
||
snapshot_batch_id,
|
||
source_latest_biz_date,
|
||
channel_name,
|
||
shop_name,
|
||
shop_key,
|
||
sku_count,
|
||
item_id_count,
|
||
active_sku_count,
|
||
active_item_id_count,
|
||
sales_amount_30d,
|
||
transaction_amount_30d,
|
||
after_sale_amount_30d,
|
||
sales_qty_30d,
|
||
refund_count_30d,
|
||
order_count_30d,
|
||
promotion_fee_30d,
|
||
gross_cost_amount_30d,
|
||
may_sku_count,
|
||
may_item_id_count,
|
||
may_active_sku_count,
|
||
may_active_item_id_count,
|
||
may_sales_amount_30d,
|
||
may_sales_qty_30d,
|
||
may_promotion_fee_30d,
|
||
may_after_sale_amount_30d,
|
||
generated_at,
|
||
calc_version
|
||
)
|
||
SELECT
|
||
? AS stat_date,
|
||
? AS snapshot_batch_id,
|
||
? AS source_latest_biz_date,
|
||
raw.channel_label AS channel_name,
|
||
raw.shop_name,
|
||
raw.shop_key,
|
||
raw.sku_count,
|
||
raw.item_id_count,
|
||
raw.active_sku_count,
|
||
raw.active_item_id_count,
|
||
raw.sales_amount_30d,
|
||
raw.transaction_amount_30d,
|
||
raw.after_sale_amount_30d,
|
||
raw.sales_qty_30d,
|
||
raw.refund_count_30d,
|
||
raw.order_count_30d,
|
||
raw.promotion_fee_30d,
|
||
raw.gross_cost_amount_30d,
|
||
COALESCE(may.sku_count, 0) AS may_sku_count,
|
||
COALESCE(may.item_id_count, 0) AS may_item_id_count,
|
||
COALESCE(may.active_sku_count, 0) AS may_active_sku_count,
|
||
COALESCE(may.active_item_id_count, 0) AS may_active_item_id_count,
|
||
COALESCE(may.sales_amount_30d, 0) AS may_sales_amount_30d,
|
||
COALESCE(may.sales_qty_30d, 0) AS may_sales_qty_30d,
|
||
COALESCE(may.promotion_fee_30d, 0) AS may_promotion_fee_30d,
|
||
COALESCE(may.after_sale_amount_30d, 0) AS may_after_sale_amount_30d,
|
||
? AS generated_at,
|
||
? AS calc_version
|
||
FROM (
|
||
SELECT
|
||
d.channel_label,
|
||
COALESCE(NULLIF(TRIM(d.shop_name), ''), '未识别店铺') AS shop_name,
|
||
COALESCE(NULLIF(TRIM(d.shop_key), ''), NULLIF(TRIM(d.shop_name), '')) AS shop_key,
|
||
COUNT(DISTINCT UPPER(TRIM(d.primary_sku_code))) AS sku_count,
|
||
COUNT(DISTINCT NULLIF(TRIM(d.item_id), '')) AS item_id_count,
|
||
COUNT(DISTINCT CASE WHEN COALESCE(d.performance_amount, 0) > 0 OR COALESCE(d.goods_count, 0) > 0 THEN UPPER(TRIM(d.primary_sku_code)) END) AS active_sku_count,
|
||
COUNT(DISTINCT CASE WHEN COALESCE(d.performance_amount, 0) > 0 OR COALESCE(d.goods_count, 0) > 0 THEN NULLIF(TRIM(d.item_id), '') END) AS active_item_id_count,
|
||
SUM(COALESCE(d.transaction_amount, 0)) AS sales_amount_30d,
|
||
SUM(COALESCE(d.transaction_amount, 0)) AS transaction_amount_30d,
|
||
SUM(COALESCE(d.after_sale_amount, 0)) AS after_sale_amount_30d,
|
||
SUM(COALESCE(d.goods_count, 0)) AS sales_qty_30d,
|
||
SUM(COALESCE(d.refund_count, 0)) AS refund_count_30d,
|
||
SUM(COALESCE(d.order_count, 0)) AS order_count_30d,
|
||
SUM(
|
||
CASE
|
||
WHEN COALESCE(d.push_fee_amount, 0) + COALESCE(d.marketing_fee_amount, 0) > 0
|
||
THEN COALESCE(d.push_fee_amount, 0) + COALESCE(d.marketing_fee_amount, 0)
|
||
ELSE COALESCE(d.fee_amount, 0)
|
||
END
|
||
) AS promotion_fee_30d,
|
||
SUM(COALESCE(d.gross_cost_amount, 0)) AS gross_cost_amount_30d
|
||
FROM (
|
||
SELECT
|
||
d.*,
|
||
${channelLabelExpression} AS channel_label
|
||
FROM ${escapeIdentifier(CHANNEL_ID_READ_TABLE)} d
|
||
WHERE d.stat_date BETWEEN DATE_SUB(?, INTERVAL 29 DAY) AND ?
|
||
AND NULLIF(TRIM(d.primary_sku_code), '') IS NOT NULL
|
||
) d
|
||
GROUP BY d.channel_label, COALESCE(NULLIF(TRIM(d.shop_name), ''), '未识别店铺'), COALESCE(NULLIF(TRIM(d.shop_key), ''), NULLIF(TRIM(d.shop_name), ''))
|
||
) raw
|
||
LEFT JOIN (
|
||
SELECT
|
||
d.channel_label,
|
||
COALESCE(NULLIF(TRIM(d.shop_name), ''), '未识别店铺') AS shop_name,
|
||
COALESCE(NULLIF(TRIM(d.shop_key), ''), NULLIF(TRIM(d.shop_name), '')) AS shop_key,
|
||
COUNT(DISTINCT UPPER(TRIM(d.primary_sku_code))) AS sku_count,
|
||
COUNT(DISTINCT NULLIF(TRIM(d.item_id), '')) AS item_id_count,
|
||
COUNT(DISTINCT CASE WHEN COALESCE(d.performance_amount, 0) > 0 OR COALESCE(d.goods_count, 0) > 0 THEN UPPER(TRIM(d.primary_sku_code)) END) AS active_sku_count,
|
||
COUNT(DISTINCT CASE WHEN COALESCE(d.performance_amount, 0) > 0 OR COALESCE(d.goods_count, 0) > 0 THEN NULLIF(TRIM(d.item_id), '') END) AS active_item_id_count,
|
||
SUM(COALESCE(d.transaction_amount, 0)) AS sales_amount_30d,
|
||
SUM(COALESCE(d.after_sale_amount, 0)) AS after_sale_amount_30d,
|
||
SUM(COALESCE(d.goods_count, 0)) AS sales_qty_30d,
|
||
SUM(
|
||
CASE
|
||
WHEN COALESCE(d.push_fee_amount, 0) + COALESCE(d.marketing_fee_amount, 0) > 0
|
||
THEN COALESCE(d.push_fee_amount, 0) + COALESCE(d.marketing_fee_amount, 0)
|
||
ELSE COALESCE(d.fee_amount, 0)
|
||
END
|
||
) AS promotion_fee_30d
|
||
FROM (
|
||
SELECT
|
||
d.*,
|
||
${channelLabelExpression} AS channel_label
|
||
FROM ${escapeIdentifier(CHANNEL_ID_READ_TABLE)} d
|
||
WHERE d.stat_date BETWEEN DATE_SUB(?, INTERVAL 29 DAY) AND ?
|
||
AND NULLIF(TRIM(d.primary_sku_code), '') IS NOT NULL
|
||
) d
|
||
STRAIGHT_JOIN ${escapeIdentifier(MAY_CHANNEL_ACTIVE_SKU_TABLE)} s
|
||
ON s.stat_date = ?
|
||
AND s.snapshot_batch_id = ?
|
||
AND s.calc_version = ?
|
||
AND s.sku_key = UPPER(TRIM(d.primary_sku_code))
|
||
GROUP BY d.channel_label, COALESCE(NULLIF(TRIM(d.shop_name), ''), '未识别店铺'), COALESCE(NULLIF(TRIM(d.shop_key), ''), NULLIF(TRIM(d.shop_name), ''))
|
||
) may
|
||
ON may.channel_label = raw.channel_label
|
||
AND may.shop_name = raw.shop_name
|
||
AND COALESCE(may.shop_key, '') = COALESCE(raw.shop_key, '')
|
||
`,
|
||
[
|
||
snapshotMeta.snapshotDate,
|
||
snapshotMeta.snapshotBatchId,
|
||
snapshotMeta.sourceLatestBizDate,
|
||
generatedAt,
|
||
MAY_CHANNEL_INSIGHT_CALC_VERSION,
|
||
snapshotMeta.sourceLatestBizDate,
|
||
snapshotMeta.sourceLatestBizDate,
|
||
snapshotMeta.sourceLatestBizDate,
|
||
snapshotMeta.sourceLatestBizDate,
|
||
snapshotMeta.snapshotDate,
|
||
snapshotMeta.snapshotBatchId,
|
||
MAY_CHANNEL_INSIGHT_CALC_VERSION,
|
||
]
|
||
);
|
||
|
||
await applyShopListingSummary(snapshotMeta, shopListingSummaryMap, shopMetricMap, mayMetricMap);
|
||
|
||
await planningDatabase.execute(
|
||
`
|
||
INSERT INTO ${escapeIdentifier(MAY_CHANNEL_LAYOUT_SNAPSHOT_TABLE)} (
|
||
stat_date,
|
||
snapshot_batch_id,
|
||
source_latest_biz_date,
|
||
may_sku_code,
|
||
category_name,
|
||
may_sku_image_url,
|
||
may_sales_status,
|
||
review_action,
|
||
may_inventory_quantity,
|
||
may_goods_id_count,
|
||
may_performance_amount,
|
||
may_promotion_fee_30d,
|
||
promotion_roi,
|
||
covered_channel_count,
|
||
covered_shop_count,
|
||
covered_item_id_count,
|
||
covered_channel_names,
|
||
covered_shop_names,
|
||
missing_channel_names,
|
||
missing_channel_count,
|
||
layout_label,
|
||
layout_reason,
|
||
risk_score,
|
||
sales_amount_30d,
|
||
sales_qty_30d,
|
||
promotion_fee_30d,
|
||
after_sale_amount_30d,
|
||
generated_at,
|
||
calc_version
|
||
)
|
||
SELECT
|
||
? AS stat_date,
|
||
? AS snapshot_batch_id,
|
||
? AS source_latest_biz_date,
|
||
s.may_sku_code,
|
||
s.category_name,
|
||
s.may_sku_image_url,
|
||
s.may_sales_status,
|
||
s.review_action,
|
||
COALESCE(s.may_inventory_quantity, 0) AS may_inventory_quantity,
|
||
COALESCE(s.may_goods_id_count, 0) AS may_goods_id_count,
|
||
COALESCE(s.may_performance_amount, 0) AS may_performance_amount,
|
||
COALESCE(s.may_promotion_fee_30d, 0) AS may_promotion_fee_30d,
|
||
CASE
|
||
WHEN COALESCE(c.promotion_fee_30d, s.may_promotion_fee_30d, 0) > 0
|
||
THEN COALESCE(c.sales_amount_30d, s.may_performance_amount, 0) / NULLIF(COALESCE(c.promotion_fee_30d, s.may_promotion_fee_30d, 0), 0)
|
||
ELSE NULL
|
||
END AS promotion_roi,
|
||
COALESCE(c.covered_channel_count, 0) AS covered_channel_count,
|
||
COALESCE(c.covered_shop_count, 0) AS covered_shop_count,
|
||
COALESCE(c.covered_item_id_count, 0) AS covered_item_id_count,
|
||
c.covered_channel_names,
|
||
c.covered_shop_names,
|
||
${missingChannelNamesExpression} AS missing_channel_names,
|
||
${missingChannelCountExpression} AS missing_channel_count,
|
||
CASE
|
||
WHEN COALESCE(s.may_inventory_quantity, 0) >= ? AND COALESCE(c.covered_item_id_count, COALESCE(s.may_goods_id_count, 0), 0) <= ? THEN '库存多ID少'
|
||
WHEN COALESCE(s.may_inventory_quantity, 0) > 0 AND (${missingChannelCountExpression}) >= 3 THEN 'ID布局缺失'
|
||
WHEN COALESCE(c.promotion_fee_30d, s.may_promotion_fee_30d, 0) > 0
|
||
AND (
|
||
COALESCE(c.sales_amount_30d, s.may_performance_amount, 0) <= 0
|
||
OR COALESCE(c.sales_amount_30d, s.may_performance_amount, 0) / NULLIF(COALESCE(c.promotion_fee_30d, s.may_promotion_fee_30d, 0), 0) < ?
|
||
) THEN '推广低效'
|
||
WHEN COALESCE(c.covered_shop_count, 0) <= 1 AND COALESCE(s.may_inventory_quantity, 0) >= 20 THEN '店铺覆盖不足'
|
||
ELSE '布局健康'
|
||
END AS layout_label,
|
||
CONCAT_WS('；',
|
||
IF(COALESCE(s.may_inventory_quantity, 0) >= ? AND COALESCE(c.covered_item_id_count, COALESCE(s.may_goods_id_count, 0), 0) <= ?, CONCAT('库存 ', ROUND(COALESCE(s.may_inventory_quantity, 0), 0), '，ID仅 ', COALESCE(c.covered_item_id_count, COALESCE(s.may_goods_id_count, 0), 0)), NULL),
|
||
IF(COALESCE(s.may_inventory_quantity, 0) > 0 AND (${missingChannelCountExpression}) >= 3, CONCAT('缺少渠道：', ${missingChannelNamesExpression}), NULL),
|
||
IF(COALESCE(c.promotion_fee_30d, s.may_promotion_fee_30d, 0) > 0
|
||
AND (
|
||
COALESCE(c.sales_amount_30d, s.may_performance_amount, 0) <= 0
|
||
OR COALESCE(c.sales_amount_30d, s.may_performance_amount, 0) / NULLIF(COALESCE(c.promotion_fee_30d, s.may_promotion_fee_30d, 0), 0) < ?
|
||
),
|
||
CONCAT('推广ROI ', ROUND(COALESCE(c.sales_amount_30d, s.may_performance_amount, 0) / NULLIF(COALESCE(c.promotion_fee_30d, s.may_promotion_fee_30d, 0), 0), 2)),
|
||
NULL),
|
||
IF(COALESCE(c.covered_shop_count, 0) <= 1 AND COALESCE(s.may_inventory_quantity, 0) >= 20, CONCAT('覆盖店铺仅 ', COALESCE(c.covered_shop_count, 0), ' 个'), NULL)
|
||
) AS layout_reason,
|
||
LEAST(100,
|
||
IF(COALESCE(s.may_inventory_quantity, 0) >= ? AND COALESCE(c.covered_item_id_count, COALESCE(s.may_goods_id_count, 0), 0) <= ?, 35, 0)
|
||
+ IF(COALESCE(s.may_inventory_quantity, 0) > 0 AND (${missingChannelCountExpression}) >= 3, 25, 0)
|
||
+ IF(COALESCE(c.promotion_fee_30d, s.may_promotion_fee_30d, 0) > 0
|
||
AND (
|
||
COALESCE(c.sales_amount_30d, s.may_performance_amount, 0) <= 0
|
||
OR COALESCE(c.sales_amount_30d, s.may_performance_amount, 0) / NULLIF(COALESCE(c.promotion_fee_30d, s.may_promotion_fee_30d, 0), 0) < ?
|
||
), 20, 0)
|
||
+ IF(COALESCE(c.sales_amount_30d, s.may_performance_amount, 0) <= 0 AND COALESCE(s.may_inventory_quantity, 0) > 0, 20, 0)
|
||
) AS risk_score,
|
||
COALESCE(c.sales_amount_30d, 0) AS sales_amount_30d,
|
||
COALESCE(c.sales_qty_30d, 0) AS sales_qty_30d,
|
||
COALESCE(c.promotion_fee_30d, s.may_promotion_fee_30d, 0) AS promotion_fee_30d,
|
||
COALESCE(c.after_sale_amount_30d, 0) AS after_sale_amount_30d,
|
||
? AS generated_at,
|
||
? AS calc_version
|
||
FROM ${escapeIdentifier(MAY_CHANNEL_ACTIVE_SKU_TABLE)} s
|
||
LEFT JOIN (
|
||
SELECT
|
||
UPPER(TRIM(c.primary_sku_code)) AS sku_key,
|
||
COUNT(DISTINCT c.channel_label) AS covered_channel_count,
|
||
COUNT(DISTINCT COALESCE(NULLIF(TRIM(c.shop_name), ''), '未识别店铺')) AS covered_shop_count,
|
||
COUNT(DISTINCT NULLIF(TRIM(c.item_id), '')) AS covered_item_id_count,
|
||
GROUP_CONCAT(DISTINCT c.channel_label ORDER BY c.channel_label SEPARATOR '、') AS covered_channel_names,
|
||
GROUP_CONCAT(DISTINCT COALESCE(NULLIF(TRIM(c.shop_name), ''), '未识别店铺') ORDER BY COALESCE(NULLIF(TRIM(c.shop_name), ''), '未识别店铺') SEPARATOR '、') AS covered_shop_names,
|
||
SUM(COALESCE(c.transaction_amount, 0)) AS sales_amount_30d,
|
||
SUM(COALESCE(c.goods_count, 0)) AS sales_qty_30d,
|
||
SUM(COALESCE(c.after_sale_amount, 0)) AS after_sale_amount_30d,
|
||
SUM(
|
||
CASE
|
||
WHEN COALESCE(c.push_fee_amount, 0) + COALESCE(c.marketing_fee_amount, 0) > 0
|
||
THEN COALESCE(c.push_fee_amount, 0) + COALESCE(c.marketing_fee_amount, 0)
|
||
ELSE COALESCE(c.fee_amount, 0)
|
||
END
|
||
) AS promotion_fee_30d,
|
||
${buildMajorChannelCountSelects()}
|
||
FROM (
|
||
SELECT
|
||
d.*,
|
||
${channelLabelExpression} AS channel_label
|
||
FROM ${escapeIdentifier(CHANNEL_ID_READ_TABLE)} d
|
||
WHERE d.stat_date BETWEEN DATE_SUB(?, INTERVAL 29 DAY) AND ?
|
||
AND NULLIF(TRIM(d.primary_sku_code), '') IS NOT NULL
|
||
) c
|
||
STRAIGHT_JOIN ${escapeIdentifier(MAY_CHANNEL_ACTIVE_SKU_TABLE)} m
|
||
ON m.stat_date = ?
|
||
AND m.snapshot_batch_id = ?
|
||
AND m.calc_version = ?
|
||
AND m.sku_key = UPPER(TRIM(c.primary_sku_code))
|
||
GROUP BY UPPER(TRIM(c.primary_sku_code))
|
||
) c
|
||
ON c.sku_key = s.sku_key
|
||
WHERE s.stat_date = ?
|
||
AND s.snapshot_batch_id = ?
|
||
AND s.calc_version = ?
|
||
`,
|
||
[
|
||
snapshotMeta.snapshotDate,
|
||
snapshotMeta.snapshotBatchId,
|
||
snapshotMeta.sourceLatestBizDate,
|
||
HIGH_INVENTORY_THRESHOLD,
|
||
LOW_ITEM_ID_THRESHOLD,
|
||
LOW_PROMOTION_ROI_THRESHOLD,
|
||
HIGH_INVENTORY_THRESHOLD,
|
||
LOW_ITEM_ID_THRESHOLD,
|
||
LOW_PROMOTION_ROI_THRESHOLD,
|
||
HIGH_INVENTORY_THRESHOLD,
|
||
LOW_ITEM_ID_THRESHOLD,
|
||
LOW_PROMOTION_ROI_THRESHOLD,
|
||
generatedAt,
|
||
MAY_CHANNEL_INSIGHT_CALC_VERSION,
|
||
snapshotMeta.sourceLatestBizDate,
|
||
snapshotMeta.sourceLatestBizDate,
|
||
snapshotMeta.snapshotDate,
|
||
snapshotMeta.snapshotBatchId,
|
||
MAY_CHANNEL_INSIGHT_CALC_VERSION,
|
||
snapshotMeta.snapshotDate,
|
||
snapshotMeta.snapshotBatchId,
|
||
MAY_CHANNEL_INSIGHT_CALC_VERSION,
|
||
]
|
||
);
|
||
|
||
const [row] = await planningDatabase.query(
|
||
`SELECT COUNT(*) AS totalRows
|
||
FROM ${escapeIdentifier(MAY_CHANNEL_LAYOUT_SNAPSHOT_TABLE)}
|
||
WHERE stat_date = ?
|
||
AND snapshot_batch_id = ?
|
||
AND calc_version = ?`,
|
||
[snapshotMeta.snapshotDate, snapshotMeta.snapshotBatchId, MAY_CHANNEL_INSIGHT_CALC_VERSION]
|
||
);
|
||
|
||
return {
|
||
success: true,
|
||
statDate: snapshotMeta.snapshotDate,
|
||
snapshotBatchId: snapshotMeta.snapshotBatchId,
|
||
sourceLatestBizDate: snapshotMeta.sourceLatestBizDate,
|
||
tableNames: [MAY_CHANNEL_SHOP_SNAPSHOT_TABLE, MAY_CHANNEL_LAYOUT_SNAPSHOT_TABLE],
|
||
totalRows: toNumber(row?.totalRows, 0),
|
||
generatedAt,
|
||
calcVersion: MAY_CHANNEL_INSIGHT_CALC_VERSION,
|
||
};
|
||
}
|
||
|
||
async function ensurePlanningMayChannelInsightFresh(options = {}) {
|
||
await ensurePlanningMayChannelInsightSchema();
|
||
const snapshotMeta = await resolveMaySnapshotMeta();
|
||
if (!snapshotMeta) {
|
||
return null;
|
||
}
|
||
|
||
const existingMeta = await getExistingInsightMeta(snapshotMeta);
|
||
if (existingMeta) {
|
||
return {
|
||
...existingMeta,
|
||
isStale: false,
|
||
refreshPending: false,
|
||
currentSnapshotDate: existingMeta.snapshotDate,
|
||
currentSnapshotBatchId: existingMeta.snapshotBatchId,
|
||
requestedSnapshotDate: existingMeta.snapshotDate,
|
||
requestedSnapshotBatchId: existingMeta.snapshotBatchId,
|
||
};
|
||
}
|
||
|
||
if (options.force) {
|
||
const refreshResult = await refreshPlanningMayChannelInsightSnapshot();
|
||
return {
|
||
snapshotDate: formatDateOnly(refreshResult.statDate || snapshotMeta.snapshotDate),
|
||
snapshotBatchId: normalizeText(refreshResult.snapshotBatchId || snapshotMeta.snapshotBatchId),
|
||
sourceLatestBizDate: formatDateOnly(refreshResult.sourceLatestBizDate || snapshotMeta.sourceLatestBizDate),
|
||
totalRows: refreshResult.totalRows || 0,
|
||
generatedAt: refreshResult.generatedAt || new Date(),
|
||
calcVersion: MAY_CHANNEL_INSIGHT_CALC_VERSION,
|
||
isStale: false,
|
||
refreshPending: false,
|
||
currentSnapshotDate: formatDateOnly(refreshResult.statDate || snapshotMeta.snapshotDate),
|
||
currentSnapshotBatchId: normalizeText(refreshResult.snapshotBatchId || snapshotMeta.snapshotBatchId),
|
||
requestedSnapshotDate: snapshotMeta.snapshotDate,
|
||
requestedSnapshotBatchId: snapshotMeta.snapshotBatchId,
|
||
};
|
||
}
|
||
|
||
const fallbackMeta = await getLatestAvailableInsightMeta();
|
||
const refreshPending = schedulePlanningMayChannelInsightRefresh(snapshotMeta) || Boolean(mayChannelInsightRefreshPromise);
|
||
if (fallbackMeta) {
|
||
return {
|
||
...fallbackMeta,
|
||
isStale: true,
|
||
refreshPending,
|
||
currentSnapshotDate: fallbackMeta.snapshotDate,
|
||
currentSnapshotBatchId: fallbackMeta.snapshotBatchId,
|
||
requestedSnapshotDate: snapshotMeta.snapshotDate,
|
||
requestedSnapshotBatchId: snapshotMeta.snapshotBatchId,
|
||
requestedSourceLatestBizDate: snapshotMeta.sourceLatestBizDate,
|
||
};
|
||
}
|
||
|
||
return {
|
||
snapshotDate: snapshotMeta.snapshotDate,
|
||
snapshotBatchId: snapshotMeta.snapshotBatchId,
|
||
sourceLatestBizDate: snapshotMeta.sourceLatestBizDate,
|
||
totalRows: 0,
|
||
generatedAt: null,
|
||
calcVersion: MAY_CHANNEL_INSIGHT_CALC_VERSION,
|
||
isStale: true,
|
||
refreshPending,
|
||
currentSnapshotDate: snapshotMeta.snapshotDate,
|
||
currentSnapshotBatchId: snapshotMeta.snapshotBatchId,
|
||
requestedSnapshotDate: snapshotMeta.snapshotDate,
|
||
requestedSnapshotBatchId: snapshotMeta.snapshotBatchId,
|
||
};
|
||
}
|
||
|
||
function buildLayoutWhere(view) {
|
||
const normalizedView = normalizeText(view || 'all');
|
||
if (normalizedView === 'missing') {
|
||
return {
|
||
sql: 'missing_channel_count > 0 AND may_inventory_quantity > 0',
|
||
params: [],
|
||
};
|
||
}
|
||
if (normalizedView === 'high_inventory_low_id') {
|
||
return {
|
||
sql: 'layout_label = ?',
|
||
params: ['库存多ID少'],
|
||
};
|
||
}
|
||
if (normalizedView === 'promotion') {
|
||
return {
|
||
sql: 'promotion_fee_30d > 0',
|
||
params: [],
|
||
};
|
||
}
|
||
if (normalizedView === 'single_shop') {
|
||
return {
|
||
sql: 'covered_shop_count <= 1 AND may_inventory_quantity > 0',
|
||
params: [],
|
||
};
|
||
}
|
||
return {
|
||
sql: '1 = 1',
|
||
params: [],
|
||
};
|
||
}
|
||
|
||
async function getPlanningMayChannelInsight(options = {}) {
|
||
const page = Math.max(Number(options.page) || 1, 1);
|
||
const pageSize = Math.min(Math.max(Number(options.pageSize) || 12, 1), 50);
|
||
const view = normalizeText(options.view || 'shops') || 'shops';
|
||
const meta = await ensurePlanningMayChannelInsightFresh({ force: ['1', 'true'].includes(String(options.refresh || '').toLowerCase()) });
|
||
if (!meta) {
|
||
return {
|
||
meta: null,
|
||
summary: {},
|
||
rows: [],
|
||
total: 0,
|
||
page,
|
||
pageSize,
|
||
view,
|
||
message: 'MAY商品快照尚未生成。',
|
||
};
|
||
}
|
||
|
||
const [summaryRow] = await planningDatabase.query(
|
||
`SELECT
|
||
COUNT(*) AS totalSku,
|
||
SUM(COALESCE(may_inventory_quantity, 0)) AS totalInventory,
|
||
SUM(COALESCE(sales_amount_30d, 0)) AS totalSalesAmount,
|
||
SUM(COALESCE(promotion_fee_30d, 0)) AS totalPromotionFee,
|
||
SUM(CASE WHEN missing_channel_count > 0 AND may_inventory_quantity > 0 THEN 1 ELSE 0 END) AS missingChannelSkuCount,
|
||
SUM(CASE WHEN layout_label = '库存多ID少' THEN 1 ELSE 0 END) AS highInventoryLowIdSkuCount,
|
||
SUM(CASE WHEN promotion_fee_30d > 0 AND (sales_amount_30d <= 0 OR sales_amount_30d / NULLIF(promotion_fee_30d, 0) < ?) THEN 1 ELSE 0 END) AS promotionInefficientSkuCount,
|
||
SUM(CASE WHEN covered_shop_count <= 1 AND may_inventory_quantity > 0 THEN 1 ELSE 0 END) AS singleShopSkuCount,
|
||
AVG(NULLIF(covered_channel_count, 0)) AS avgCoveredChannelCount,
|
||
AVG(NULLIF(covered_shop_count, 0)) AS avgCoveredShopCount
|
||
FROM ${escapeIdentifier(MAY_CHANNEL_LAYOUT_SNAPSHOT_TABLE)}
|
||
WHERE stat_date = ?
|
||
AND snapshot_batch_id = ?
|
||
AND calc_version = ?`,
|
||
[LOW_PROMOTION_ROI_THRESHOLD, meta.snapshotDate, meta.snapshotBatchId, MAY_CHANNEL_INSIGHT_CALC_VERSION]
|
||
);
|
||
|
||
const [shopSummaryRow] = await planningDatabase.query(
|
||
`SELECT
|
||
COUNT(DISTINCT channel_name) AS channelCount,
|
||
COUNT(DISTINCT shop_name) AS shopCount,
|
||
COUNT(*) AS channelShopCount,
|
||
SUM(COALESCE(sku_count, 0)) AS rawSkuCount,
|
||
SUM(COALESCE(item_id_count, 0)) AS rawItemIdCount,
|
||
SUM(COALESCE(sales_amount_30d, 0)) AS rawSalesAmount,
|
||
SUM(COALESCE(sales_qty_30d, 0)) AS rawSalesQty,
|
||
SUM(COALESCE(promotion_fee_30d, 0)) AS rawPromotionFee,
|
||
SUM(COALESCE(may_sku_count, 0)) AS maySkuCount,
|
||
SUM(COALESCE(may_item_id_count, 0)) AS mayItemIdCount,
|
||
SUM(COALESCE(may_sales_amount_30d, 0)) AS maySalesAmount,
|
||
SUM(COALESCE(may_sales_qty_30d, 0)) AS maySalesQty,
|
||
SUM(COALESCE(may_promotion_fee_30d, 0)) AS mayPromotionFee
|
||
FROM ${escapeIdentifier(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE)}
|
||
WHERE stat_date = ?
|
||
AND snapshot_batch_id = ?
|
||
AND calc_version = ?`,
|
||
[meta.snapshotDate, meta.snapshotBatchId, MAY_CHANNEL_INSIGHT_CALC_VERSION]
|
||
);
|
||
|
||
const summary = {
|
||
totalSku: toNumber(summaryRow?.totalSku, 0),
|
||
totalInventory: toNumber(summaryRow?.totalInventory, 0),
|
||
totalSalesAmount: toNumber(summaryRow?.totalSalesAmount, 0),
|
||
totalPromotionFee: toNumber(summaryRow?.totalPromotionFee, 0),
|
||
channelCount: toNumber(shopSummaryRow?.channelCount, 0),
|
||
shopCount: toNumber(shopSummaryRow?.shopCount, 0),
|
||
channelShopCount: toNumber(shopSummaryRow?.channelShopCount, 0),
|
||
missingChannelSkuCount: toNumber(summaryRow?.missingChannelSkuCount, 0),
|
||
highInventoryLowIdSkuCount: toNumber(summaryRow?.highInventoryLowIdSkuCount, 0),
|
||
promotionInefficientSkuCount: toNumber(summaryRow?.promotionInefficientSkuCount, 0),
|
||
singleShopSkuCount: toNumber(summaryRow?.singleShopSkuCount, 0),
|
||
avgCoveredChannelCount: toNumber(summaryRow?.avgCoveredChannelCount, 0),
|
||
avgCoveredShopCount: toNumber(summaryRow?.avgCoveredShopCount, 0),
|
||
rawSkuCount: toNumber(shopSummaryRow?.rawSkuCount, 0),
|
||
rawItemIdCount: toNumber(shopSummaryRow?.rawItemIdCount, 0),
|
||
rawSalesAmount: toNumber(shopSummaryRow?.rawSalesAmount, 0),
|
||
rawSalesQty: toNumber(shopSummaryRow?.rawSalesQty, 0),
|
||
rawPromotionFee: toNumber(shopSummaryRow?.rawPromotionFee, 0),
|
||
maySkuCount: toNumber(shopSummaryRow?.maySkuCount, 0),
|
||
mayItemIdCount: toNumber(shopSummaryRow?.mayItemIdCount, 0),
|
||
maySalesAmount: toNumber(shopSummaryRow?.maySalesAmount, 0),
|
||
maySalesQty: toNumber(shopSummaryRow?.maySalesQty, 0),
|
||
mayPromotionFee: toNumber(shopSummaryRow?.mayPromotionFee, 0),
|
||
};
|
||
|
||
if (view === 'shops') {
|
||
summary.totalSalesAmount = summary.rawSalesAmount;
|
||
summary.totalPromotionFee = summary.rawPromotionFee;
|
||
}
|
||
|
||
const offset = (page - 1) * pageSize;
|
||
if (view === 'shops') {
|
||
const [countRow] = await planningDatabase.query(
|
||
`SELECT COUNT(*) AS total
|
||
FROM ${escapeIdentifier(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE)}
|
||
WHERE stat_date = ?
|
||
AND snapshot_batch_id = ?
|
||
AND calc_version = ?`,
|
||
[meta.snapshotDate, meta.snapshotBatchId, MAY_CHANNEL_INSIGHT_CALC_VERSION]
|
||
);
|
||
const rows = await planningDatabase.query(
|
||
`SELECT
|
||
channel_name AS channelName,
|
||
shop_name AS shopName,
|
||
shop_key AS shopKey,
|
||
sku_count AS skuCount,
|
||
item_id_count AS itemIdCount,
|
||
active_sku_count AS activeSkuCount,
|
||
active_item_id_count AS activeItemIdCount,
|
||
sales_amount_30d AS salesAmount30d,
|
||
transaction_amount_30d AS transactionAmount30d,
|
||
after_sale_amount_30d AS afterSaleAmount30d,
|
||
sales_qty_30d AS salesQty30d,
|
||
refund_count_30d AS refundCount30d,
|
||
order_count_30d AS orderCount30d,
|
||
promotion_fee_30d AS promotionFee30d,
|
||
gross_cost_amount_30d AS grossCostAmount30d,
|
||
may_sku_count AS maySkuCount,
|
||
may_item_id_count AS mayItemIdCount,
|
||
may_active_sku_count AS mayActiveSkuCount,
|
||
may_active_item_id_count AS mayActiveItemIdCount,
|
||
may_sales_amount_30d AS maySalesAmount30d,
|
||
may_sales_qty_30d AS maySalesQty30d,
|
||
may_promotion_fee_30d AS mayPromotionFee30d,
|
||
may_after_sale_amount_30d AS mayAfterSaleAmount30d
|
||
FROM ${escapeIdentifier(MAY_CHANNEL_SHOP_SNAPSHOT_TABLE)}
|
||
WHERE stat_date = ?
|
||
AND snapshot_batch_id = ?
|
||
AND calc_version = ?
|
||
ORDER BY sales_amount_30d DESC, sku_count DESC
|
||
LIMIT ? OFFSET ?`,
|
||
[meta.snapshotDate, meta.snapshotBatchId, MAY_CHANNEL_INSIGHT_CALC_VERSION, pageSize, offset]
|
||
);
|
||
return {
|
||
meta,
|
||
summary,
|
||
rows,
|
||
total: toNumber(countRow?.total, 0),
|
||
page,
|
||
pageSize,
|
||
view,
|
||
};
|
||
}
|
||
|
||
const layoutWhere = buildLayoutWhere(view);
|
||
const baseParams = [meta.snapshotDate, meta.snapshotBatchId, MAY_CHANNEL_INSIGHT_CALC_VERSION, ...layoutWhere.params];
|
||
const [countRow] = await planningDatabase.query(
|
||
`SELECT COUNT(*) AS total
|
||
FROM ${escapeIdentifier(MAY_CHANNEL_LAYOUT_SNAPSHOT_TABLE)}
|
||
WHERE stat_date = ?
|
||
AND snapshot_batch_id = ?
|
||
AND calc_version = ?
|
||
AND ${layoutWhere.sql}`,
|
||
baseParams
|
||
);
|
||
const rows = await planningDatabase.query(
|
||
`SELECT
|
||
may_sku_code AS maySkuCode,
|
||
category_name AS categoryName,
|
||
may_sku_image_url AS maySkuImageUrl,
|
||
may_sales_status AS maySalesStatus,
|
||
review_action AS reviewAction,
|
||
may_inventory_quantity AS mayInventoryQuantity,
|
||
may_goods_id_count AS mayGoodsIdCount,
|
||
may_performance_amount AS mayPerformanceAmount,
|
||
may_promotion_fee_30d AS mayPromotionFee30d,
|
||
promotion_roi AS promotionRoi,
|
||
covered_channel_count AS coveredChannelCount,
|
||
covered_shop_count AS coveredShopCount,
|
||
covered_item_id_count AS coveredItemIdCount,
|
||
covered_channel_names AS coveredChannelNames,
|
||
covered_shop_names AS coveredShopNames,
|
||
missing_channel_names AS missingChannelNames,
|
||
missing_channel_count AS missingChannelCount,
|
||
layout_label AS layoutLabel,
|
||
layout_reason AS layoutReason,
|
||
risk_score AS riskScore,
|
||
sales_amount_30d AS salesAmount30d,
|
||
sales_qty_30d AS salesQty30d,
|
||
promotion_fee_30d AS promotionFee30d,
|
||
after_sale_amount_30d AS afterSaleAmount30d
|
||
FROM ${escapeIdentifier(MAY_CHANNEL_LAYOUT_SNAPSHOT_TABLE)}
|
||
WHERE stat_date = ?
|
||
AND snapshot_batch_id = ?
|
||
AND calc_version = ?
|
||
AND ${layoutWhere.sql}
|
||
ORDER BY risk_score DESC, may_inventory_quantity DESC, may_performance_amount DESC
|
||
LIMIT ? OFFSET ?`,
|
||
[...baseParams, pageSize, offset]
|
||
);
|
||
|
||
return {
|
||
meta,
|
||
summary,
|
||
rows,
|
||
total: toNumber(countRow?.total, 0),
|
||
page,
|
||
pageSize,
|
||
view,
|
||
};
|
||
}
|
||
|
||
module.exports = {
|
||
MAY_CHANNEL_SHOP_SNAPSHOT_TABLE,
|
||
MAY_CHANNEL_LAYOUT_SNAPSHOT_TABLE,
|
||
MAY_CHANNEL_INSIGHT_CALC_VERSION,
|
||
ensurePlanningMayChannelInsightSchema,
|
||
refreshPlanningMayChannelInsightSnapshot,
|
||
repairPlanningMayChannelInsightShopCoverage,
|
||
getPlanningMayChannelInsight,
|
||
};
|