1276 lines
37 KiB
Plaintext
1276 lines
37 KiB
Plaintext
const BOT_TOKEN = 'xxxxxxxx';
|
||
const ALLOWED_USER_ID = xxxxxxxx;
|
||
const VIEW_TOKEN = 'xbox123';
|
||
|
||
const MAX_TELEGRAM_TEXT = 4000;
|
||
const FETCH_TIMEOUT_MS = 8000;
|
||
const EXCHANGE_TIMEOUT_MS = 6000;
|
||
const MINI_CONCURRENCY = 5; // 每次 /run 只处理前 5 个
|
||
const RUN_LOCK_TTL = 1800;
|
||
const BATCH_TIMEOUT_MS = 15000;
|
||
|
||
// ========================= 工具函数 =========================
|
||
function safeTelegramText(text) {
|
||
let s = String(text ?? '');
|
||
if (s.length > MAX_TELEGRAM_TEXT) {
|
||
s = s.substring(0, MAX_TELEGRAM_TEXT) + '\n\n... (内容过长已截断)';
|
||
}
|
||
return s;
|
||
}
|
||
|
||
function escapeHTML(str) {
|
||
return String(str ?? '')
|
||
.replace(/&/g, '&')
|
||
.replace(/</g, '<')
|
||
.replace(/>/g, '>')
|
||
.replace(/"/g, '"');
|
||
}
|
||
|
||
function makeProgressBar(done, total, length = 10) {
|
||
if (total <= 0) return '□□□□□□□□□□';
|
||
const ratio = Math.max(0, Math.min(1, done / total));
|
||
const filled = Math.round(ratio * length);
|
||
return '■'.repeat(filled) + '□'.repeat(length - filled);
|
||
}
|
||
|
||
function getPaginationKeyboard(currentPage) {
|
||
return {
|
||
inline_keyboard: [
|
||
[
|
||
{ text: currentPage === 'page_1' ? '✅ 报价' : '🎮 报价', callback_data: 'page_1' },
|
||
{ text: currentPage === 'page_2' ? '✅ Surge' : '📦 Surge', callback_data: 'page_2' },
|
||
{ text: currentPage === 'page_3' ? '✅ 链接' : '🔗 链接', callback_data: 'page_3' }
|
||
]
|
||
]
|
||
};
|
||
}
|
||
|
||
async function fetchWithTimeout(url, options = {}, timeoutMs = FETCH_TIMEOUT_MS) {
|
||
const controller = new AbortController();
|
||
const timer = setTimeout(() => controller.abort(), timeoutMs);
|
||
|
||
try {
|
||
return await fetch(url, {
|
||
...options,
|
||
signal: controller.signal
|
||
});
|
||
} finally {
|
||
clearTimeout(timer);
|
||
}
|
||
}
|
||
|
||
async function answerCallbackQuery(callbackQueryId, text = null) {
|
||
const url = `https://api.telegram.org/bot${BOT_TOKEN}/answerCallbackQuery`;
|
||
const body = { callback_query_id: callbackQueryId };
|
||
|
||
if (text) {
|
||
body.text = text;
|
||
body.show_alert = true;
|
||
}
|
||
|
||
const resp = await fetch(url, {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify(body)
|
||
});
|
||
|
||
try {
|
||
resp.body?.cancel();
|
||
} catch (_) {}
|
||
}
|
||
|
||
async function sendTelegramMessage(chatId, text, replyMarkup = null) {
|
||
const url = `https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`;
|
||
|
||
const payloadObj = {
|
||
chat_id: chatId,
|
||
text: safeTelegramText(text),
|
||
parse_mode: 'HTML',
|
||
disable_web_page_preview: true
|
||
};
|
||
|
||
if (replyMarkup) {
|
||
payloadObj.reply_markup = replyMarkup;
|
||
}
|
||
|
||
const resp = await fetch(url, {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify(payloadObj)
|
||
});
|
||
|
||
try {
|
||
return await resp.json();
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
async function editTelegramMessage(chatId, messageId, text, replyMarkup = null) {
|
||
const url = `https://api.telegram.org/bot${BOT_TOKEN}/editMessageText`;
|
||
|
||
const payloadObj = {
|
||
chat_id: chatId,
|
||
message_id: messageId,
|
||
text: safeTelegramText(text),
|
||
parse_mode: 'HTML',
|
||
disable_web_page_preview: true
|
||
};
|
||
|
||
if (replyMarkup) {
|
||
payloadObj.reply_markup = replyMarkup;
|
||
}
|
||
|
||
const resp = await fetch(url, {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify(payloadObj)
|
||
});
|
||
|
||
try {
|
||
resp.body?.cancel();
|
||
} catch (_) {}
|
||
}
|
||
|
||
function calculateProxyPrice(cnyPrices) {
|
||
const totalCNY = cnyPrices.reduce((acc, val) => acc + parseFloat(val), 0);
|
||
let proxyPrice = 0;
|
||
let expressionStr = '';
|
||
const baseStr = cnyPrices.join('+');
|
||
const multi = cnyPrices.length > 1;
|
||
|
||
if (totalCNY < 40) {
|
||
proxyPrice = totalCNY + 12;
|
||
expressionStr = `${baseStr}+12=${proxyPrice.toFixed(2)}`;
|
||
} else if (totalCNY < 65) {
|
||
proxyPrice = totalCNY * 1.28;
|
||
expressionStr = `${multi ? '(' + baseStr + ')' : baseStr}*1.28=${proxyPrice.toFixed(2)}`;
|
||
} else {
|
||
proxyPrice = totalCNY * 1.27;
|
||
expressionStr = `${multi ? '(' + baseStr + ')' : baseStr}*1.27=${proxyPrice.toFixed(2)}`;
|
||
}
|
||
|
||
return { totalCNY, proxyPrice, expressionStr };
|
||
}
|
||
|
||
function buildProgressText(total, processed, pendingCount, rate, extra = '') {
|
||
const bar = makeProgressBar(processed, total, 10);
|
||
|
||
let text =
|
||
`⏳ <b>抓取进行中</b>\n\n` +
|
||
`${bar}\n` +
|
||
`<b>${processed}/${total}</b>\n\n` +
|
||
`当前待处理队列: <b>${pendingCount}</b> 个`;
|
||
|
||
if (rate) {
|
||
text += `\n汇率: <b>1 NGN ≈ ${Number(rate).toFixed(6)} CNY</b>`;
|
||
}
|
||
|
||
if (extra) {
|
||
text += `\n\n${extra}`;
|
||
}
|
||
|
||
return text;
|
||
}
|
||
|
||
// ================== 实时汇率获取 ==================
|
||
async function getRealTimeExchangeRate() {
|
||
const apis = [
|
||
{
|
||
name: 'Open Exchange Rates',
|
||
url: 'https://open.er-api.com/v6/latest/NGN',
|
||
parse: (data) => data?.rates?.CNY
|
||
},
|
||
{
|
||
name: 'Fawaz Ahmed API',
|
||
url: 'https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@latest/v1/currencies/ngn.json',
|
||
parse: (data) => data?.ngn?.cny
|
||
},
|
||
{
|
||
name: 'ExchangeRate-API',
|
||
url: 'https://api.exchangerate-api.com/v4/latest/NGN',
|
||
parse: (data) => data?.rates?.CNY
|
||
}
|
||
];
|
||
|
||
for (const api of apis) {
|
||
try {
|
||
const response = await fetchWithTimeout(api.url, {}, EXCHANGE_TIMEOUT_MS);
|
||
if (!response.ok) continue;
|
||
|
||
const data = await response.json();
|
||
const rate = api.parse(data);
|
||
|
||
if (rate && typeof rate === 'number') {
|
||
return rate;
|
||
}
|
||
} catch (_) {}
|
||
}
|
||
|
||
throw new Error('所有备用实时汇率 API 均请求失败，请稍后再试。');
|
||
}
|
||
|
||
// ========================= KV Key =========================
|
||
function getQueueKey(userId) {
|
||
return `xbox_urls_${userId}`;
|
||
}
|
||
|
||
function getRunLockKey(userId) {
|
||
return `RUNNING_${userId}`;
|
||
}
|
||
|
||
function getRunMetaKey(userId) {
|
||
return `RUN_META_${userId}`;
|
||
}
|
||
|
||
function getStateKey(userId) {
|
||
return `SUCCESS_STATE_${userId}`;
|
||
}
|
||
|
||
function getPagesKey(userId) {
|
||
return `LATEST_RESULT_${userId}`;
|
||
}
|
||
|
||
function getSurgeQueueKey(userId) {
|
||
return `SURGE_GROUP_QUEUE_${userId}`;
|
||
}
|
||
|
||
function getResolvedLinksKey(userId) {
|
||
return `RESOLVED_LINKS_${userId}`;
|
||
}
|
||
|
||
// ========================= 状态读写 =========================
|
||
async function loadPendingQueue(env, userId) {
|
||
const raw = await env.LINKS_KV.get(getQueueKey(userId));
|
||
return raw ? JSON.parse(raw) : [];
|
||
}
|
||
|
||
async function savePendingQueue(env, userId, queue) {
|
||
const uniqueQueue = [...new Set(queue)];
|
||
if (uniqueQueue.length > 0) {
|
||
await env.LINKS_KV.put(getQueueKey(userId), JSON.stringify(uniqueQueue));
|
||
} else {
|
||
await env.LINKS_KV.delete(getQueueKey(userId));
|
||
}
|
||
}
|
||
|
||
async function loadSuccessState(env, userId) {
|
||
const raw = await env.LINKS_KV.get(getStateKey(userId));
|
||
if (!raw) {
|
||
return {
|
||
items: [],
|
||
lastRate: null,
|
||
updatedAt: null
|
||
};
|
||
}
|
||
|
||
try {
|
||
const parsed = JSON.parse(raw);
|
||
return {
|
||
items: Array.isArray(parsed.items) ? parsed.items : [],
|
||
lastRate: parsed.lastRate ?? null,
|
||
updatedAt: parsed.updatedAt ?? null
|
||
};
|
||
} catch {
|
||
return {
|
||
items: [],
|
||
lastRate: null,
|
||
updatedAt: null
|
||
};
|
||
}
|
||
}
|
||
|
||
async function saveSuccessState(env, userId, state) {
|
||
await env.LINKS_KV.put(
|
||
getStateKey(userId),
|
||
JSON.stringify({
|
||
items: state.items || [],
|
||
lastRate: state.lastRate ?? null,
|
||
updatedAt: new Date().toISOString()
|
||
})
|
||
);
|
||
}
|
||
|
||
async function loadResolvedLinks(env, userId) {
|
||
const raw = await env.LINKS_KV.get(getResolvedLinksKey(userId));
|
||
if (!raw) return [];
|
||
|
||
try {
|
||
const parsed = JSON.parse(raw);
|
||
return Array.isArray(parsed) ? parsed : [];
|
||
} catch {
|
||
return [];
|
||
}
|
||
}
|
||
|
||
async function saveResolvedLinks(env, userId, links) {
|
||
const safeLinks = Array.isArray(links) ? links : [];
|
||
await env.LINKS_KV.put(getResolvedLinksKey(userId), JSON.stringify(safeLinks));
|
||
}
|
||
|
||
async function appendResolvedLink(env, userId, linkInfo) {
|
||
const links = await loadResolvedLinks(env, userId);
|
||
const exists = links.some(x => x.sourceUrl === linkInfo.sourceUrl);
|
||
|
||
if (!exists) {
|
||
links.push({
|
||
sourceUrl: linkInfo.sourceUrl,
|
||
resolvedUrl: linkInfo.resolvedUrl,
|
||
bigId: linkInfo.bigId,
|
||
gameName: linkInfo.gameName,
|
||
createdAt: new Date().toISOString()
|
||
});
|
||
await saveResolvedLinks(env, userId, links);
|
||
}
|
||
}
|
||
|
||
async function loadRunMeta(env, userId) {
|
||
const raw = await env.LINKS_KV.get(getRunMetaKey(userId));
|
||
return raw ? JSON.parse(raw) : null;
|
||
}
|
||
|
||
async function saveRunMeta(env, userId, meta) {
|
||
await env.LINKS_KV.put(getRunMetaKey(userId), JSON.stringify(meta), {
|
||
expirationTtl: RUN_LOCK_TTL
|
||
});
|
||
}
|
||
|
||
async function clearRunMeta(env, userId) {
|
||
await env.LINKS_KV.delete(getRunMetaKey(userId));
|
||
}
|
||
|
||
async function isRunActive(env, userId, runId) {
|
||
const meta = await loadRunMeta(env, userId);
|
||
return !!(meta && meta.runId === runId);
|
||
}
|
||
|
||
async function forceStopRunInternal(env, userId, runId) {
|
||
if (!(await isRunActive(env, userId, runId))) {
|
||
return false;
|
||
}
|
||
|
||
await env.LINKS_KV.delete(getRunLockKey(userId));
|
||
await clearRunMeta(env, userId);
|
||
return true;
|
||
}
|
||
|
||
// ========================= Surge 分组队列 =========================
|
||
async function loadSurgeQueue(env, userId) {
|
||
const raw = await env.LINKS_KV.get(getSurgeQueueKey(userId));
|
||
if (!raw) {
|
||
return {
|
||
nextGroupIndex: 1,
|
||
groups: []
|
||
};
|
||
}
|
||
|
||
try {
|
||
const parsed = JSON.parse(raw);
|
||
return {
|
||
nextGroupIndex: typeof parsed.nextGroupIndex === 'number' ? parsed.nextGroupIndex : 1,
|
||
groups: Array.isArray(parsed.groups) ? parsed.groups : []
|
||
};
|
||
} catch {
|
||
return {
|
||
nextGroupIndex: 1,
|
||
groups: []
|
||
};
|
||
}
|
||
}
|
||
|
||
async function saveSurgeQueue(env, userId, queue) {
|
||
const safeQueue = {
|
||
nextGroupIndex: typeof queue.nextGroupIndex === 'number' ? queue.nextGroupIndex : 1,
|
||
groups: Array.isArray(queue.groups) ? queue.groups : []
|
||
};
|
||
|
||
await env.LINKS_KV.put(getSurgeQueueKey(userId), JSON.stringify(safeQueue));
|
||
|
||
if (safeQueue.groups.length > 0) {
|
||
await env.LINKS_KV.put('LATEST_XBOX_LIST', JSON.stringify(safeQueue.groups[0].products));
|
||
} else {
|
||
await env.LINKS_KV.delete('LATEST_XBOX_LIST');
|
||
}
|
||
}
|
||
|
||
async function appendProductToSurgeQueue(env, userId, item) {
|
||
const queue = await loadSurgeQueue(env, userId);
|
||
|
||
const productPayload = {
|
||
ProductId: item.bigId,
|
||
SkuId: item.targetSkuId,
|
||
AvailabilityId: item.targetAvailabilityId
|
||
};
|
||
|
||
let lastGroup = queue.groups[queue.groups.length - 1];
|
||
|
||
if (!lastGroup || lastGroup.count >= 15) {
|
||
lastGroup = {
|
||
groupIndex: queue.nextGroupIndex,
|
||
count: 0,
|
||
products: {}
|
||
};
|
||
queue.groups.push(lastGroup);
|
||
queue.nextGroupIndex += 1;
|
||
}
|
||
|
||
lastGroup.count += 1;
|
||
lastGroup.products[`product${lastGroup.count}`] = productPayload;
|
||
|
||
await saveSurgeQueue(env, userId, queue);
|
||
}
|
||
|
||
async function popFirstSurgeGroup(env, userId) {
|
||
const queue = await loadSurgeQueue(env, userId);
|
||
|
||
if (!queue.groups.length) {
|
||
return {
|
||
ok: true,
|
||
cleared: false,
|
||
remainingGroups: 0,
|
||
nextGroupIndex: null,
|
||
nextGroupCount: 0
|
||
};
|
||
}
|
||
|
||
const removed = queue.groups.shift();
|
||
await saveSurgeQueue(env, userId, queue);
|
||
|
||
return {
|
||
ok: true,
|
||
cleared: true,
|
||
clearedGroupIndex: removed.groupIndex,
|
||
clearedGroupCount: removed.count,
|
||
remainingGroups: queue.groups.length,
|
||
nextGroupIndex: queue.groups[0]?.groupIndex ?? null,
|
||
nextGroupCount: queue.groups[0]?.count ?? 0
|
||
};
|
||
}
|
||
|
||
// ========================= 页面渲染 =========================
|
||
function buildPagesFromState(state, resolvedLinks, surgeQueue) {
|
||
const items = Array.isArray(state.items) ? state.items : [];
|
||
const rate = state.lastRate;
|
||
|
||
let page1 = '';
|
||
let page2 = '';
|
||
let page3 = '';
|
||
let firstGroupJsonObj = {};
|
||
let hasMultipleSurgeGroups = false;
|
||
|
||
if (items.length > 0) {
|
||
page1 += '<b>🎮 游戏比价及代购信息</b>\n\n';
|
||
if (rate) {
|
||
page1 += `💱 最近一次汇率: 1 NGN ≈ ${Number(rate).toFixed(6)} CNY\n\n`;
|
||
}
|
||
|
||
let copyableText = '';
|
||
let totalCurrentPriceNGN = 0;
|
||
|
||
items.forEach((info, idx) => {
|
||
const displayIndex = idx + 1;
|
||
|
||
copyableText += `游戏（${displayIndex}）\n`;
|
||
copyableText += `名称: ${info.gameName}\n`;
|
||
|
||
copyableText += `原价: ${info.originalPriceStr}`;
|
||
if (info.originalPriceCNY !== 'N/A') copyableText += ` (¥${info.originalPriceCNY})`;
|
||
copyableText += '\n';
|
||
|
||
copyableText += `现价: ${info.currentPriceStr}`;
|
||
if (info.currentPriceCNY !== 'N/A') copyableText += ` (¥${info.currentPriceCNY})`;
|
||
copyableText += '\n';
|
||
|
||
copyableText += '----------------------------------------\n';
|
||
|
||
if (typeof info.currentPriceNum === 'number') {
|
||
totalCurrentPriceNGN += info.currentPriceNum;
|
||
}
|
||
});
|
||
|
||
const cnyPrices = items.map(info => info.currentPriceCNY).filter(p => p !== 'N/A');
|
||
|
||
if (cnyPrices.length > 0) {
|
||
const calc = calculateProxyPrice(cnyPrices);
|
||
copyableText += `📊 游戏总价: NGN ${totalCurrentPriceNGN.toFixed(2)}\n`;
|
||
copyableText += `🛍️ 代购总价: ${calc.expressionStr}`;
|
||
} else {
|
||
copyableText += `📊 游戏总价: NGN ${totalCurrentPriceNGN.toFixed(2)}\n`;
|
||
copyableText += '🛍️ 代购总价: ¥0.00';
|
||
}
|
||
|
||
page1 += `<pre>${escapeHTML(copyableText.trim())}</pre>`;
|
||
} else {
|
||
page1 += '📭 目前还没有成功解析的游戏。';
|
||
}
|
||
|
||
page2 += '<b>📦 Surge 分组队列</b>\n\n';
|
||
|
||
const groups = Array.isArray(surgeQueue?.groups) ? surgeQueue.groups : [];
|
||
|
||
if (groups.length > 0) {
|
||
page2 += `当前剩余 <b>${groups.length}</b> 组待同步\n\n`;
|
||
|
||
groups.forEach((group, idx) => {
|
||
page2 += `<b>【 第 ${group.groupIndex} 组 】</b>共 ${group.count} 个商品\n`;
|
||
page2 += `<pre>${escapeHTML(JSON.stringify(group.products))}</pre>\n\n`;
|
||
|
||
if (idx === 0) {
|
||
firstGroupJsonObj = group.products;
|
||
} else {
|
||
hasMultipleSurgeGroups = true;
|
||
}
|
||
});
|
||
} else {
|
||
page2 += '📭 当前没有待同步的 Surge 数据。';
|
||
}
|
||
|
||
page3 += '<b>🔗 已解析链接记录</b>\n\n';
|
||
|
||
if (resolvedLinks.length > 0) {
|
||
resolvedLinks.forEach((item, idx) => {
|
||
page3 += `游戏（${idx + 1}）\n`;
|
||
page3 += `名称: ${item.gameName || 'Unknown Game'}\n`;
|
||
page3 += `bigId: ${item.bigId || 'N/A'}\n`;
|
||
page3 += `解析链接: ${escapeHTML(item.resolvedUrl || '')}\n`;
|
||
page3 += '----------------------------------------\n';
|
||
});
|
||
} else {
|
||
page3 += '📭 当前还没有已解析的链接记录。';
|
||
}
|
||
|
||
return {
|
||
page1,
|
||
page2,
|
||
page3,
|
||
firstGroupJsonObj,
|
||
hasMultipleSurgeGroups
|
||
};
|
||
}
|
||
|
||
async function persistRenderedPages(env, userId) {
|
||
const state = await loadSuccessState(env, userId);
|
||
const surgeQueue = await loadSurgeQueue(env, userId);
|
||
const resolvedLinks = await loadResolvedLinks(env, userId);
|
||
const pages = buildPagesFromState(state, resolvedLinks, surgeQueue);
|
||
|
||
await env.LINKS_KV.put(getPagesKey(userId), JSON.stringify({
|
||
page_1: pages.page1,
|
||
page_2: pages.page2,
|
||
page_3: pages.page3
|
||
}));
|
||
|
||
return pages;
|
||
}
|
||
|
||
async function showQuotePage(env, chatId, userId, messageId = null) {
|
||
const pages = await persistRenderedPages(env, userId);
|
||
|
||
if (messageId) {
|
||
try {
|
||
await editTelegramMessage(
|
||
chatId,
|
||
messageId,
|
||
pages.page1,
|
||
getPaginationKeyboard('page_1')
|
||
);
|
||
return;
|
||
} catch (_) {}
|
||
}
|
||
|
||
await sendTelegramMessage(
|
||
chatId,
|
||
pages.page1,
|
||
getPaginationKeyboard('page_1')
|
||
);
|
||
}
|
||
|
||
// ========================= 单链接解析 =========================
|
||
async function processSingleXboxLink(startUrl, currentRate) {
|
||
const urlObj = new URL(startUrl);
|
||
urlObj.searchParams.set('r', 'en-us');
|
||
const safeFetchUrl = urlObj.toString();
|
||
|
||
const redirectResponse = await fetchWithTimeout(
|
||
safeFetchUrl,
|
||
{ redirect: 'follow' },
|
||
FETCH_TIMEOUT_MS
|
||
);
|
||
|
||
const finalUrl = redirectResponse.url;
|
||
|
||
try {
|
||
redirectResponse.body?.cancel();
|
||
} catch (_) {}
|
||
|
||
const idMatch = finalUrl.match(/\/([a-zA-Z0-9]{12})(?:[\/?#]|$)/);
|
||
|
||
if (!idMatch) {
|
||
throw new Error('无法提取 bigId');
|
||
}
|
||
|
||
const bigId = idMatch[1];
|
||
const apiUrl = `https://displaycatalog.mp.microsoft.com/v7.0/products?bigIds=${bigId}&market=NG&languages=en-ng&MS-CV=DUMMY.1`;
|
||
|
||
const apiResponse = await fetchWithTimeout(apiUrl, {}, FETCH_TIMEOUT_MS);
|
||
if (!apiResponse.ok) {
|
||
throw new Error(`微软接口请求失败: ${apiResponse.status}`);
|
||
}
|
||
|
||
const data = await apiResponse.json();
|
||
if (!data.Products || data.Products.length === 0) {
|
||
throw new Error('Products 为空');
|
||
}
|
||
|
||
const product = data.Products[0];
|
||
const gameName = product.LocalizedProperties?.[0]?.ProductTitle || 'Unknown Game';
|
||
|
||
let targetSkuId = '';
|
||
let targetAvailabilityId = '';
|
||
let originalPriceStr = 'N/A';
|
||
let currentPriceStr = 'N/A';
|
||
let originalPriceNum = null;
|
||
let currentPriceNum = null;
|
||
|
||
for (const skuObj of product.DisplaySkuAvailabilities || []) {
|
||
if (skuObj.Sku && skuObj.Sku.SkuType === 'full') {
|
||
for (const avail of skuObj.Availabilities || []) {
|
||
if (avail.Actions && avail.Actions.includes('Purchase')) {
|
||
targetSkuId = skuObj.Sku.SkuId;
|
||
targetAvailabilityId = avail.AvailabilityId;
|
||
|
||
if (avail.OrderManagementData?.Price) {
|
||
const priceData = avail.OrderManagementData.Price;
|
||
const currency = priceData.CurrencyCode;
|
||
originalPriceNum = priceData.MSRP;
|
||
currentPriceNum = priceData.ListPrice;
|
||
|
||
originalPriceStr = `${currency} ${originalPriceNum}`;
|
||
currentPriceStr = `${currency} ${currentPriceNum}`;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (targetAvailabilityId) break;
|
||
}
|
||
|
||
if (!targetAvailabilityId) {
|
||
throw new Error('没有找到可购买的 SKU / Availability');
|
||
}
|
||
|
||
return {
|
||
sourceUrl: startUrl,
|
||
resolvedUrl: finalUrl,
|
||
bigId,
|
||
gameName,
|
||
targetSkuId,
|
||
targetAvailabilityId,
|
||
originalPriceStr,
|
||
currentPriceStr,
|
||
originalPriceNum,
|
||
currentPriceNum,
|
||
originalPriceCNY: originalPriceNum !== null ? (originalPriceNum * currentRate).toFixed(2) : 'N/A',
|
||
currentPriceCNY: currentPriceNum !== null ? (currentPriceNum * currentRate).toFixed(2) : 'N/A'
|
||
};
|
||
}
|
||
|
||
// ========================= 运行主逻辑 =========================
|
||
|
||
// ★ 新增：构建"继续"按钮键盘
|
||
function getContinueKeyboard() {
|
||
return {
|
||
inline_keyboard: [
|
||
[{ text: '▶️ 继续抓取', callback_data: 'action_run' }]
|
||
]
|
||
};
|
||
}
|
||
|
||
// ★ 修改：finalizeRun 增加 batchSuccess / batchFail 参数
|
||
async function finalizeRun(
|
||
env, chatId, userId, runId, progressMessageId,
|
||
total, processed, reason = 'done',
|
||
batchSuccess = 0, batchFail = 0
|
||
) {
|
||
if (!(await isRunActive(env, userId, runId))) {
|
||
return;
|
||
}
|
||
|
||
// ★ 核心改动：'done' 分支根据剩余队列决定显示内容
|
||
if (reason === 'done') {
|
||
const pendingAfter = await loadPendingQueue(env, userId);
|
||
const state = await loadSuccessState(env, userId);
|
||
|
||
await env.LINKS_KV.delete(getRunLockKey(userId));
|
||
await clearRunMeta(env, userId);
|
||
|
||
if (pendingAfter.length > 0) {
|
||
// 队列还有内容 → 只显示本批摘要 + 继续按钮
|
||
const summaryText =
|
||
`✅ <b>本批执行完成</b>\n\n` +
|
||
`成功: <b>${batchSuccess}</b> 个\n` +
|
||
`失败: <b>${batchFail}</b> 个（已保留在队列中）\n\n` +
|
||
`累计解析: <b>${state.items.length}</b> 个\n` +
|
||
`队列剩余: <b>${pendingAfter.length}</b> 个`;
|
||
|
||
if (progressMessageId) {
|
||
try {
|
||
await editTelegramMessage(chatId, progressMessageId, summaryText, getContinueKeyboard());
|
||
return;
|
||
} catch (_) {}
|
||
}
|
||
await sendTelegramMessage(chatId, summaryText, getContinueKeyboard());
|
||
} else {
|
||
// 队列已清空 → 显示完整报价/Surge/链接页
|
||
await showQuotePage(env, chatId, userId, progressMessageId);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
if (reason === 'error_rate') {
|
||
const finalText =
|
||
`❌ <b>任务终止</b>\n\n` +
|
||
`获取汇率失败，已停止执行。\n` +
|
||
`当前待处理仍保留在队列中。`;
|
||
|
||
if (progressMessageId) {
|
||
try {
|
||
await editTelegramMessage(chatId, progressMessageId, finalText, getPaginationKeyboard('page_1'));
|
||
} catch (_) {
|
||
await sendTelegramMessage(chatId, finalText, getPaginationKeyboard('page_1'));
|
||
}
|
||
} else {
|
||
await sendTelegramMessage(chatId, finalText, getPaginationKeyboard('page_1'));
|
||
}
|
||
|
||
await env.LINKS_KV.delete(getRunLockKey(userId));
|
||
await clearRunMeta(env, userId);
|
||
return;
|
||
}
|
||
|
||
if (reason === 'force_stopped') {
|
||
await showQuotePage(env, chatId, userId, progressMessageId);
|
||
await env.LINKS_KV.delete(getRunLockKey(userId));
|
||
await clearRunMeta(env, userId);
|
||
return;
|
||
}
|
||
|
||
// 兜底（理论上不会走到这里）
|
||
const pendingQueue = await loadPendingQueue(env, userId);
|
||
const state = await loadSuccessState(env, userId);
|
||
const bar = makeProgressBar(processed, total, 10);
|
||
|
||
const fallbackText =
|
||
`✅ <b>本轮执行完成</b>\n\n` +
|
||
`${bar}\n` +
|
||
`<b>${processed}/${total}</b>\n\n` +
|
||
`当前待处理: <b>${pendingQueue.length}</b> 个\n` +
|
||
`累计成功解析: <b>${state.items.length}</b> 个`;
|
||
|
||
if (progressMessageId) {
|
||
try {
|
||
await editTelegramMessage(chatId, progressMessageId, fallbackText, getPaginationKeyboard('page_1'));
|
||
} catch (_) {
|
||
await sendTelegramMessage(chatId, fallbackText, getPaginationKeyboard('page_1'));
|
||
}
|
||
} else {
|
||
await sendTelegramMessage(chatId, fallbackText, getPaginationKeyboard('page_1'));
|
||
}
|
||
|
||
await env.LINKS_KV.delete(getRunLockKey(userId));
|
||
await clearRunMeta(env, userId);
|
||
}
|
||
|
||
async function runQueueTask(env, chatId, userId, runId, progressMessageId, targets) {
|
||
const total = targets.length;
|
||
let processed = 0;
|
||
|
||
try {
|
||
const rate = await getRealTimeExchangeRate();
|
||
|
||
if (!(await isRunActive(env, userId, runId))) {
|
||
return;
|
||
}
|
||
|
||
const state = await loadSuccessState(env, userId);
|
||
state.lastRate = rate;
|
||
await saveSuccessState(env, userId, state);
|
||
await persistRenderedPages(env, userId);
|
||
|
||
const pendingBefore = await loadPendingQueue(env, userId);
|
||
|
||
if (progressMessageId) {
|
||
try {
|
||
await editTelegramMessage(
|
||
chatId,
|
||
progressMessageId,
|
||
buildProgressText(
|
||
total,
|
||
0,
|
||
pendingBefore.length,
|
||
rate,
|
||
`本批处理中: <b>${targets.length}</b> 个`
|
||
)
|
||
);
|
||
} catch (_) {}
|
||
}
|
||
|
||
const batchPromise = Promise.allSettled(
|
||
targets.map(url => processSingleXboxLink(url, rate))
|
||
);
|
||
|
||
const raceResult = await Promise.race([
|
||
batchPromise,
|
||
new Promise(resolve => setTimeout(() => resolve('__BATCH_TIMEOUT__'), BATCH_TIMEOUT_MS))
|
||
]);
|
||
|
||
if (raceResult === '__BATCH_TIMEOUT__') {
|
||
const stopped = await forceStopRunInternal(env, userId, runId);
|
||
|
||
if (stopped) {
|
||
await showQuotePage(env, chatId, userId, progressMessageId);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
const results = raceResult;
|
||
|
||
if (!(await isRunActive(env, userId, runId))) {
|
||
return;
|
||
}
|
||
|
||
let batchSuccess = 0;
|
||
let batchFail = 0;
|
||
|
||
for (let i = 0; i < targets.length; i++) {
|
||
if (!(await isRunActive(env, userId, runId))) {
|
||
return;
|
||
}
|
||
|
||
const sourceUrl = targets[i];
|
||
const result = results[i];
|
||
|
||
if (result.status === 'fulfilled') {
|
||
const item = result.value;
|
||
|
||
const freshState = await loadSuccessState(env, userId);
|
||
const exists = freshState.items.some(x => x.sourceUrl === sourceUrl);
|
||
|
||
if (!exists) {
|
||
freshState.items.push(item);
|
||
freshState.lastRate = rate;
|
||
await saveSuccessState(env, userId, freshState);
|
||
|
||
if (!(await isRunActive(env, userId, runId))) {
|
||
return;
|
||
}
|
||
|
||
await appendProductToSurgeQueue(env, userId, item);
|
||
await appendResolvedLink(env, userId, {
|
||
sourceUrl: item.sourceUrl,
|
||
resolvedUrl: item.resolvedUrl,
|
||
bigId: item.bigId,
|
||
gameName: item.gameName
|
||
});
|
||
}
|
||
|
||
if (!(await isRunActive(env, userId, runId))) {
|
||
return;
|
||
}
|
||
|
||
// 成功：从待处理队列中移除
|
||
const latestPending = await loadPendingQueue(env, userId);
|
||
const newPending = latestPending.filter(x => x !== sourceUrl);
|
||
await savePendingQueue(env, userId, newPending);
|
||
|
||
batchSuccess++;
|
||
} else {
|
||
// ★ 失败：URL 保留在待处理队列中（未移除），计入失败数
|
||
batchFail++;
|
||
}
|
||
}
|
||
|
||
if (!(await isRunActive(env, userId, runId))) {
|
||
return;
|
||
}
|
||
|
||
processed = targets.length;
|
||
|
||
const latestMeta = await loadRunMeta(env, userId);
|
||
if (latestMeta && latestMeta.runId === runId) {
|
||
latestMeta.processed = processed;
|
||
await saveRunMeta(env, userId, latestMeta);
|
||
}
|
||
|
||
await persistRenderedPages(env, userId);
|
||
|
||
const pendingAfter = await loadPendingQueue(env, userId);
|
||
|
||
if (progressMessageId) {
|
||
try {
|
||
await editTelegramMessage(
|
||
chatId,
|
||
progressMessageId,
|
||
buildProgressText(
|
||
total,
|
||
processed,
|
||
pendingAfter.length,
|
||
rate,
|
||
`本批完成: <b>${targets.length}</b> 个\n成功: <b>${batchSuccess}</b> 个\n失败: <b>${batchFail}</b> 个`
|
||
)
|
||
);
|
||
} catch (_) {}
|
||
}
|
||
|
||
// ★ 将 batchSuccess / batchFail 传入 finalizeRun
|
||
await finalizeRun(
|
||
env, chatId, userId, runId, progressMessageId,
|
||
total, processed, 'done',
|
||
batchSuccess, batchFail
|
||
);
|
||
} catch (error) {
|
||
if (String(error?.message || '').includes('汇率')) {
|
||
await finalizeRun(env, chatId, userId, runId, progressMessageId, total, processed, 'error_rate');
|
||
return;
|
||
}
|
||
|
||
if (await isRunActive(env, userId, runId)) {
|
||
await sendTelegramMessage(
|
||
chatId,
|
||
`❌ <b>执行异常</b>\n\n${escapeHTML(error?.message || '未知错误')}\n\n已完成的数据不会丢失。`
|
||
);
|
||
|
||
await env.LINKS_KV.delete(getRunLockKey(userId));
|
||
await clearRunMeta(env, userId);
|
||
}
|
||
}
|
||
}
|
||
|
||
export default {
|
||
async fetch(request, env, ctx) {
|
||
const requestUrl = new URL(request.url);
|
||
|
||
// ================= GET：syncxbox.com / Surge 前端读取当前组 =================
|
||
if (request.method === 'GET') {
|
||
if (requestUrl.searchParams.get('token') === VIEW_TOKEN) {
|
||
const headers = {
|
||
'Content-Type': 'application/json',
|
||
'Access-Control-Allow-Origin': '*'
|
||
};
|
||
|
||
if (requestUrl.searchParams.get('action') === 'clear') {
|
||
const result = await popFirstSurgeGroup(env, ALLOWED_USER_ID);
|
||
return new Response(JSON.stringify(result), {
|
||
status: 200,
|
||
headers
|
||
});
|
||
}
|
||
|
||
const queue = await loadSurgeQueue(env, ALLOWED_USER_ID);
|
||
|
||
if (!queue.groups.length) {
|
||
return new Response(JSON.stringify({
|
||
ok: true,
|
||
currentGroupIndex: null,
|
||
currentGroupCount: 0,
|
||
remainingGroups: 0,
|
||
remainingAfterCurrent: 0,
|
||
currentGroup: {}
|
||
}), {
|
||
status: 200,
|
||
headers
|
||
});
|
||
}
|
||
|
||
const current = queue.groups[0];
|
||
|
||
return new Response(JSON.stringify({
|
||
ok: true,
|
||
currentGroupIndex: current.groupIndex,
|
||
currentGroupCount: current.count,
|
||
remainingGroups: queue.groups.length,
|
||
remainingAfterCurrent: Math.max(queue.groups.length - 1, 0),
|
||
currentGroup: current.products
|
||
}), {
|
||
status: 200,
|
||
headers
|
||
});
|
||
}
|
||
|
||
return new Response('Xbox Bot is running.', { status: 200 });
|
||
}
|
||
|
||
// ================= Telegram webhook =================
|
||
try {
|
||
const payload = await request.json();
|
||
|
||
let chatId, userId, text;
|
||
let cbId = null;
|
||
let callbackMessageId = null;
|
||
|
||
if (payload.callback_query) {
|
||
chatId = payload.callback_query.message.chat.id;
|
||
userId = payload.callback_query.from.id;
|
||
text = payload.callback_query.data;
|
||
cbId = payload.callback_query.id;
|
||
callbackMessageId = payload.callback_query.message.message_id;
|
||
|
||
if (text.startsWith('page_')) {
|
||
const storedResult = await env.LINKS_KV.get(getPagesKey(userId));
|
||
|
||
if (storedResult) {
|
||
const pagesData = JSON.parse(storedResult);
|
||
|
||
if (pagesData[text]) {
|
||
try {
|
||
await editTelegramMessage(
|
||
chatId,
|
||
callbackMessageId,
|
||
pagesData[text],
|
||
getPaginationKeyboard(text)
|
||
);
|
||
await answerCallbackQuery(cbId);
|
||
} catch (_) {
|
||
await answerCallbackQuery(cbId);
|
||
}
|
||
} else {
|
||
await answerCallbackQuery(cbId, '⚠️ 页面不存在');
|
||
}
|
||
} else {
|
||
await answerCallbackQuery(cbId, '⚠️ 页面数据为空');
|
||
}
|
||
|
||
return new Response('OK', { status: 200 });
|
||
}
|
||
|
||
if (text === 'action_run') {
|
||
await answerCallbackQuery(cbId);
|
||
// ★ action_run 回调直接复用 /run 逻辑，text 已经是 'action_run'，下面统一处理
|
||
}
|
||
} else if (payload.message && payload.message.text) {
|
||
chatId = payload.message.chat.id;
|
||
userId = payload.message.from.id;
|
||
text = payload.message.text.trim();
|
||
} else {
|
||
return new Response('OK', { status: 200 });
|
||
}
|
||
|
||
if (userId !== ALLOWED_USER_ID) {
|
||
return new Response('Unauthorized', { status: 200 });
|
||
}
|
||
|
||
const queueKey = getQueueKey(userId);
|
||
const lockKey = getRunLockKey(userId);
|
||
const stateKey = getStateKey(userId);
|
||
const pagesKey = getPagesKey(userId);
|
||
const runMetaKey = getRunMetaKey(userId);
|
||
const surgeQueueKey = getSurgeQueueKey(userId);
|
||
const resolvedLinksKey = getResolvedLinksKey(userId);
|
||
|
||
if (text.toLowerCase() === '/view_product') {
|
||
const queue = await loadSurgeQueue(env, userId);
|
||
|
||
if (!queue.groups.length) {
|
||
await sendTelegramMessage(chatId, '📭 当前没有待同步的 Surge 分组数据。');
|
||
} else {
|
||
const current = queue.groups[0];
|
||
let msg =
|
||
`📦 <b>当前待同步的 Surge 分组队列</b>\n\n` +
|
||
`剩余组数: <b>${queue.groups.length}</b>\n` +
|
||
`当前组编号: <b>${current.groupIndex}</b>\n` +
|
||
`当前组商品数: <b>${current.count}</b>\n\n` +
|
||
`<pre>${escapeHTML(JSON.stringify(current.products))}</pre>`;
|
||
|
||
await sendTelegramMessage(chatId, msg);
|
||
}
|
||
|
||
return new Response('OK', { status: 200 });
|
||
}
|
||
|
||
if (text.toLowerCase().startsWith('/update_product')) {
|
||
const jsonStr = text.substring('/update_product'.length).trim();
|
||
|
||
if (!jsonStr) {
|
||
await sendTelegramMessage(chatId, '⚠️ 请在命令后附带合法的 JSON 字符串。');
|
||
return new Response('OK', { status: 200 });
|
||
}
|
||
|
||
try {
|
||
const parsedData = JSON.parse(jsonStr);
|
||
const keys = Object.keys(parsedData || {});
|
||
const queue = {
|
||
nextGroupIndex: 2,
|
||
groups: keys.length > 0 ? [{
|
||
groupIndex: 1,
|
||
count: keys.length,
|
||
products: parsedData
|
||
}] : []
|
||
};
|
||
await saveSurgeQueue(env, userId, queue);
|
||
await persistRenderedPages(env, userId);
|
||
await sendTelegramMessage(chatId, '✅ 成功覆盖更新 Surge 分组数据！');
|
||
} catch (e) {
|
||
await sendTelegramMessage(chatId, `❌ JSON 格式错误：\n${escapeHTML(e.message)}`);
|
||
}
|
||
|
||
return new Response('OK', { status: 200 });
|
||
}
|
||
|
||
if (text.toLowerCase() === '/view_list') {
|
||
const urls = await loadPendingQueue(env, userId);
|
||
|
||
if (urls.length === 0) {
|
||
await sendTelegramMessage(chatId, '📭 当前待处理链接队列为空。');
|
||
} else {
|
||
let listText = `📋 <b>当前待处理链接（共 ${urls.length} 个）：</b>\n\n`;
|
||
urls.forEach((url, index) => {
|
||
listText += `${index + 1}. ${escapeHTML(url)}\n`;
|
||
});
|
||
await sendTelegramMessage(chatId, listText);
|
||
}
|
||
return new Response('OK', { status: 200 });
|
||
}
|
||
|
||
if (text.toLowerCase() === '/force_stop') {
|
||
const meta = await loadRunMeta(env, userId);
|
||
|
||
if (!meta) {
|
||
await sendTelegramMessage(chatId, 'ℹ️ 当前没有正在执行的任务。');
|
||
return new Response('OK', { status: 200 });
|
||
}
|
||
|
||
await env.LINKS_KV.delete(lockKey);
|
||
await clearRunMeta(env, userId);
|
||
await showQuotePage(env, chatId, userId, meta.progressMessageId);
|
||
|
||
return new Response('OK', { status: 200 });
|
||
}
|
||
|
||
if (text.toLowerCase() === '/clear') {
|
||
await env.LINKS_KV.delete(queueKey);
|
||
await env.LINKS_KV.delete(stateKey);
|
||
await env.LINKS_KV.delete(pagesKey);
|
||
await env.LINKS_KV.delete(runMetaKey);
|
||
await env.LINKS_KV.delete(surgeQueueKey);
|
||
await env.LINKS_KV.delete(resolvedLinksKey);
|
||
await env.LINKS_KV.delete('LATEST_XBOX_LIST');
|
||
await env.LINKS_KV.delete(lockKey);
|
||
|
||
await sendTelegramMessage(
|
||
chatId,
|
||
'🗑️ 已彻底清空<b>待处理队列</b>、<b>成功解析记录</b>、<b>已解析链接记录</b>、<b>分页缓存</b>与云端 <b>Product 数据</b>。'
|
||
);
|
||
return new Response('OK', { status: 200 });
|
||
}
|
||
|
||
// ★ /run 和 action_run 回调统一处理
|
||
if (text.toLowerCase() === '/run' || text === 'action_run') {
|
||
let isRunning = await env.LINKS_KV.get(lockKey);
|
||
|
||
if (isRunning) {
|
||
const meta = await loadRunMeta(env, userId);
|
||
if (!meta) {
|
||
await env.LINKS_KV.delete(lockKey);
|
||
isRunning = null;
|
||
}
|
||
}
|
||
|
||
if (isRunning) {
|
||
await sendTelegramMessage(chatId, '⏳ 当前已有任务正在执行中，请先 /force_stop。');
|
||
return new Response('OK', { status: 200 });
|
||
}
|
||
|
||
const pendingQueue = await loadPendingQueue(env, userId);
|
||
if (pendingQueue.length === 0) {
|
||
await sendTelegramMessage(chatId, '📭 链接队列为空，请先发送游戏链接。');
|
||
return new Response('OK', { status: 200 });
|
||
}
|
||
|
||
// 每次只处理前 5 个
|
||
const targets = pendingQueue.slice(0, MINI_CONCURRENCY);
|
||
const runTotal = targets.length;
|
||
|
||
const initText =
|
||
`⏳ <b>准备开始抓取</b>\n\n` +
|
||
`本次处理: <b>${runTotal}</b> 个\n` +
|
||
`队列剩余总数: <b>${pendingQueue.length}</b> 个\n\n` +
|
||
`${makeProgressBar(0, runTotal)}\n<b>0/${runTotal}</b>`;
|
||
|
||
// ★ 如果来自回调按钮，直接编辑那条消息；否则发新消息
|
||
let progressMessageId;
|
||
if (callbackMessageId) {
|
||
await editTelegramMessage(chatId, callbackMessageId, initText, null);
|
||
progressMessageId = callbackMessageId;
|
||
} else {
|
||
const startMsg = await sendTelegramMessage(chatId, initText);
|
||
progressMessageId = startMsg?.result?.message_id || null;
|
||
}
|
||
|
||
const runId = crypto.randomUUID();
|
||
|
||
await env.LINKS_KV.put(lockKey, runId, { expirationTtl: RUN_LOCK_TTL });
|
||
await saveRunMeta(env, userId, {
|
||
runId,
|
||
chatId,
|
||
progressMessageId,
|
||
total: runTotal,
|
||
processed: 0,
|
||
startedAt: new Date().toISOString()
|
||
});
|
||
|
||
ctx.waitUntil(runQueueTask(env, chatId, userId, runId, progressMessageId, targets));
|
||
return new Response('OK', { status: 200 });
|
||
}
|
||
|
||
const urlRegex = /(https?:\/\/[^\s]+)/g;
|
||
const newUrls = text.match(urlRegex);
|
||
|
||
if (newUrls && newUrls.length > 0) {
|
||
const pendingQueue = await loadPendingQueue(env, userId);
|
||
const state = await loadSuccessState(env, userId);
|
||
const resolvedLinks = await loadResolvedLinks(env, userId);
|
||
|
||
const successUrlSet = new Set((state.items || []).map(x => x.sourceUrl));
|
||
const resolvedUrlSet = new Set((resolvedLinks || []).map(x => x.sourceUrl));
|
||
const pendingSet = new Set(pendingQueue);
|
||
|
||
const reallyNewUrls = newUrls.filter(
|
||
url => !successUrlSet.has(url) && !resolvedUrlSet.has(url) && !pendingSet.has(url)
|
||
);
|
||
|
||
const mergedQueue = [...pendingQueue, ...reallyNewUrls];
|
||
await savePendingQueue(env, userId, mergedQueue);
|
||
await persistRenderedPages(env, userId);
|
||
|
||
const inlineKeyboard = {
|
||
inline_keyboard: [
|
||
[
|
||
{ text: '🚀 一键抓取执行', callback_data: 'action_run' }
|
||
]
|
||
]
|
||
};
|
||
|
||
if (reallyNewUrls.length > 0) {
|
||
await sendTelegramMessage(
|
||
chatId,
|
||
`✅ 成功记录 <b>${reallyNewUrls.length}</b> 个新链接。\n\n当前待处理队列共 <b>${mergedQueue.length}</b> 个。`,
|
||
inlineKeyboard
|
||
);
|
||
} else {
|
||
await sendTelegramMessage(
|
||
chatId,
|
||
`ℹ️ 这些链接已经在待处理队列中，或之前已成功解析过。\n\n当前待处理队列共 <b>${mergedQueue.length}</b> 个。`,
|
||
inlineKeyboard
|
||
);
|
||
}
|
||
}
|
||
|
||
return new Response('OK', { status: 200 });
|
||
} catch (_) {
|
||
return new Response('Error', { status: 200 });
|
||
}
|
||
}
|
||
};
|