1564 lines
44 KiB
JavaScript
1564 lines
44 KiB
JavaScript
// @ts-check
|
|
|
|
import { createTaskEvent } from "../../repositories/task-event-repo.js";
|
|
import { getOrderById } from "../../repositories/order-repo.js";
|
|
import { updateTask } from "../../repositories/task-repo.js";
|
|
import { buildClaimUrl, createTaskClaimToken } from "../claim/claim-service.js";
|
|
import { normalizeProductName } from "../order/product-match-service.js";
|
|
import {
|
|
getCloudtentaclesSourceConfig,
|
|
getCloudtentaclesSourceByKey,
|
|
} from "../platforms/cloudtentacles/source-config-service.js";
|
|
import {
|
|
getCloudtentaclesSessionState,
|
|
getCloudtentaclesSessionStateByKey,
|
|
} from "../platforms/cloudtentacles/session-state-service.js";
|
|
import {
|
|
buyCloudtentaclesSku,
|
|
getCloudtentaclesAsset,
|
|
listCloudtentaclesSku,
|
|
useCloudtentaclesSku,
|
|
} from "../platforms/cloudtentacles/catalog-service.js";
|
|
import { getCloudtentaclesKnapsack } from "../platforms/cloudtentacles/knapsack-service.js";
|
|
import {
|
|
appointCloudtentaclesVirtualNumber,
|
|
backCloudtentaclesVirtualNumber,
|
|
fetchCloudtentaclesVirtualNumberCode,
|
|
generateCloudtentaclesLoginCode,
|
|
getCloudtentaclesBindInfo,
|
|
getCloudtentaclesBindUrl,
|
|
probeCloudtentaclesBindUrl,
|
|
verifyCloudtentaclesLoginCode,
|
|
} from "../platforms/cloudtentacles/virtual-number-service.js";
|
|
import { resolveCloudtentaclesConfig } from "../platforms/cloudtentacles/shared.js";
|
|
import { consumeKuaishouEticket } from "../platforms/kuaishou-eticket/consume-service.js";
|
|
import {
|
|
getKuaishouEticketSourceConfig,
|
|
resolveKuaishouEticketShopConfig,
|
|
} from "../platforms/kuaishou-eticket/source-config-service.js";
|
|
import {
|
|
notifyKuaishouCloudAssetNotEnough,
|
|
notifyKuaishouCloudBindUrlRefreshFailed,
|
|
notifyKuaishouCloudConsumeFailed,
|
|
} from "../notification/domain-notifications.js";
|
|
import { createHttpError } from "../../utils/http.js";
|
|
import { nowIso } from "../../utils/time.js";
|
|
|
|
const KUAISHOU_CLOUD_FIXED_VN_KEY = "1";
|
|
|
|
export function isKuaishouCloudTask(task) {
|
|
return String(task?.executor_key || "").trim() === "kuaishou_ct_assisted";
|
|
}
|
|
|
|
export function normalizeKuaishouCloudFlow(value) {
|
|
const source = value && typeof value === "object" ? value : {};
|
|
const binding =
|
|
source.binding && typeof source.binding === "object" ? source.binding : {};
|
|
const role =
|
|
source.role && typeof source.role === "object" ? source.role : {};
|
|
const purchase =
|
|
source.purchase && typeof source.purchase === "object"
|
|
? source.purchase
|
|
: {};
|
|
const dispatch =
|
|
source.dispatch && typeof source.dispatch === "object"
|
|
? source.dispatch
|
|
: {};
|
|
const returnNumber =
|
|
source.returnNumber && typeof source.returnNumber === "object"
|
|
? source.returnNumber
|
|
: {};
|
|
const consume =
|
|
source.consume && typeof source.consume === "object" ? source.consume : {};
|
|
const ticket =
|
|
source.ticket && typeof source.ticket === "object" ? source.ticket : {};
|
|
|
|
const roleName = String(role.name || binding.roleName || "").trim();
|
|
const roleId = String(role.rid || binding.roleId || "").trim();
|
|
const bindPreparedAt = binding.bindPreparedAt || null;
|
|
const bindExpiresAt =
|
|
binding.bindExpiresAt ||
|
|
resolveKuaishouCloudBindUrlExpiresAt(bindPreparedAt);
|
|
|
|
return {
|
|
...source,
|
|
configId: String(source.configId || "").trim(),
|
|
internalSkuCode: String(source.internalSkuCode || "").trim(),
|
|
internalSkuName: String(source.internalSkuName || "").trim(),
|
|
ticket: {
|
|
code: String(ticket.code || "").trim(),
|
|
status: String(ticket.status || "pending").trim() || "pending",
|
|
capturedAt: ticket.capturedAt || null,
|
|
capturedBy: ticket.capturedBy || null,
|
|
verifiedAt: ticket.verifiedAt || null,
|
|
oid: String(ticket.oid || "").trim(),
|
|
formToken: String(ticket.formToken || "").trim(),
|
|
leftCount: Number(ticket.leftCount || 0) || 0,
|
|
goodsTitle: String(ticket.goodsTitle || "").trim(),
|
|
},
|
|
binding: {
|
|
prepareStatus:
|
|
String(binding.prepareStatus || "pending").trim() || "pending",
|
|
cloudSourceKey:
|
|
String(binding.cloudSourceKey || "default").trim() || "default",
|
|
skuId: Number(binding.skuId || 0) || 0,
|
|
skuName: String(binding.skuName || "").trim(),
|
|
vnKey:
|
|
String(binding.vnKey || KUAISHOU_CLOUD_FIXED_VN_KEY).trim() ||
|
|
KUAISHOU_CLOUD_FIXED_VN_KEY,
|
|
vnId: Number(binding.vnId || 0) || 0,
|
|
vnPhone: String(binding.vnPhone || "").trim(),
|
|
bindUrl: String(binding.bindUrl || "").trim(),
|
|
bindPreparedAt,
|
|
bindExpiresAt,
|
|
bindProbeAt: binding.bindProbeAt || null,
|
|
bindProbeStatus: String(binding.bindProbeStatus || "").trim(),
|
|
bindProbeMessage: String(binding.bindProbeMessage || "").trim(),
|
|
roleName,
|
|
roleId,
|
|
},
|
|
role: {
|
|
status:
|
|
String(
|
|
role.status || (roleName || roleId ? "ready" : "pending")
|
|
).trim() || "pending",
|
|
name: roleName,
|
|
rid: roleId,
|
|
refreshedAt: role.refreshedAt || null,
|
|
errorMessage: String(role.errorMessage || "").trim(),
|
|
rawInfo:
|
|
role.rawInfo && typeof role.rawInfo === "object" ? role.rawInfo : null,
|
|
},
|
|
purchase: {
|
|
autoBuyEnabled: purchase.autoBuyEnabled !== false,
|
|
minAssetReserve: Number(purchase.minAssetReserve || 0) || 0,
|
|
usedKnapsack: purchase.usedKnapsack === true,
|
|
purchaseTriggered: purchase.purchaseTriggered === true,
|
|
assetBefore: Number(purchase.assetBefore || 0) || 0,
|
|
assetAfter: Number(purchase.assetAfter || 0) || 0,
|
|
purchaseAt: purchase.purchaseAt || null,
|
|
},
|
|
dispatch: {
|
|
status: String(dispatch.status || "pending").trim() || "pending",
|
|
dispatchAt: dispatch.dispatchAt || null,
|
|
dispatchBy: dispatch.dispatchBy || null,
|
|
sendType: Number(dispatch.sendType || 0) || 0,
|
|
note: String(dispatch.note || "").trim(),
|
|
},
|
|
returnNumber: {
|
|
status: String(returnNumber.status || "pending").trim() || "pending",
|
|
returnedAt: returnNumber.returnedAt || null,
|
|
returnedBy: returnNumber.returnedBy || null,
|
|
autoReturnEnabled: returnNumber.autoReturnEnabled === true,
|
|
},
|
|
consume: {
|
|
status: String(consume.status || "pending").trim() || "pending",
|
|
shopId: String(consume.shopId || "").trim(),
|
|
shopName: String(consume.shopName || "").trim(),
|
|
autoConsumeEnabled: consume.autoConsumeEnabled === true,
|
|
consumedAt: consume.consumedAt || null,
|
|
errorMessage: String(consume.errorMessage || "").trim(),
|
|
},
|
|
notes: String(source.notes || "").trim(),
|
|
};
|
|
}
|
|
|
|
export function normalizeKuaishouCloudRoleInfo(value) {
|
|
const rawInfo = value && typeof value === "object" ? value : null;
|
|
const nestedBindInfo =
|
|
rawInfo?.sBindInfo && typeof rawInfo.sBindInfo === "object"
|
|
? rawInfo.sBindInfo
|
|
: null;
|
|
const source = nestedBindInfo || rawInfo;
|
|
|
|
return {
|
|
name: String(
|
|
source?.name ||
|
|
source?.roleName ||
|
|
source?.nickname ||
|
|
source?.sRoleName ||
|
|
""
|
|
).trim(),
|
|
rid: String(
|
|
source?.rid ||
|
|
source?.roleId ||
|
|
source?.uid ||
|
|
source?.sRoleId ||
|
|
source?.sUserId ||
|
|
""
|
|
).trim(),
|
|
rawInfo,
|
|
};
|
|
}
|
|
|
|
export function resolvePersistedCloudtentaclesContext(sourceKey = "default") {
|
|
const source =
|
|
getCloudtentaclesSourceByKey(sourceKey) || getCloudtentaclesSourceConfig();
|
|
const session =
|
|
getCloudtentaclesSessionStateByKey(sourceKey) ||
|
|
getCloudtentaclesSessionState();
|
|
const token = String(session.token || "").trim();
|
|
|
|
if (!token) {
|
|
throw createHttpError(
|
|
"当前 cloudtentacles 没有可用 token，请先到平台配置完成登录校验",
|
|
{
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_missing_cloud_token",
|
|
}
|
|
);
|
|
}
|
|
|
|
return {
|
|
baseUrl:
|
|
String(session.baseUrl || source.baseUrl || "").trim() ||
|
|
"https://123.207.217.176",
|
|
token,
|
|
deviceId: String(session.deviceId || source.deviceId || "-").trim() || "-",
|
|
deviceType: Number(session.deviceType ?? source.deviceType ?? 0),
|
|
};
|
|
}
|
|
|
|
export async function ensureTaskClaimLink(task) {
|
|
const tokenStatus = String(task?.primary_claim_token_status || "").trim();
|
|
const token = String(
|
|
task?.primary_claim_token || task?.claim_token || ""
|
|
).trim();
|
|
const expiredAt = getTaskClaimExpiresAt(task);
|
|
|
|
if (tokenStatus === "active" && token && !isClaimExpired(expiredAt)) {
|
|
return {
|
|
token,
|
|
expiredAt,
|
|
claimUrl: buildClaimUrl(token),
|
|
};
|
|
}
|
|
|
|
const claimToken = await createTaskClaimToken(task.id);
|
|
return {
|
|
token: claimToken.token,
|
|
expiredAt: claimToken.expired_at,
|
|
claimUrl: claimToken.claimUrl,
|
|
};
|
|
}
|
|
|
|
export async function prepareKuaishouCloudFulfillmentTask(task, options = {}) {
|
|
if (!isKuaishouCloudTask(task)) {
|
|
throw createHttpError("当前任务不是快手 Cloud 履约任务", {
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_task_invalid",
|
|
});
|
|
}
|
|
|
|
const now = nowIso();
|
|
const actor = normalizeActor(options.actor);
|
|
const force = options.force === true;
|
|
const taskContext = parseTaskContext(task);
|
|
const flow = normalizeKuaishouCloudFlow(taskContext.kuaishouCloudFulfillment);
|
|
const claimLinkState = await ensureTaskClaimLink(task);
|
|
|
|
if (
|
|
!force &&
|
|
flow.binding.prepareStatus === "ready" &&
|
|
flow.binding.vnId > 0 &&
|
|
flow.binding.vnPhone &&
|
|
flow.binding.bindUrl
|
|
) {
|
|
if (!isKuaishouCloudBindUrlFresh(flow)) {
|
|
return refreshKuaishouCloudTaskBindUrl(task, {
|
|
source: options.source || "system_refresh_expired_bind_url",
|
|
actor,
|
|
claimLinkState,
|
|
});
|
|
}
|
|
|
|
let readyTask = task;
|
|
|
|
if (String(task.task_status || "").trim() !== "waiting_binding") {
|
|
readyTask = await updateTask(task.id, {
|
|
task_status: "waiting_binding",
|
|
claim_token: claimLinkState.token || task.claim_token || "",
|
|
claim_expires_at:
|
|
claimLinkState.expiredAt || getTaskClaimExpiresAt(task),
|
|
updated_at: now,
|
|
});
|
|
}
|
|
|
|
return {
|
|
task: readyTask,
|
|
claimUrl: claimLinkState.claimUrl,
|
|
token: claimLinkState.token,
|
|
flow,
|
|
};
|
|
}
|
|
|
|
const cloudContext = resolvePersistedCloudtentaclesContext(
|
|
flow.binding.cloudSourceKey || "default"
|
|
);
|
|
const [knapsack, skuList] = await Promise.all([
|
|
getCloudtentaclesKnapsack(cloudContext),
|
|
listCloudtentaclesSku(cloudContext),
|
|
]);
|
|
const resolvedBinding = resolveKuaishouCloudBindingResources(flow, {
|
|
skuItems: Array.isArray(skuList.items) ? skuList.items : [],
|
|
knapsackItems: Array.isArray(knapsack.items) ? knapsack.items : [],
|
|
});
|
|
const vnKeyCandidates = resolveKuaishouCloudVnKeyCandidates({
|
|
flow,
|
|
binding: resolvedBinding,
|
|
});
|
|
|
|
if (!resolvedBinding.skuId || vnKeyCandidates.length === 0) {
|
|
throw createHttpError("当前任务缺少可用 cloud 资源，无法自动准备绑定", {
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_missing_binding_config",
|
|
});
|
|
}
|
|
|
|
const flowWithResolvedBinding = {
|
|
...flow,
|
|
binding: {
|
|
...flow.binding,
|
|
skuId: resolvedBinding.skuId,
|
|
skuName: resolvedBinding.skuName,
|
|
vnKey: KUAISHOU_CLOUD_FIXED_VN_KEY,
|
|
},
|
|
};
|
|
|
|
const knapsackItem = resolvedBinding.knapsackItem;
|
|
let usedKnapsack = Number(knapsackItem?.count || 0) > 0;
|
|
let purchaseTriggered = false;
|
|
let assetBefore = 0;
|
|
let assetAfter = 0;
|
|
|
|
if (!usedKnapsack) {
|
|
if (!flowWithResolvedBinding.purchase.autoBuyEnabled) {
|
|
throw createHttpError("背包中没有现成库存，且当前配置未开启自动购买", {
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_auto_buy_disabled",
|
|
});
|
|
}
|
|
|
|
const asset = await getCloudtentaclesAsset(cloudContext);
|
|
const targetSku = resolvedBinding.skuItem;
|
|
|
|
if (!targetSku) {
|
|
throw createHttpError(
|
|
`cloudtentacles 未找到 SKU ${flowWithResolvedBinding.binding.skuId}`,
|
|
{
|
|
statusCode: 404,
|
|
errorCode: "kuaishou_cloud_sku_not_found",
|
|
}
|
|
);
|
|
}
|
|
|
|
assetBefore = Number(asset.asset || 0) || 0;
|
|
const targetPrice = Number(targetSku.price || 0) || 0;
|
|
const requiredAsset =
|
|
targetPrice + flowWithResolvedBinding.purchase.minAssetReserve;
|
|
if (assetBefore < requiredAsset) {
|
|
await notifyKuaishouCloudAssetNotEnough({
|
|
task,
|
|
flow: flowWithResolvedBinding,
|
|
assetBefore,
|
|
requiredAsset,
|
|
skuName: targetSku.name,
|
|
});
|
|
throw createHttpError(
|
|
`余额不足，当前 ${assetBefore}，至少需要 ${requiredAsset}`,
|
|
{
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_asset_not_enough",
|
|
}
|
|
);
|
|
}
|
|
|
|
await buyCloudtentaclesSku({
|
|
...cloudContext,
|
|
id: flowWithResolvedBinding.binding.skuId,
|
|
count: 1,
|
|
});
|
|
purchaseTriggered = true;
|
|
|
|
const assetResult = await getCloudtentaclesAsset(cloudContext);
|
|
assetAfter = Number(assetResult.asset || 0) || 0;
|
|
}
|
|
|
|
const preparedBinding = await prepareKuaishouCloudBindResourceWithFallback({
|
|
cloudContext,
|
|
vnKeyCandidates,
|
|
});
|
|
|
|
const nextContext = {
|
|
...taskContext,
|
|
kuaishouCloudFulfillment: {
|
|
...flowWithResolvedBinding,
|
|
binding: {
|
|
...flowWithResolvedBinding.binding,
|
|
vnKey: preparedBinding.vnKey,
|
|
prepareStatus: "ready",
|
|
vnId: preparedBinding.vnId,
|
|
vnPhone: preparedBinding.vnPhone,
|
|
bindUrl: preparedBinding.bindUrl,
|
|
bindPreparedAt: now,
|
|
bindExpiresAt: resolveKuaishouCloudBindUrlExpiresAt(now),
|
|
bindProbeAt: null,
|
|
bindProbeStatus: "pending",
|
|
bindProbeMessage: "",
|
|
roleName: "",
|
|
roleId: "",
|
|
},
|
|
role: {
|
|
status: "pending",
|
|
name: "",
|
|
rid: "",
|
|
refreshedAt: null,
|
|
errorMessage: "",
|
|
rawInfo: null,
|
|
},
|
|
purchase: {
|
|
...flowWithResolvedBinding.purchase,
|
|
usedKnapsack,
|
|
purchaseTriggered,
|
|
assetBefore,
|
|
assetAfter,
|
|
purchaseAt: purchaseTriggered
|
|
? now
|
|
: flowWithResolvedBinding.purchase.purchaseAt,
|
|
},
|
|
},
|
|
};
|
|
|
|
const updatedTask = await updateTask(task.id, {
|
|
task_status: "waiting_binding",
|
|
inventory_status: "not_required",
|
|
user_action_status: "pending_claim",
|
|
claim_token: claimLinkState.token || task.claim_token || "",
|
|
claim_expires_at: claimLinkState.expiredAt || getTaskClaimExpiresAt(task),
|
|
role_id: "",
|
|
role_name: "",
|
|
last_error: "",
|
|
context_json: JSON.stringify(nextContext),
|
|
updated_at: now,
|
|
});
|
|
|
|
await createTaskEvent(
|
|
task.id,
|
|
"kuaishou_cloud_binding_prepared",
|
|
{
|
|
source: String(options.source || "system").trim() || "system",
|
|
skuId: flowWithResolvedBinding.binding.skuId,
|
|
skuName: flowWithResolvedBinding.binding.skuName,
|
|
vnKey: preparedBinding.vnKey,
|
|
vnId: preparedBinding.vnId,
|
|
vnPhoneMasked: maskPhone(preparedBinding.vnPhone),
|
|
purchaseTriggered,
|
|
usedKnapsack,
|
|
resolvedByName: resolvedBinding.resolvedByName,
|
|
actor,
|
|
},
|
|
now
|
|
);
|
|
|
|
return {
|
|
task: updatedTask,
|
|
claimUrl: claimLinkState.claimUrl,
|
|
token: claimLinkState.token,
|
|
flow: normalizeKuaishouCloudFlow(nextContext.kuaishouCloudFulfillment),
|
|
};
|
|
}
|
|
|
|
export async function refreshKuaishouCloudTaskBindUrl(task, options = {}) {
|
|
if (!isKuaishouCloudTask(task)) {
|
|
throw createHttpError("当前任务不是快手 Cloud 履约任务", {
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_task_invalid",
|
|
});
|
|
}
|
|
|
|
const now = nowIso();
|
|
const actor = normalizeActor(options.actor);
|
|
const taskContext = parseTaskContext(task);
|
|
const flow = normalizeKuaishouCloudFlow(taskContext.kuaishouCloudFulfillment);
|
|
|
|
if (!flow.binding.vnId || !flow.binding.vnKey) {
|
|
throw createHttpError("当前任务缺少可刷新绑定链接的虚拟号信息", {
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_missing_bind_url_context",
|
|
});
|
|
}
|
|
|
|
const cloudContext = resolvePersistedCloudtentaclesContext(
|
|
flow.binding.cloudSourceKey || "default"
|
|
);
|
|
const oldVnKey = flow.binding.vnKey;
|
|
const oldVnId = flow.binding.vnId;
|
|
const oldVnPhone = flow.binding.vnPhone;
|
|
|
|
await backCloudtentaclesVirtualNumber({
|
|
...cloudContext,
|
|
key: oldVnKey,
|
|
id: oldVnId,
|
|
});
|
|
|
|
await createTaskEvent(
|
|
task.id,
|
|
"kuaishou_cloud_expired_bind_number_returned",
|
|
{
|
|
source: String(options.source || "system").trim() || "system",
|
|
vnKey: oldVnKey,
|
|
vnId: oldVnId,
|
|
vnPhoneMasked: maskPhone(oldVnPhone),
|
|
actor,
|
|
},
|
|
now
|
|
);
|
|
|
|
let preparedBinding;
|
|
try {
|
|
preparedBinding = await prepareKuaishouCloudBindResourceWithFallback({
|
|
cloudContext,
|
|
vnKeyCandidates: resolveKuaishouCloudVnKeyCandidates({
|
|
flow,
|
|
binding: flow.binding,
|
|
}),
|
|
});
|
|
|
|
if (!String(preparedBinding.bindUrl || "").trim()) {
|
|
throw createHttpError("cloudtentacles 未返回新的绑定链接", {
|
|
statusCode: 502,
|
|
errorCode: "kuaishou_cloud_empty_bind_url",
|
|
});
|
|
}
|
|
} catch (error) {
|
|
const failedTask = await markKuaishouCloudBindUrlRefreshFailed(task, {
|
|
taskContext,
|
|
flow,
|
|
now,
|
|
actor,
|
|
error,
|
|
});
|
|
|
|
return {
|
|
task: failedTask,
|
|
claimUrl: buildClaimUrl(
|
|
String(task.primary_claim_token || task.claim_token || "")
|
|
),
|
|
token: String(task.primary_claim_token || task.claim_token || ""),
|
|
flow: normalizeKuaishouCloudFlow(
|
|
parseTaskContext(failedTask).kuaishouCloudFulfillment
|
|
),
|
|
};
|
|
}
|
|
|
|
const nextContext = {
|
|
...taskContext,
|
|
kuaishouCloudFulfillment: {
|
|
...flow,
|
|
binding: {
|
|
...flow.binding,
|
|
prepareStatus: "ready",
|
|
vnKey: preparedBinding.vnKey,
|
|
vnId: preparedBinding.vnId,
|
|
vnPhone: preparedBinding.vnPhone,
|
|
bindUrl: preparedBinding.bindUrl,
|
|
bindPreparedAt: now,
|
|
bindExpiresAt: resolveKuaishouCloudBindUrlExpiresAt(now),
|
|
bindProbeAt: null,
|
|
bindProbeStatus: "pending",
|
|
bindProbeMessage: "",
|
|
roleName:
|
|
String(task.task_status || "").trim() === "role_confirmed"
|
|
? flow.binding.roleName
|
|
: "",
|
|
roleId:
|
|
String(task.task_status || "").trim() === "role_confirmed"
|
|
? flow.binding.roleId
|
|
: "",
|
|
},
|
|
role:
|
|
String(task.task_status || "").trim() === "role_confirmed"
|
|
? flow.role
|
|
: {
|
|
status: "pending",
|
|
name: "",
|
|
rid: "",
|
|
refreshedAt: null,
|
|
errorMessage: "",
|
|
rawInfo: null,
|
|
},
|
|
},
|
|
};
|
|
|
|
const claimLinkState =
|
|
options.claimLinkState || (await ensureTaskClaimLink(task));
|
|
const updatedTask = await updateTask(task.id, {
|
|
task_status:
|
|
String(task.task_status || "").trim() === "role_confirmed"
|
|
? task.task_status
|
|
: "waiting_binding",
|
|
claim_token: claimLinkState.token || task.claim_token || "",
|
|
claim_expires_at: claimLinkState.expiredAt || getTaskClaimExpiresAt(task),
|
|
role_id:
|
|
String(task.task_status || "").trim() === "role_confirmed"
|
|
? task.role_id
|
|
: "",
|
|
role_name:
|
|
String(task.task_status || "").trim() === "role_confirmed"
|
|
? task.role_name
|
|
: "",
|
|
last_error: "",
|
|
context_json: JSON.stringify(nextContext),
|
|
updated_at: now,
|
|
});
|
|
|
|
await createTaskEvent(
|
|
task.id,
|
|
"kuaishou_cloud_bind_url_refreshed",
|
|
{
|
|
source: String(options.source || "system").trim() || "system",
|
|
oldVnId,
|
|
oldVnPhoneMasked: maskPhone(oldVnPhone),
|
|
vnKey: preparedBinding.vnKey,
|
|
vnId: preparedBinding.vnId,
|
|
vnPhoneMasked: maskPhone(preparedBinding.vnPhone),
|
|
actor,
|
|
},
|
|
now
|
|
);
|
|
|
|
return {
|
|
task: updatedTask,
|
|
claimUrl: claimLinkState.claimUrl,
|
|
token: claimLinkState.token,
|
|
flow: normalizeKuaishouCloudFlow(nextContext.kuaishouCloudFulfillment),
|
|
};
|
|
}
|
|
|
|
export async function probeKuaishouCloudTaskBindUrl(task, options = {}) {
|
|
if (!isKuaishouCloudTask(task)) {
|
|
throw createHttpError("当前任务不是快手 Cloud 履约任务", {
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_task_invalid",
|
|
});
|
|
}
|
|
|
|
const now = nowIso();
|
|
const taskContext = parseTaskContext(task);
|
|
const flow = normalizeKuaishouCloudFlow(taskContext.kuaishouCloudFulfillment);
|
|
|
|
if (!flow.binding.bindUrl) {
|
|
return {
|
|
task,
|
|
flow,
|
|
probe: null,
|
|
};
|
|
}
|
|
|
|
const probeIntervalMs =
|
|
Number(resolveCloudtentaclesConfig().bindUrlProbeIntervalSeconds || 30) *
|
|
1000;
|
|
if (
|
|
!options.force &&
|
|
flow.binding.bindProbeAt &&
|
|
Date.now() - Date.parse(flow.binding.bindProbeAt) < probeIntervalMs
|
|
) {
|
|
return {
|
|
task,
|
|
flow,
|
|
probe: null,
|
|
};
|
|
}
|
|
|
|
const probe = await probeCloudtentaclesBindUrl({
|
|
bindUrl: flow.binding.bindUrl,
|
|
});
|
|
|
|
if (probe.expired || !isKuaishouCloudBindUrlFresh(flow)) {
|
|
const refreshed = await refreshKuaishouCloudTaskBindUrl(task, {
|
|
source: options.source || "claim_page_bind_url_expired",
|
|
actor: options.actor || { source: "system" },
|
|
});
|
|
return {
|
|
...refreshed,
|
|
probe,
|
|
};
|
|
}
|
|
|
|
const probeRoleInfo = normalizeKuaishouCloudRoleInfo(probe.roleInfo);
|
|
const hasRoleInfo = Boolean(probeRoleInfo.name || probeRoleInfo.rid);
|
|
const nextContext = {
|
|
...taskContext,
|
|
kuaishouCloudFulfillment: {
|
|
...flow,
|
|
binding: {
|
|
...flow.binding,
|
|
bindProbeAt: now,
|
|
bindProbeStatus: probe.valid ? "valid" : "invalid",
|
|
bindProbeMessage: String(probe.message || probe.reason || "").trim(),
|
|
roleName: hasRoleInfo ? probeRoleInfo.name : flow.binding.roleName,
|
|
roleId: hasRoleInfo ? probeRoleInfo.rid : flow.binding.roleId,
|
|
},
|
|
role: {
|
|
...flow.role,
|
|
status: hasRoleInfo ? "ready" : flow.role.status,
|
|
name: hasRoleInfo ? probeRoleInfo.name : flow.role.name,
|
|
rid: hasRoleInfo ? probeRoleInfo.rid : flow.role.rid,
|
|
refreshedAt: hasRoleInfo ? now : flow.role.refreshedAt,
|
|
errorMessage: hasRoleInfo ? "" : flow.role.errorMessage,
|
|
rawInfo: hasRoleInfo ? probeRoleInfo.rawInfo : flow.role.rawInfo,
|
|
},
|
|
},
|
|
};
|
|
|
|
const updatedTask = await updateTask(task.id, {
|
|
role_id: hasRoleInfo ? probeRoleInfo.rid : task.role_id,
|
|
role_name: hasRoleInfo ? probeRoleInfo.name : task.role_name,
|
|
context_json: JSON.stringify(nextContext),
|
|
updated_at: now,
|
|
});
|
|
|
|
return {
|
|
task: updatedTask,
|
|
flow: normalizeKuaishouCloudFlow(nextContext.kuaishouCloudFulfillment),
|
|
probe,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {any} task
|
|
* @param {{ taskContext?: any, flow?: any, now?: string, actor?: any, error?: unknown }} [input]
|
|
*/
|
|
async function markKuaishouCloudBindUrlRefreshFailed(
|
|
task,
|
|
{ taskContext, flow, now, actor, error } = {}
|
|
) {
|
|
const errorMessage =
|
|
error instanceof Error
|
|
? error.message
|
|
: String(error || "新绑定链接准备失败");
|
|
const nextContext = {
|
|
...taskContext,
|
|
kuaishouCloudFulfillment: {
|
|
...flow,
|
|
binding: {
|
|
...flow.binding,
|
|
prepareStatus: "pending",
|
|
vnId: 0,
|
|
vnPhone: "",
|
|
bindUrl: "",
|
|
bindPreparedAt: null,
|
|
bindExpiresAt: null,
|
|
bindProbeAt: now,
|
|
bindProbeStatus: "refresh_failed",
|
|
bindProbeMessage: errorMessage,
|
|
roleName: "",
|
|
roleId: "",
|
|
},
|
|
role: {
|
|
status: "pending",
|
|
name: "",
|
|
rid: "",
|
|
refreshedAt: now,
|
|
errorMessage:
|
|
"绑定链接已过期，旧号码已退还，新链接准备失败，请稍后刷新或联系客服处理",
|
|
rawInfo: null,
|
|
},
|
|
},
|
|
};
|
|
|
|
const updatedTask = await updateTask(task.id, {
|
|
task_status: "pending_binding_prepare",
|
|
role_id: "",
|
|
role_name: "",
|
|
last_error: `绑定链接过期，旧号码已退还，新链接准备失败：${errorMessage}`,
|
|
context_json: JSON.stringify(nextContext),
|
|
updated_at: now,
|
|
});
|
|
|
|
await createTaskEvent(
|
|
task.id,
|
|
"kuaishou_cloud_bind_url_refresh_failed",
|
|
{
|
|
source: "system_refresh_expired_bind_url",
|
|
errorMessage,
|
|
actor,
|
|
},
|
|
now
|
|
);
|
|
|
|
await notifyKuaishouCloudBindUrlRefreshFailed({
|
|
task: updatedTask,
|
|
errorMessage,
|
|
});
|
|
|
|
return updatedTask;
|
|
}
|
|
|
|
export async function refreshKuaishouCloudTaskRoleInfo(task, options = {}) {
|
|
if (!isKuaishouCloudTask(task)) {
|
|
throw createHttpError("当前任务不是快手 Cloud 履约任务", {
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_task_invalid",
|
|
});
|
|
}
|
|
|
|
const now = nowIso();
|
|
const actor = normalizeActor(options.actor);
|
|
const taskContext = parseTaskContext(task);
|
|
const flow = normalizeKuaishouCloudFlow(taskContext.kuaishouCloudFulfillment);
|
|
|
|
if (!flow.binding.vnId || !flow.binding.vnKey) {
|
|
throw createHttpError(
|
|
"当前任务还没有可查询的绑定角色信息，请先准备绑定资源",
|
|
{
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_missing_bind_info_context",
|
|
}
|
|
);
|
|
}
|
|
|
|
if (flow.binding.bindUrl) {
|
|
const probed = await probeKuaishouCloudTaskBindUrl(task, {
|
|
source: options.source || "system_role_refresh_bind_url_probe",
|
|
actor,
|
|
force: options.forceProbe === true,
|
|
});
|
|
const probedFlow = normalizeKuaishouCloudFlow(
|
|
parseTaskContext(probed.task).kuaishouCloudFulfillment
|
|
);
|
|
if (probed.probe?.expired) {
|
|
return {
|
|
task: probed.task,
|
|
roleInfo: normalizeKuaishouCloudRoleInfo(null),
|
|
flow: probedFlow,
|
|
};
|
|
}
|
|
|
|
if (
|
|
(probed.probe === null || probed.probe?.valid) &&
|
|
(probedFlow.binding.roleName || probedFlow.binding.roleId)
|
|
) {
|
|
return {
|
|
task: probed.task,
|
|
roleInfo: {
|
|
name: probedFlow.binding.roleName,
|
|
rid: probedFlow.binding.roleId,
|
|
rawInfo: probedFlow.role.rawInfo,
|
|
},
|
|
flow: probedFlow,
|
|
};
|
|
}
|
|
}
|
|
|
|
const cloudContext = resolvePersistedCloudtentaclesContext(
|
|
flow.binding.cloudSourceKey || "default"
|
|
);
|
|
const bindInfoResult = await getCloudtentaclesBindInfo({
|
|
...cloudContext,
|
|
key: flow.binding.vnKey,
|
|
id: flow.binding.vnId,
|
|
});
|
|
|
|
const bindInfo = normalizeKuaishouCloudRoleInfo(bindInfoResult.bindInfo);
|
|
const hasRoleInfo = Boolean(bindInfo.name || bindInfo.rid);
|
|
const nextContext = {
|
|
...taskContext,
|
|
kuaishouCloudFulfillment: {
|
|
...flow,
|
|
binding: {
|
|
...flow.binding,
|
|
roleName: hasRoleInfo ? bindInfo.name : "",
|
|
roleId: hasRoleInfo ? bindInfo.rid : "",
|
|
},
|
|
role: {
|
|
status: hasRoleInfo ? "ready" : "pending",
|
|
name: hasRoleInfo ? bindInfo.name : "",
|
|
rid: hasRoleInfo ? bindInfo.rid : "",
|
|
refreshedAt: now,
|
|
errorMessage: hasRoleInfo
|
|
? ""
|
|
: "当前还没有查询到角色信息，请完成绑定后稍等片刻再试",
|
|
rawInfo: bindInfo.rawInfo,
|
|
},
|
|
},
|
|
};
|
|
|
|
const updatedTask = await updateTask(task.id, {
|
|
role_id: hasRoleInfo ? bindInfo.rid : "",
|
|
role_name: hasRoleInfo ? bindInfo.name : "",
|
|
context_json: JSON.stringify(nextContext),
|
|
updated_at: now,
|
|
});
|
|
|
|
if (options.recordEvent !== false) {
|
|
await createTaskEvent(
|
|
task.id,
|
|
"kuaishou_cloud_role_info_refreshed",
|
|
{
|
|
source: String(options.source || "system").trim() || "system",
|
|
roleName: bindInfo.name,
|
|
roleId: bindInfo.rid,
|
|
vnId: flow.binding.vnId,
|
|
actor,
|
|
},
|
|
now
|
|
);
|
|
}
|
|
|
|
return {
|
|
task: updatedTask,
|
|
roleInfo: bindInfo,
|
|
flow: normalizeKuaishouCloudFlow(nextContext.kuaishouCloudFulfillment),
|
|
};
|
|
}
|
|
|
|
export async function dispatchKuaishouCloudFulfillmentTask(task, options = {}) {
|
|
if (!isKuaishouCloudTask(task)) {
|
|
throw createHttpError("当前任务不是快手 Cloud 履约任务", {
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_task_invalid",
|
|
});
|
|
}
|
|
|
|
const actor = normalizeActor(options.actor);
|
|
const now = nowIso();
|
|
const taskContext = parseTaskContext(task);
|
|
const flow = normalizeKuaishouCloudFlow(taskContext.kuaishouCloudFulfillment);
|
|
const cloudContext = resolvePersistedCloudtentaclesContext(
|
|
flow.binding.cloudSourceKey || "default"
|
|
);
|
|
|
|
if (!flow.binding.skuId || !flow.binding.vnId || !flow.binding.vnPhone) {
|
|
throw createHttpError(
|
|
"当前任务还没有准备好绑定资源，请先完成绑定资源准备",
|
|
{
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_not_prepared",
|
|
}
|
|
);
|
|
}
|
|
|
|
const ticketCode = String(options.ticketCode || "").trim();
|
|
const persistedTicketCode = String(flow.ticket.code || "").trim();
|
|
if (!persistedTicketCode && !ticketCode) {
|
|
throw createHttpError("客户还没有提交有效核销码，暂时不能继续兑换", {
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_missing_ticket_code",
|
|
});
|
|
}
|
|
|
|
if (
|
|
flow.dispatch.status === "success" &&
|
|
String(task.task_status || "").trim() === "dispatched_pending_return"
|
|
) {
|
|
return { task, flow };
|
|
}
|
|
|
|
const dispatchResult = await useCloudtentaclesSku({
|
|
...cloudContext,
|
|
id: flow.binding.skuId,
|
|
virtualNumberId: flow.binding.vnId,
|
|
phone: flow.binding.vnPhone,
|
|
});
|
|
|
|
const nextContext = {
|
|
...taskContext,
|
|
kuaishouCloudFulfillment: {
|
|
...flow,
|
|
ticket: {
|
|
...flow.ticket,
|
|
code: ticketCode || persistedTicketCode,
|
|
capturedAt: ticketCode ? now : flow.ticket.capturedAt,
|
|
capturedBy: ticketCode && actor ? actor : flow.ticket.capturedBy,
|
|
},
|
|
dispatch: {
|
|
...flow.dispatch,
|
|
status: "success",
|
|
dispatchAt: now,
|
|
dispatchBy: actor,
|
|
sendType: Number(dispatchResult.sendType || 0) || 0,
|
|
note: String(
|
|
dispatchResult.note ||
|
|
dispatchResult.responseMessage ||
|
|
"cloudtentacles 发货成功"
|
|
).trim(),
|
|
},
|
|
},
|
|
};
|
|
|
|
let updatedTask = await updateTask(task.id, {
|
|
task_status: "dispatched_pending_return",
|
|
delivery_status: "delivered",
|
|
result_code: "kuaishou_cloud_dispatched",
|
|
result_message: String(
|
|
dispatchResult.responseMessage ||
|
|
dispatchResult.note ||
|
|
"cloudtentacles 发货成功"
|
|
).trim(),
|
|
user_action_status: "not_required",
|
|
last_error: "",
|
|
context_json: JSON.stringify(nextContext),
|
|
updated_at: now,
|
|
});
|
|
|
|
await createTaskEvent(
|
|
task.id,
|
|
"kuaishou_cloud_dispatched",
|
|
{
|
|
source: String(options.source || "system").trim() || "system",
|
|
ticketCodeMasked: maskCode(ticketCode || persistedTicketCode),
|
|
skuId: flow.binding.skuId,
|
|
vnId: flow.binding.vnId,
|
|
vnPhoneMasked: maskPhone(flow.binding.vnPhone),
|
|
sendType: dispatchResult.sendType,
|
|
note: dispatchResult.note,
|
|
actor,
|
|
},
|
|
now
|
|
);
|
|
|
|
const shouldAutoFinalize =
|
|
options.autoFinalize === true &&
|
|
normalizeKuaishouCloudFlow(nextContext.kuaishouCloudFulfillment)
|
|
.returnNumber.autoReturnEnabled === true;
|
|
|
|
if (shouldAutoFinalize) {
|
|
const finalizeResult = await returnKuaishouCloudFulfillmentTask(
|
|
updatedTask,
|
|
{
|
|
actor,
|
|
source: options.source || "system_auto_finalize",
|
|
}
|
|
);
|
|
updatedTask = finalizeResult.task;
|
|
}
|
|
|
|
return {
|
|
task: updatedTask,
|
|
flow: normalizeKuaishouCloudFlow(
|
|
parseTaskContext(updatedTask).kuaishouCloudFulfillment
|
|
),
|
|
};
|
|
}
|
|
|
|
export async function returnKuaishouCloudFulfillmentTask(task, options = {}) {
|
|
if (!isKuaishouCloudTask(task)) {
|
|
throw createHttpError("当前任务不是快手 Cloud 履约任务", {
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_task_invalid",
|
|
});
|
|
}
|
|
|
|
const actor = normalizeActor(options.actor);
|
|
const now = nowIso();
|
|
const taskContext = parseTaskContext(task);
|
|
const flow = normalizeKuaishouCloudFlow(taskContext.kuaishouCloudFulfillment);
|
|
const cloudContext = resolvePersistedCloudtentaclesContext(
|
|
flow.binding.cloudSourceKey || "default"
|
|
);
|
|
|
|
if (!flow.binding.vnId || !flow.binding.vnKey) {
|
|
throw createHttpError("当前任务缺少可退还的虚拟号信息", {
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_missing_return_context",
|
|
});
|
|
}
|
|
|
|
if (
|
|
flow.returnNumber.status === "success" &&
|
|
["completed", "manual_review"].includes(
|
|
String(task.task_status || "").trim()
|
|
)
|
|
) {
|
|
return { task, flow };
|
|
}
|
|
|
|
await backCloudtentaclesVirtualNumber({
|
|
...cloudContext,
|
|
key: flow.binding.vnKey,
|
|
id: flow.binding.vnId,
|
|
});
|
|
|
|
const order = await getOrderById(task.order_id);
|
|
const ticketCode = String(flow.ticket.code || "").trim();
|
|
const shopId = String(flow.consume.shopId || order?.shop_id || "").trim();
|
|
const shopName = String(
|
|
flow.consume.shopName || order?.shop_name || ""
|
|
).trim();
|
|
const eticketSource = getKuaishouEticketSourceConfig();
|
|
const shopConfig = resolveKuaishouEticketShopConfig({
|
|
shopId,
|
|
shopName,
|
|
});
|
|
|
|
let consumeStatus = "pending";
|
|
let consumeErrorMessage = "";
|
|
let consumedAt = null;
|
|
let nextTaskStatus = "completed";
|
|
let nextResultCode = "kuaishou_cloud_completed";
|
|
let nextResultMessage = "cloudtentacles 发货、退号并完成快手核销";
|
|
|
|
if (!order) {
|
|
consumeStatus = "failed";
|
|
consumeErrorMessage = "任务关联订单不存在，无法执行快手核销";
|
|
} else if (!ticketCode) {
|
|
consumeStatus = "failed";
|
|
consumeErrorMessage = "客户未提交有效核销码，无法执行快手核销";
|
|
} else if (
|
|
!shopConfig ||
|
|
shopConfig.enabled === false ||
|
|
!String(shopConfig.cookie || "").trim()
|
|
) {
|
|
consumeStatus = "failed";
|
|
consumeErrorMessage = "订单对应快手小店缺少可用 Cookie，无法执行快手核销";
|
|
} else {
|
|
try {
|
|
const consumeResult = await consumeKuaishouEticket({
|
|
baseUrl: eticketSource.baseUrl,
|
|
cookie: shopConfig.cookie,
|
|
eTicketId: ticketCode,
|
|
oid: String(flow.ticket.oid || "").trim(),
|
|
formToken: String(flow.ticket.formToken || "").trim(),
|
|
});
|
|
|
|
if (consumeResult.consumed) {
|
|
consumeStatus = "success";
|
|
consumedAt = now;
|
|
} else {
|
|
consumeStatus = "failed";
|
|
consumeErrorMessage = String(
|
|
consumeResult.errorMessage || "快手核销失败"
|
|
).trim();
|
|
}
|
|
} catch (error) {
|
|
consumeStatus = "failed";
|
|
consumeErrorMessage =
|
|
error instanceof Error ? error.message : "快手核销失败";
|
|
}
|
|
}
|
|
|
|
if (consumeStatus !== "success") {
|
|
nextTaskStatus = "manual_review";
|
|
nextResultCode = "kuaishou_cloud_consume_failed";
|
|
nextResultMessage =
|
|
consumeErrorMessage || "号码已退还，但快手核销未完成，请人工处理";
|
|
}
|
|
|
|
const nextContext = {
|
|
...taskContext,
|
|
kuaishouCloudFulfillment: {
|
|
...flow,
|
|
returnNumber: {
|
|
...flow.returnNumber,
|
|
status: "success",
|
|
returnedAt: now,
|
|
returnedBy: actor,
|
|
},
|
|
consume: {
|
|
...flow.consume,
|
|
status: consumeStatus,
|
|
shopId: shopId || flow.consume.shopId,
|
|
shopName,
|
|
autoConsumeEnabled: flow.consume.autoConsumeEnabled === true,
|
|
consumedAt,
|
|
errorMessage: consumeErrorMessage,
|
|
},
|
|
},
|
|
};
|
|
|
|
const updatedTask = await updateTask(task.id, {
|
|
task_status: nextTaskStatus,
|
|
delivery_status: "delivered",
|
|
result_code: nextResultCode,
|
|
result_message: nextResultMessage,
|
|
redeemed_at: consumeStatus === "success" ? now : task.redeemed_at,
|
|
last_error: consumeErrorMessage,
|
|
context_json: JSON.stringify(nextContext),
|
|
updated_at: now,
|
|
});
|
|
|
|
await createTaskEvent(
|
|
task.id,
|
|
"kuaishou_cloud_number_returned",
|
|
{
|
|
source: String(options.source || "system").trim() || "system",
|
|
vnId: flow.binding.vnId,
|
|
vnPhoneMasked: maskPhone(flow.binding.vnPhone),
|
|
actor,
|
|
},
|
|
now
|
|
);
|
|
|
|
await createTaskEvent(
|
|
task.id,
|
|
consumeStatus === "success"
|
|
? "kuaishou_cloud_consumed"
|
|
: "kuaishou_cloud_consume_failed",
|
|
{
|
|
source: String(options.source || "system").trim() || "system",
|
|
ticketCodeMasked: maskCode(ticketCode),
|
|
shopId,
|
|
shopName,
|
|
consumeStatus,
|
|
errorMessage: consumeErrorMessage,
|
|
actor,
|
|
},
|
|
now
|
|
);
|
|
|
|
if (consumeStatus !== "success") {
|
|
await notifyKuaishouCloudConsumeFailed({
|
|
task: updatedTask,
|
|
order,
|
|
ticketCodeMasked: maskCode(ticketCode),
|
|
shopId,
|
|
shopName,
|
|
errorMessage: consumeErrorMessage,
|
|
});
|
|
}
|
|
|
|
return {
|
|
task: updatedTask,
|
|
flow: normalizeKuaishouCloudFlow(
|
|
parseTaskContext(updatedTask).kuaishouCloudFulfillment
|
|
),
|
|
};
|
|
}
|
|
|
|
export function maskPhone(value) {
|
|
const text = String(value || "").trim();
|
|
if (!text) {
|
|
return "";
|
|
}
|
|
|
|
if (text.length <= 7) {
|
|
return `${text.slice(0, 2)}***${text.slice(-2)}`;
|
|
}
|
|
|
|
return `${text.slice(0, 3)}****${text.slice(-4)}`;
|
|
}
|
|
|
|
export function maskCode(value) {
|
|
const text = String(value || "").trim();
|
|
if (!text) {
|
|
return "";
|
|
}
|
|
|
|
if (text.length <= 8) {
|
|
return `${text.slice(0, 2)}***${text.slice(-2)}`;
|
|
}
|
|
|
|
return `${text.slice(0, 4)}****${text.slice(-4)}`;
|
|
}
|
|
|
|
export function resolveKuaishouCloudBindUrlExpiresAt(preparedAt) {
|
|
const preparedTime = Date.parse(String(preparedAt || ""));
|
|
if (!Number.isFinite(preparedTime)) {
|
|
return null;
|
|
}
|
|
|
|
const config = resolveCloudtentaclesConfig();
|
|
const ttlSeconds = Number(config.bindUrlTtlSeconds || 600);
|
|
return new Date(preparedTime + Math.max(1, ttlSeconds) * 1000).toISOString();
|
|
}
|
|
|
|
export function isKuaishouCloudBindUrlFresh(flow, now = new Date()) {
|
|
const normalizedFlow = normalizeKuaishouCloudFlow(flow);
|
|
if (!normalizedFlow.binding.bindUrl) {
|
|
return false;
|
|
}
|
|
|
|
const expiresAt = normalizedFlow.binding.bindExpiresAt;
|
|
if (!expiresAt) {
|
|
return false;
|
|
}
|
|
|
|
const expiresTime = Date.parse(String(expiresAt || ""));
|
|
if (!Number.isFinite(expiresTime)) {
|
|
return false;
|
|
}
|
|
|
|
return expiresTime > now.getTime();
|
|
}
|
|
|
|
function resolveKuaishouCloudBindingResources(
|
|
flow,
|
|
{ skuItems = [], knapsackItems = [] } = {}
|
|
) {
|
|
const normalizedSkuItems = Array.isArray(skuItems)
|
|
? skuItems.filter(isCloudSkuLikeItem)
|
|
: [];
|
|
const normalizedKnapsackItems = Array.isArray(knapsackItems)
|
|
? knapsackItems.filter(isCloudSkuLikeItem)
|
|
: [];
|
|
const currentSkuId = Number(flow?.binding?.skuId || 0) || 0;
|
|
const currentSkuName = String(flow?.binding?.skuName || "").trim();
|
|
const nameCandidates = collectKuaishouCloudNameCandidates(flow);
|
|
|
|
const skuItemById =
|
|
currentSkuId > 0
|
|
? normalizedSkuItems.find(
|
|
(item) => Number(item.id || 0) === currentSkuId
|
|
) || null
|
|
: null;
|
|
const knapsackItemById =
|
|
currentSkuId > 0
|
|
? normalizedKnapsackItems.find(
|
|
(item) => Number(item.id || 0) === currentSkuId
|
|
) || null
|
|
: null;
|
|
|
|
if (skuItemById || knapsackItemById) {
|
|
const matchedItem = skuItemById || knapsackItemById;
|
|
return {
|
|
skuId: Number(matchedItem?.id || 0) || 0,
|
|
skuName: String(currentSkuName || matchedItem?.name || "").trim(),
|
|
vnKey: KUAISHOU_CLOUD_FIXED_VN_KEY,
|
|
skuItem: skuItemById,
|
|
knapsackItem: knapsackItemById,
|
|
resolvedByName: false,
|
|
};
|
|
}
|
|
|
|
const matchedSkuItem = findCloudItemByNames(
|
|
normalizedSkuItems,
|
|
nameCandidates
|
|
);
|
|
const matchedKnapsackItem = findCloudItemByNames(
|
|
normalizedKnapsackItems,
|
|
nameCandidates,
|
|
matchedSkuItem ? Number(matchedSkuItem.id || 0) : 0
|
|
);
|
|
const matchedItem = matchedSkuItem || matchedKnapsackItem;
|
|
|
|
return {
|
|
skuId: Number(matchedItem?.id || 0) || 0,
|
|
skuName: String(currentSkuName || matchedItem?.name || "").trim(),
|
|
vnKey: KUAISHOU_CLOUD_FIXED_VN_KEY,
|
|
skuItem: matchedSkuItem,
|
|
knapsackItem: matchedKnapsackItem,
|
|
resolvedByName: Boolean(matchedItem),
|
|
};
|
|
}
|
|
|
|
function resolveKuaishouCloudVnKeyCandidates(_input = {}) {
|
|
return [KUAISHOU_CLOUD_FIXED_VN_KEY];
|
|
}
|
|
|
|
async function prepareKuaishouCloudBindResourceWithFallback(input = {}) {
|
|
const { cloudContext = {}, vnKeyCandidates = [] } = input;
|
|
const candidates = Array.isArray(vnKeyCandidates) ? vnKeyCandidates : [];
|
|
let lastError = null;
|
|
|
|
for (const vnKey of candidates) {
|
|
let vnId = 0;
|
|
let vnPhone = "";
|
|
|
|
try {
|
|
const appointed = await appointCloudtentaclesVirtualNumber({
|
|
...cloudContext,
|
|
key: vnKey,
|
|
});
|
|
vnId = Number(appointed.item?.id || 0);
|
|
vnPhone = String(appointed.item?.phone || "").trim();
|
|
|
|
if (!vnId || !vnPhone) {
|
|
throw createHttpError("申请虚拟号成功但返回数据不完整", {
|
|
statusCode: 502,
|
|
errorCode: "kuaishou_cloud_invalid_vn",
|
|
});
|
|
}
|
|
|
|
await generateCloudtentaclesLoginCode({
|
|
...cloudContext,
|
|
key: vnKey,
|
|
id: vnId,
|
|
});
|
|
|
|
const fetchedCode = await fetchCloudtentaclesVirtualNumberCode({
|
|
...cloudContext,
|
|
key: vnKey,
|
|
phone: vnPhone,
|
|
});
|
|
|
|
await verifyCloudtentaclesLoginCode({
|
|
...cloudContext,
|
|
key: vnKey,
|
|
id: vnId,
|
|
code: fetchedCode.code,
|
|
});
|
|
|
|
const bindUrlResult = await getCloudtentaclesBindUrl({
|
|
...cloudContext,
|
|
key: vnKey,
|
|
id: vnId,
|
|
});
|
|
|
|
return {
|
|
vnKey,
|
|
vnId,
|
|
vnPhone,
|
|
bindUrl: String(bindUrlResult.bindUrl || "").trim(),
|
|
};
|
|
} catch (error) {
|
|
lastError = error;
|
|
|
|
if (vnId > 0) {
|
|
try {
|
|
await backCloudtentaclesVirtualNumber({
|
|
...cloudContext,
|
|
key: vnKey,
|
|
id: vnId,
|
|
});
|
|
} catch {
|
|
// 退号失败保留主错误
|
|
}
|
|
}
|
|
|
|
if (!isRecoverableKuaishouCloudVnKeyError(error)) {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
|
|
throw (
|
|
lastError ||
|
|
createHttpError("没有找到可用的 VN Key", {
|
|
statusCode: 409,
|
|
errorCode: "kuaishou_cloud_missing_binding_config",
|
|
})
|
|
);
|
|
}
|
|
|
|
function collectKuaishouCloudNameCandidates(flow) {
|
|
return Array.from(
|
|
new Set(
|
|
[
|
|
String(flow?.binding?.skuName || "").trim(),
|
|
String(flow?.internalSkuName || "").trim(),
|
|
String(flow?.internalSkuCode || "").trim(),
|
|
].filter(Boolean)
|
|
)
|
|
);
|
|
}
|
|
|
|
function findCloudItemByNames(items, nameCandidates, preferredId = 0) {
|
|
const normalizedItems = Array.isArray(items) ? items : [];
|
|
const normalizedNames = nameCandidates
|
|
.map((item) => ({
|
|
raw: String(item || "").trim(),
|
|
normalized: normalizeProductName(item),
|
|
}))
|
|
.filter((item) => item.raw && item.normalized);
|
|
|
|
if (normalizedNames.length === 0 || normalizedItems.length === 0) {
|
|
return preferredId > 0
|
|
? normalizedItems.find((item) => Number(item.id || 0) === preferredId) ||
|
|
null
|
|
: null;
|
|
}
|
|
|
|
if (preferredId > 0) {
|
|
const preferred =
|
|
normalizedItems.find((item) => Number(item.id || 0) === preferredId) ||
|
|
null;
|
|
if (preferred) {
|
|
return preferred;
|
|
}
|
|
}
|
|
|
|
const exactMatches = normalizedItems.filter((item) => {
|
|
const itemName = normalizeProductName(item.name);
|
|
return normalizedNames.some(
|
|
(candidate) => candidate.normalized === itemName
|
|
);
|
|
});
|
|
if (exactMatches.length > 0) {
|
|
return exactMatches[0];
|
|
}
|
|
|
|
const partialMatches = normalizedItems.filter((item) => {
|
|
const itemName = normalizeProductName(item.name);
|
|
return normalizedNames.some(
|
|
(candidate) =>
|
|
itemName.includes(candidate.normalized) ||
|
|
candidate.normalized.includes(itemName)
|
|
);
|
|
});
|
|
if (partialMatches.length > 0) {
|
|
return partialMatches.sort(
|
|
(left, right) =>
|
|
String(left.name || "").length - String(right.name || "").length
|
|
)[0];
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function isCloudSkuLikeItem(item) {
|
|
return Boolean(item) && typeof item === "object" && Number(item.id || 0) > 0;
|
|
}
|
|
|
|
function isRecoverableKuaishouCloudVnKeyError(error) {
|
|
const errorCode = String(error?.errorCode || error?.code || "").trim();
|
|
const errorMessage = String(error?.message || "").trim();
|
|
return (
|
|
errorCode === "cloudtentacles_vn_bind_url_failed" &&
|
|
errorMessage.includes("不支持的游戏类型")
|
|
);
|
|
}
|
|
|
|
function normalizeActor(actor) {
|
|
if (!actor || typeof actor !== "object") {
|
|
return null;
|
|
}
|
|
|
|
const source = String(actor.source || "").trim();
|
|
const userId = Number(actor.userId || 0) || 0;
|
|
const username = String(actor.username || "").trim();
|
|
const role = String(actor.role || "").trim();
|
|
|
|
if (!source && !userId && !username && !role) {
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
source,
|
|
userId,
|
|
username,
|
|
role,
|
|
};
|
|
}
|
|
|
|
function parseTaskContext(task) {
|
|
const value = task?.context_json;
|
|
|
|
if (!value) {
|
|
return {};
|
|
}
|
|
|
|
if (typeof value === "object") {
|
|
return value;
|
|
}
|
|
|
|
try {
|
|
return JSON.parse(String(value || "{}"));
|
|
} catch {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
function getTaskClaimExpiresAt(task) {
|
|
return task?.claim_expires_at || task?.primary_claim_expires_at || null;
|
|
}
|
|
|
|
function isClaimExpired(expiredAt) {
|
|
if (!expiredAt) {
|
|
return false;
|
|
}
|
|
|
|
const timestamp = new Date(expiredAt).getTime();
|
|
return Number.isFinite(timestamp) && timestamp <= Date.now();
|
|
}
|