Isulew
1008 lines
38 KiB
JavaScript
1008 lines
38 KiB
JavaScript
// phone-sms/providers/nexsms.js — NexSMS 接码平台适配层
|
||
(function attachNexSmsProvider(root, factory) {
|
||
root.PhoneSmsNexSmsProvider = factory();
|
||
})(typeof self !== 'undefined' ? self : globalThis, function createNexSmsProviderModule() {
|
||
const PROVIDER_ID = 'nexsms';
|
||
const DEFAULT_BASE_URL = 'https://api.nexsms.net';
|
||
const DEFAULT_SERVICE_CODE = 'ot';
|
||
const DEFAULT_SERVICE_LABEL = 'OpenAI';
|
||
const DEFAULT_COUNTRY_ID = 1;
|
||
const DEFAULT_COUNTRY_LABEL = 'Country #1';
|
||
const DEFAULT_REQUEST_TIMEOUT_MS = 20000;
|
||
const DEFAULT_ACQUIRE_RETRY_ROUNDS = 3;
|
||
const DEFAULT_ACQUIRE_RETRY_DELAY_MS = 2000;
|
||
const DEFAULT_POLL_TIMEOUT_MS = 180000;
|
||
const DEFAULT_POLL_INTERVAL_MS = 5000;
|
||
const MAX_PRICE_CANDIDATES = 8;
|
||
const PHONE_CODE_TIMEOUT_ERROR_PREFIX = 'PHONE_CODE_TIMEOUT::';
|
||
const ACQUIRE_PRIORITY_COUNTRY = 'country';
|
||
const ACQUIRE_PRIORITY_PRICE = 'price';
|
||
const ACQUIRE_PRIORITY_PRICE_HIGH = 'price_high';
|
||
|
||
function normalizeBaseUrl(value = '') {
|
||
const trimmed = String(value || '').trim() || DEFAULT_BASE_URL;
|
||
try {
|
||
return new URL(trimmed).toString().replace(/\/+$/, '');
|
||
} catch {
|
||
return DEFAULT_BASE_URL;
|
||
}
|
||
}
|
||
|
||
function normalizeText(value = '', fallback = '') {
|
||
return String(value || '').trim() || fallback;
|
||
}
|
||
|
||
function normalizeNexSmsCountryId(value, fallback = DEFAULT_COUNTRY_ID) {
|
||
const parsed = Math.floor(Number(value));
|
||
if (Number.isFinite(parsed) && parsed >= 0) {
|
||
return parsed;
|
||
}
|
||
const fallbackParsed = Math.floor(Number(fallback));
|
||
if (Number.isFinite(fallbackParsed) && fallbackParsed >= 0) {
|
||
return fallbackParsed;
|
||
}
|
||
return DEFAULT_COUNTRY_ID;
|
||
}
|
||
|
||
function normalizeNexSmsCountryLabel(value = '', fallback = DEFAULT_COUNTRY_LABEL) {
|
||
return normalizeText(value, fallback);
|
||
}
|
||
|
||
function normalizeCountryKey(value) {
|
||
const countryId = normalizeNexSmsCountryId(value, -1);
|
||
return countryId >= 0 ? String(countryId) : '';
|
||
}
|
||
|
||
function normalizeNexSmsServiceCode(value = '', fallback = DEFAULT_SERVICE_CODE) {
|
||
const normalized = String(value || '').trim().toLowerCase().replace(/[^a-z0-9_-]+/g, '');
|
||
if (normalized) {
|
||
return normalized;
|
||
}
|
||
const fallbackNormalized = String(fallback || '').trim().toLowerCase().replace(/[^a-z0-9_-]+/g, '');
|
||
return fallbackNormalized || DEFAULT_SERVICE_CODE;
|
||
}
|
||
|
||
function normalizePriceLimit(value) {
|
||
if (value === undefined || value === null || String(value).trim() === '') {
|
||
return null;
|
||
}
|
||
const parsed = Number(value);
|
||
if (!Number.isFinite(parsed) || parsed <= 0) {
|
||
return null;
|
||
}
|
||
return Math.round(parsed * 10000) / 10000;
|
||
}
|
||
|
||
function normalizeAcquirePriority(value = '') {
|
||
const normalized = String(value || '').trim().toLowerCase();
|
||
if (normalized === ACQUIRE_PRIORITY_PRICE) {
|
||
return ACQUIRE_PRIORITY_PRICE;
|
||
}
|
||
if (normalized === ACQUIRE_PRIORITY_PRICE_HIGH) {
|
||
return ACQUIRE_PRIORITY_PRICE_HIGH;
|
||
}
|
||
return ACQUIRE_PRIORITY_COUNTRY;
|
||
}
|
||
|
||
function normalizeActivationRetryRounds(value) {
|
||
const parsed = Math.floor(Number(value));
|
||
if (!Number.isFinite(parsed) || parsed <= 0) {
|
||
return DEFAULT_ACQUIRE_RETRY_ROUNDS;
|
||
}
|
||
return Math.max(1, Math.min(10, parsed));
|
||
}
|
||
|
||
function normalizeActivationRetryDelayMs(value) {
|
||
const parsed = Math.floor(Number(value));
|
||
if (!Number.isFinite(parsed) || parsed <= 0) {
|
||
return DEFAULT_ACQUIRE_RETRY_DELAY_MS;
|
||
}
|
||
return Math.max(500, Math.min(30000, parsed));
|
||
}
|
||
|
||
function normalizeNexSmsCountryOrder(value = []) {
|
||
const source = Array.isArray(value)
|
||
? value
|
||
: String(value || '')
|
||
.split(/[\r\n,，;；]+/)
|
||
.map((entry) => String(entry || '').trim())
|
||
.filter(Boolean);
|
||
const normalized = [];
|
||
const seen = new Set();
|
||
|
||
source.forEach((entry) => {
|
||
let id = -1;
|
||
let label = '';
|
||
if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
|
||
id = normalizeNexSmsCountryId(entry.id ?? entry.countryId, -1);
|
||
label = normalizeText(entry.label ?? entry.countryLabel, '');
|
||
} else {
|
||
const text = String(entry || '').trim();
|
||
const structured = text.match(/^(\d+)\s*(?:[:|/-]\s*(.+))?$/);
|
||
id = normalizeNexSmsCountryId(structured?.[1] || text, -1);
|
||
label = normalizeText(structured?.[2], '');
|
||
}
|
||
if (id < 0 || seen.has(id)) {
|
||
return;
|
||
}
|
||
seen.add(id);
|
||
normalized.push({
|
||
id,
|
||
label: label || `Country #${id}`,
|
||
});
|
||
});
|
||
|
||
return normalized.slice(0, 20);
|
||
}
|
||
|
||
function resolveCountryCandidates(state = {}) {
|
||
const candidates = normalizeNexSmsCountryOrder(state?.nexSmsCountryOrder);
|
||
if (candidates.length) {
|
||
return candidates;
|
||
}
|
||
return [{
|
||
id: normalizeNexSmsCountryId(state?.nexSmsCountryId, DEFAULT_COUNTRY_ID),
|
||
label: normalizeNexSmsCountryLabel(state?.nexSmsCountryLabel, DEFAULT_COUNTRY_LABEL),
|
||
}];
|
||
}
|
||
|
||
function resolveCountryLabel(state = {}, countryId = DEFAULT_COUNTRY_ID) {
|
||
const countryKey = normalizeCountryKey(countryId);
|
||
const matched = resolveCountryCandidates(state)
|
||
.find((entry) => normalizeCountryKey(entry.id) === countryKey);
|
||
return matched?.label || (countryKey ? `Country #${countryKey}` : DEFAULT_COUNTRY_LABEL);
|
||
}
|
||
|
||
function parsePayload(text) {
|
||
const trimmed = String(text || '').trim();
|
||
if (!trimmed) {
|
||
return '';
|
||
}
|
||
try {
|
||
return JSON.parse(trimmed);
|
||
} catch {
|
||
return trimmed;
|
||
}
|
||
}
|
||
|
||
function describePayload(raw) {
|
||
if (typeof raw === 'string') {
|
||
return raw.trim();
|
||
}
|
||
if (raw && typeof raw === 'object') {
|
||
const message = normalizeText(raw.message || raw.error || raw.msg || raw.statusText, '');
|
||
if (message) {
|
||
return message;
|
||
}
|
||
try {
|
||
return JSON.stringify(raw);
|
||
} catch {
|
||
return String(raw);
|
||
}
|
||
}
|
||
return String(raw || '').trim();
|
||
}
|
||
|
||
function isSuccessPayload(payload) {
|
||
if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
|
||
return false;
|
||
}
|
||
return Number(payload.code) === 0;
|
||
}
|
||
|
||
function isNoNumbersError(payloadOrMessage) {
|
||
const text = describePayload(payloadOrMessage);
|
||
return /numbers?\s+not\s+found|暂无可用|no\s+numbers|no\s+stock|库存.*0|not\s+available/i.test(text);
|
||
}
|
||
|
||
function isPendingMessage(payloadOrMessage) {
|
||
const text = describePayload(payloadOrMessage);
|
||
return /no\s+sms|暂无短信|waiting|not\s+arrived|empty|未收到|短信为空|no\s+records/i.test(text);
|
||
}
|
||
|
||
function isTerminalError(payloadOrMessage, status = 0) {
|
||
if (Number(status) === 401 || Number(status) === 403) {
|
||
return true;
|
||
}
|
||
const text = describePayload(payloadOrMessage);
|
||
return /invalid\s*api\s*key|bad[_\s-]*key|wrong[_\s-]*key|unauthorized|forbidden|no\s*balance|insufficient\s*balance|余额不足|账号.*封禁|banned/i.test(text);
|
||
}
|
||
|
||
function resolveConfig(state = {}, deps = {}) {
|
||
return {
|
||
apiKey: normalizeText(state?.nexSmsApiKey),
|
||
baseUrl: normalizeBaseUrl(state?.nexSmsBaseUrl || DEFAULT_BASE_URL),
|
||
serviceCode: normalizeNexSmsServiceCode(state?.nexSmsServiceCode, DEFAULT_SERVICE_CODE),
|
||
fetchImpl: deps.fetchImpl || (typeof fetch === 'function' ? fetch.bind(globalThis) : null),
|
||
requestTimeoutMs: deps.requestTimeoutMs || DEFAULT_REQUEST_TIMEOUT_MS,
|
||
};
|
||
}
|
||
|
||
async function fetchPayload(config, path, actionLabel, options = {}) {
|
||
if (!config.fetchImpl) {
|
||
throw new Error('NexSMS 网络请求实现不可用。');
|
||
}
|
||
if (!config.apiKey) {
|
||
throw new Error('NexSMS API Key 缺失，请先在侧边栏保存接码 API Key。');
|
||
}
|
||
const controller = typeof AbortController === 'function' ? new AbortController() : null;
|
||
const timeoutId = controller
|
||
? setTimeout(() => controller.abort(), Number(config.requestTimeoutMs) || DEFAULT_REQUEST_TIMEOUT_MS)
|
||
: null;
|
||
|
||
try {
|
||
const method = String(options.method || 'GET').trim().toUpperCase() || 'GET';
|
||
const requestUrl = new URL(path.replace(/^\/+/, ''), `${config.baseUrl.replace(/\/+$/, '')}/`);
|
||
requestUrl.searchParams.set('apiKey', config.apiKey);
|
||
Object.entries(options.query || {}).forEach(([key, value]) => {
|
||
if (value === undefined || value === null || value === '') {
|
||
return;
|
||
}
|
||
requestUrl.searchParams.set(key, String(value));
|
||
});
|
||
const headers = {
|
||
Accept: 'application/json',
|
||
...(options.headers && typeof options.headers === 'object' ? options.headers : {}),
|
||
};
|
||
const requestInit = {
|
||
method,
|
||
headers,
|
||
signal: controller?.signal,
|
||
};
|
||
if (method !== 'GET' && method !== 'HEAD' && options.body !== undefined) {
|
||
requestInit.body = typeof options.body === 'string'
|
||
? options.body
|
||
: JSON.stringify(options.body);
|
||
if (!requestInit.headers['Content-Type']) {
|
||
requestInit.headers['Content-Type'] = 'application/json';
|
||
}
|
||
}
|
||
const response = await config.fetchImpl(requestUrl.toString(), requestInit);
|
||
const text = await response.text();
|
||
const payload = parsePayload(text);
|
||
if (!response.ok) {
|
||
const error = new Error(`${actionLabel}失败：${describePayload(payload) || response.status}`);
|
||
error.payload = payload;
|
||
error.status = response.status;
|
||
throw error;
|
||
}
|
||
return payload;
|
||
} catch (error) {
|
||
if (error?.name === 'AbortError') {
|
||
throw new Error(`${actionLabel}超时。`);
|
||
}
|
||
throw error;
|
||
} finally {
|
||
if (timeoutId) {
|
||
clearTimeout(timeoutId);
|
||
}
|
||
}
|
||
}
|
||
|
||
async function fetchBalance(state = {}, deps = {}) {
|
||
const config = resolveConfig(state, deps);
|
||
const payload = await fetchPayload(config, '/api/user/getBalance', 'NexSMS get balance');
|
||
if (!isSuccessPayload(payload)) {
|
||
throw new Error(`NexSMS get balance 失败：${describePayload(payload) || 'empty response'}`);
|
||
}
|
||
const balance = Number(payload?.data?.balance);
|
||
return {
|
||
balance: Number.isFinite(balance) ? balance : null,
|
||
raw: payload,
|
||
};
|
||
}
|
||
|
||
async function fetchPrices(state = {}, countryConfig = {}, deps = {}) {
|
||
const config = resolveConfig(state, deps);
|
||
const countryId = normalizeNexSmsCountryId(countryConfig?.id, DEFAULT_COUNTRY_ID);
|
||
return fetchPayload(config, '/api/getCountryByService', 'NexSMS getCountryByService', {
|
||
query: {
|
||
serviceCode: config.serviceCode,
|
||
countryId,
|
||
},
|
||
});
|
||
}
|
||
|
||
function buildSortedUniquePriceCandidates(values = []) {
|
||
return Array.from(
|
||
new Set(
|
||
values
|
||
.map((value) => Number(value))
|
||
.filter((value) => Number.isFinite(value) && value > 0)
|
||
.map((value) => Math.round(value * 10000) / 10000)
|
||
)
|
||
)
|
||
.sort((left, right) => left - right)
|
||
.slice(0, MAX_PRICE_CANDIDATES);
|
||
}
|
||
|
||
function collectPriceCandidates(countryData = {}) {
|
||
const candidates = [];
|
||
const pushCandidate = (value) => {
|
||
const numeric = Number(value);
|
||
if (Number.isFinite(numeric) && numeric > 0) {
|
||
candidates.push(Math.round(numeric * 10000) / 10000);
|
||
}
|
||
};
|
||
pushCandidate(countryData.minPrice);
|
||
pushCandidate(countryData.medianPrice);
|
||
pushCandidate(countryData.maxPrice);
|
||
if (countryData.priceMap && typeof countryData.priceMap === 'object') {
|
||
Object.entries(countryData.priceMap).forEach(([priceKey, count]) => {
|
||
const availableCount = Number(count);
|
||
if (!Number.isFinite(availableCount) || availableCount <= 0) {
|
||
return;
|
||
}
|
||
pushCandidate(priceKey);
|
||
});
|
||
}
|
||
return buildSortedUniquePriceCandidates(candidates);
|
||
}
|
||
|
||
function resolvePriceRange(state = {}) {
|
||
const minPriceLimit = normalizePriceLimit(state?.nexSmsMinPrice ?? state?.heroSmsMinPrice);
|
||
const maxPriceLimit = normalizePriceLimit(state?.nexSmsMaxPrice ?? state?.heroSmsMaxPrice);
|
||
return {
|
||
minPriceLimit,
|
||
maxPriceLimit,
|
||
hasMinPriceLimit: minPriceLimit !== null,
|
||
hasMaxPriceLimit: maxPriceLimit !== null,
|
||
invalidRange: minPriceLimit !== null && maxPriceLimit !== null && minPriceLimit > maxPriceLimit,
|
||
};
|
||
}
|
||
|
||
function isPriceWithinRange(price, minPriceLimit = null, maxPriceLimit = null) {
|
||
const numeric = Number(price);
|
||
if (!Number.isFinite(numeric) || numeric <= 0) {
|
||
return false;
|
||
}
|
||
const normalized = Math.round(numeric * 10000) / 10000;
|
||
if (minPriceLimit !== null && normalized < minPriceLimit) {
|
||
return false;
|
||
}
|
||
if (maxPriceLimit !== null && normalized > maxPriceLimit) {
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
function filterPriceCandidatesWithinRange(prices = [], minPriceLimit = null, maxPriceLimit = null) {
|
||
return (Array.isArray(prices) ? prices : []).filter((price) => (
|
||
isPriceWithinRange(price, minPriceLimit, maxPriceLimit)
|
||
));
|
||
}
|
||
|
||
function filterPriceCandidatesAboveFloor(prices = [], minExclusivePrice = null) {
|
||
const floor = normalizePriceLimit(minExclusivePrice);
|
||
if (floor === null || floor <= 0) {
|
||
return Array.isArray(prices) ? [...prices] : [];
|
||
}
|
||
return (Array.isArray(prices) ? prices : []).filter((value) => {
|
||
const numeric = Number(value);
|
||
return Number.isFinite(numeric) && numeric > floor;
|
||
});
|
||
}
|
||
|
||
function reorderPriceCandidates(prices = [], acquirePriority = ACQUIRE_PRIORITY_COUNTRY, preferredPrice = null) {
|
||
const ordered = buildSortedUniquePriceCandidates(prices);
|
||
if (acquirePriority === ACQUIRE_PRIORITY_PRICE_HIGH) {
|
||
ordered.reverse();
|
||
}
|
||
const preferred = normalizePriceLimit(preferredPrice);
|
||
if (preferred === null) {
|
||
return ordered;
|
||
}
|
||
return [preferred, ...ordered.filter((price) => price !== preferred)];
|
||
}
|
||
|
||
function normalizePriceFloorMap(rawMap = {}, normalizeCountryKey) {
|
||
const normalizedMap = new Map();
|
||
if (!rawMap || typeof rawMap !== 'object') {
|
||
return normalizedMap;
|
||
}
|
||
Object.entries(rawMap).forEach(([rawCountryKey, rawPrice]) => {
|
||
const countryKey = String(
|
||
typeof normalizeCountryKey === 'function'
|
||
? normalizeCountryKey(rawCountryKey)
|
||
: rawCountryKey
|
||
).trim();
|
||
if (!countryKey) {
|
||
return;
|
||
}
|
||
const normalizedPrice = normalizePriceLimit(rawPrice);
|
||
if (normalizedPrice === null || normalizedPrice <= 0) {
|
||
return;
|
||
}
|
||
normalizedMap.set(countryKey, normalizedPrice);
|
||
});
|
||
return normalizedMap;
|
||
}
|
||
|
||
function formatPriceRangeText(minPriceLimit = null, maxPriceLimit = null) {
|
||
const minPrice = normalizePriceLimit(minPriceLimit);
|
||
const maxPrice = normalizePriceLimit(maxPriceLimit);
|
||
if (minPrice !== null && maxPrice !== null) {
|
||
return `${minPrice}~${maxPrice}`;
|
||
}
|
||
if (minPrice !== null) {
|
||
return `${minPrice}~`;
|
||
}
|
||
if (maxPrice !== null) {
|
||
return `~${maxPrice}`;
|
||
}
|
||
return 'unbounded';
|
||
}
|
||
|
||
async function resolveCountryPricePlan(state = {}, countryConfig = {}, deps = {}) {
|
||
const config = resolveConfig(state, deps);
|
||
const countryId = normalizeNexSmsCountryId(countryConfig?.id, -1);
|
||
if (countryId < 0) {
|
||
throw new Error(`NexSMS 国家 ID 无效：${countryConfig?.id}`);
|
||
}
|
||
const payload = await fetchPayload(config, '/api/getCountryByService', 'NexSMS getCountryByService', {
|
||
query: {
|
||
serviceCode: config.serviceCode,
|
||
countryId,
|
||
},
|
||
});
|
||
if (!isSuccessPayload(payload)) {
|
||
throw new Error(`NexSMS getCountryByService 失败：${describePayload(payload) || 'empty response'}`);
|
||
}
|
||
const countryData = payload && typeof payload === 'object' && !Array.isArray(payload)
|
||
? (payload.data || {})
|
||
: {};
|
||
const countryLabel = normalizeNexSmsCountryLabel(
|
||
countryData.countryName || countryConfig?.label,
|
||
`Country #${countryId}`
|
||
);
|
||
const prices = collectPriceCandidates(countryData);
|
||
const minCatalogPrice = prices.length
|
||
? prices[0]
|
||
: (() => {
|
||
const minPrice = Number(countryData.minPrice);
|
||
return Number.isFinite(minPrice) && minPrice > 0
|
||
? Math.round(minPrice * 10000) / 10000
|
||
: null;
|
||
})();
|
||
const priceRange = resolvePriceRange(state);
|
||
const filteredPrices = filterPriceCandidatesWithinRange(
|
||
prices,
|
||
priceRange.minPriceLimit,
|
||
priceRange.maxPriceLimit
|
||
);
|
||
return {
|
||
countryId,
|
||
countryLabel,
|
||
prices: filteredPrices,
|
||
userLimit: priceRange.maxPriceLimit,
|
||
minCatalogPrice,
|
||
rawPayload: payload,
|
||
};
|
||
}
|
||
|
||
function normalizeActivation(payload, fallback = {}) {
|
||
const source = payload && typeof payload === 'object' && !Array.isArray(payload)
|
||
? payload
|
||
: {};
|
||
const data = isSuccessPayload(source) ? (source.data || {}) : source;
|
||
const phoneCandidates = Array.isArray(data.phoneNumbers)
|
||
? data.phoneNumbers
|
||
: (Array.isArray(data.numbers) ? data.numbers : []);
|
||
const phoneNumber = normalizeText(
|
||
data.phoneNumber
|
||
|| data.phone
|
||
|| phoneCandidates[0]
|
||
|| source.phoneNumber
|
||
|| source.phone
|
||
|| fallback.phoneNumber
|
||
);
|
||
if (!phoneNumber) {
|
||
return null;
|
||
}
|
||
const countryId = normalizeNexSmsCountryId(
|
||
data.countryId ?? source.countryId ?? fallback.countryId,
|
||
DEFAULT_COUNTRY_ID
|
||
);
|
||
return {
|
||
activationId: normalizeText(data.activationId || source.activationId || fallback.activationId, phoneNumber),
|
||
phoneNumber,
|
||
provider: PROVIDER_ID,
|
||
serviceCode: normalizeNexSmsServiceCode(
|
||
data.serviceCode || source.serviceCode || fallback.serviceCode || DEFAULT_SERVICE_CODE,
|
||
DEFAULT_SERVICE_CODE
|
||
),
|
||
countryId,
|
||
countryLabel: normalizeNexSmsCountryLabel(
|
||
data.countryName || source.countryName || data.countryLabel || source.countryLabel || fallback.countryLabel,
|
||
`Country #${countryId}`
|
||
),
|
||
successfulUses: Math.max(0, Math.floor(Number(fallback.successfulUses) || 0)),
|
||
maxUses: 1,
|
||
...(fallback.selectedPrice !== undefined ? { selectedPrice: Number(fallback.selectedPrice) } : {}),
|
||
...(fallback.price !== undefined ? { price: Number(fallback.price) } : {}),
|
||
...(fallback.maxPrice !== undefined ? { maxPrice: Number(fallback.maxPrice) } : {}),
|
||
};
|
||
}
|
||
|
||
function resolveActivationCountry(activation = {}, state = {}) {
|
||
const normalizedActivation = normalizeActivation(activation)
|
||
|| (activation && typeof activation === 'object' ? activation : {});
|
||
const countryId = normalizeNexSmsCountryId(
|
||
normalizedActivation.countryId ?? normalizedActivation.country,
|
||
DEFAULT_COUNTRY_ID
|
||
);
|
||
const matched = resolveCountryCandidates(state)
|
||
.find((entry) => normalizeNexSmsCountryId(entry.id, -1) === countryId);
|
||
if (matched) {
|
||
return matched;
|
||
}
|
||
return {
|
||
id: countryId,
|
||
label: normalizeNexSmsCountryLabel(normalizedActivation.countryLabel, `Country #${countryId}`),
|
||
};
|
||
}
|
||
|
||
function getActivationCountryKey(activation = {}) {
|
||
return normalizeCountryKey(activation?.countryId ?? activation?.country);
|
||
}
|
||
|
||
function getActivationPrice(activation = {}) {
|
||
return Number.isFinite(Number(activation?.selectedPrice))
|
||
? Math.round(Number(activation.selectedPrice) * 10000) / 10000
|
||
: null;
|
||
}
|
||
|
||
async function requestActivation(state = {}, options = {}, deps = {}) {
|
||
const config = resolveConfig(state, deps);
|
||
const allCountryCandidates = resolveCountryCandidates(state);
|
||
if (!allCountryCandidates.length) {
|
||
throw new Error('步骤 9：NexSMS 未选择国家，请先在接码设置中至少选择 1 个国家。');
|
||
}
|
||
const blockedCountryIds = new Set(
|
||
(Array.isArray(options?.blockedCountryIds) ? options.blockedCountryIds : [])
|
||
.map((value) => normalizeNexSmsCountryId(value, -1))
|
||
.filter((id) => id >= 0)
|
||
);
|
||
let countryCandidates = allCountryCandidates.filter((entry) => {
|
||
const id = normalizeNexSmsCountryId(entry.id, -1);
|
||
return id >= 0 && !blockedCountryIds.has(id);
|
||
});
|
||
if (!countryCandidates.length) {
|
||
countryCandidates = allCountryCandidates;
|
||
if (blockedCountryIds.size && typeof deps.addLog === 'function') {
|
||
await deps.addLog('步骤 9：已选国家均达到临时收码失败跳过阈值，本轮解除跳过并重新尝试。', 'warn');
|
||
}
|
||
}
|
||
const acquirePriority = normalizeAcquirePriority(state?.heroSmsAcquirePriority);
|
||
const priceRange = resolvePriceRange(state);
|
||
if (priceRange.invalidRange) {
|
||
throw new Error(`NexSMS 价格区间无效：最低购买价 ${priceRange.minPriceLimit} 高于价格上限 ${priceRange.maxPriceLimit}。`);
|
||
}
|
||
const hasPriceBounds = priceRange.hasMinPriceLimit || priceRange.hasMaxPriceLimit;
|
||
const preferredPriceTier = normalizePriceLimit(state?.heroSmsPreferredPrice);
|
||
const countryPriceFloorByCountryId = normalizePriceFloorMap(
|
||
options?.countryPriceFloorByCountryId,
|
||
(value) => String(normalizeNexSmsCountryId(value, -1))
|
||
);
|
||
const maxAcquireRounds = Math.max(2, normalizeActivationRetryRounds(state?.heroSmsActivationRetryRounds));
|
||
const retryDelayMs = normalizeActivationRetryDelayMs(state?.heroSmsActivationRetryDelayMs);
|
||
let finalNoNumbersByCountry = [];
|
||
let finalLastError = null;
|
||
|
||
for (let round = 1; round <= maxAcquireRounds; round += 1) {
|
||
if (maxAcquireRounds > 1 && typeof deps.addLog === 'function') {
|
||
await deps.addLog(`步骤 9：NexSMS 正在获取手机号（第 ${round}/${maxAcquireRounds} 轮）...`, 'info');
|
||
}
|
||
const candidateAttempts = countryCandidates.map((countryConfig, index) => ({
|
||
index,
|
||
countryConfig,
|
||
pricePlan: null,
|
||
orderingPrice: Number.POSITIVE_INFINITY,
|
||
}));
|
||
if (
|
||
(acquirePriority === ACQUIRE_PRIORITY_PRICE || acquirePriority === ACQUIRE_PRIORITY_PRICE_HIGH)
|
||
&& candidateAttempts.length > 1
|
||
) {
|
||
for (const attempt of candidateAttempts) {
|
||
try {
|
||
const pricePlan = await resolveCountryPricePlan(state, attempt.countryConfig, deps);
|
||
attempt.pricePlan = pricePlan;
|
||
const orderedForRanking = reorderPriceCandidates(pricePlan.prices, acquirePriority, preferredPriceTier);
|
||
const rangeFilteredForRanking = filterPriceCandidatesWithinRange(
|
||
orderedForRanking,
|
||
priceRange.minPriceLimit,
|
||
priceRange.maxPriceLimit
|
||
);
|
||
const rankingPrices = rangeFilteredForRanking.length
|
||
? rangeFilteredForRanking
|
||
: (hasPriceBounds ? [] : orderedForRanking);
|
||
attempt.orderingPrice = Array.isArray(rankingPrices) && rankingPrices.length
|
||
? Number(rankingPrices[0])
|
||
: Number.POSITIVE_INFINITY;
|
||
} catch (error) {
|
||
attempt.lookupError = error;
|
||
}
|
||
}
|
||
candidateAttempts.sort((left, right) => {
|
||
if (left.orderingPrice !== right.orderingPrice) {
|
||
return acquirePriority === ACQUIRE_PRIORITY_PRICE_HIGH
|
||
? (right.orderingPrice - left.orderingPrice)
|
||
: (left.orderingPrice - right.orderingPrice);
|
||
}
|
||
return left.index - right.index;
|
||
});
|
||
if (typeof deps.addLog === 'function') {
|
||
const rankingSummary = candidateAttempts.map((attempt) => {
|
||
const id = normalizeNexSmsCountryId(attempt.countryConfig.id, -1);
|
||
const label = normalizeText(attempt.countryConfig.label, `Country #${id}`);
|
||
return Number.isFinite(attempt.orderingPrice)
|
||
? `${label}:${attempt.orderingPrice}`
|
||
: `${label}:无`;
|
||
}).join(' | ');
|
||
await deps.addLog(`步骤 9：NexSMS 价格优先排序：${rankingSummary}`, 'info');
|
||
}
|
||
}
|
||
|
||
const noNumbersByCountry = [];
|
||
const retryableNoNumberCountries = [];
|
||
let lastError = null;
|
||
for (const attempt of candidateAttempts) {
|
||
const countryId = normalizeNexSmsCountryId(attempt.countryConfig.id, -1);
|
||
const countryLabel = normalizeNexSmsCountryLabel(attempt.countryConfig.label, `Country #${countryId}`);
|
||
const countryPriceFloor = countryPriceFloorByCountryId.get(String(countryId)) ?? null;
|
||
let pricePlan = attempt.pricePlan;
|
||
if (!pricePlan) {
|
||
try {
|
||
pricePlan = await resolveCountryPricePlan(state, attempt.countryConfig, deps);
|
||
} catch (error) {
|
||
if (isTerminalError(error?.payload || error?.message, error?.status)) {
|
||
throw new Error(`NexSMS price lookup 失败：${describePayload(error?.payload || error?.message) || 'unknown terminal error'}`);
|
||
}
|
||
lastError = error;
|
||
continue;
|
||
}
|
||
}
|
||
if (!Array.isArray(pricePlan.prices) || !pricePlan.prices.length) {
|
||
if (
|
||
pricePlan.userLimit !== null
|
||
&& pricePlan.minCatalogPrice !== null
|
||
&& pricePlan.minCatalogPrice > pricePlan.userLimit
|
||
) {
|
||
noNumbersByCountry.push(`${countryLabel}: 价格上限 ${pricePlan.userLimit} 内暂无可用号码；平台最低价=${pricePlan.minCatalogPrice}`);
|
||
} else {
|
||
const reason = describePayload(pricePlan.rawPayload) || '无可用价格档位';
|
||
noNumbersByCountry.push(`${countryLabel}: ${reason}`);
|
||
retryableNoNumberCountries.push(countryLabel);
|
||
}
|
||
continue;
|
||
}
|
||
const orderedPrices = reorderPriceCandidates(pricePlan.prices, acquirePriority, preferredPriceTier);
|
||
const rangeFilteredPrices = filterPriceCandidatesWithinRange(
|
||
orderedPrices,
|
||
priceRange.minPriceLimit,
|
||
priceRange.maxPriceLimit
|
||
);
|
||
const candidatePrices = rangeFilteredPrices.length
|
||
? rangeFilteredPrices
|
||
: (hasPriceBounds ? [] : orderedPrices);
|
||
const floorFilteredPrices = filterPriceCandidatesAboveFloor(candidatePrices, countryPriceFloor);
|
||
const hasCountryPriceFloor = (
|
||
countryPriceFloor !== null
|
||
&& Number.isFinite(Number(countryPriceFloor))
|
||
&& Number(countryPriceFloor) > 0
|
||
);
|
||
const hasAlternativeCountries = candidateAttempts.some((entry) => (
|
||
normalizeNexSmsCountryId(entry?.countryConfig?.id, -1)
|
||
!== normalizeNexSmsCountryId(attempt?.countryConfig?.id, -1)
|
||
));
|
||
const pricesToTry = hasCountryPriceFloor
|
||
? (floorFilteredPrices.length ? floorFilteredPrices : (hasAlternativeCountries ? [] : candidatePrices.slice(0, 1)))
|
||
: (floorFilteredPrices.length ? floorFilteredPrices : candidatePrices);
|
||
if (!pricesToTry.length) {
|
||
if (priceRange.hasMinPriceLimit && !rangeFilteredPrices.length) {
|
||
noNumbersByCountry.push(`${countryLabel}: 价格区间 ${formatPriceRangeText(priceRange.minPriceLimit, priceRange.maxPriceLimit)} 内暂无可用号码`);
|
||
continue;
|
||
}
|
||
if (
|
||
countryPriceFloor !== null
|
||
&& Array.isArray(pricePlan.prices)
|
||
&& pricePlan.prices.length > 0
|
||
) {
|
||
noNumbersByCountry.push(`${countryLabel}: 当前回退尝试没有高于 ${countryPriceFloor} 的价格档位`);
|
||
} else {
|
||
noNumbersByCountry.push(`${countryLabel}: ${describePayload(pricePlan.rawPayload) || '暂无可用号码'}`);
|
||
retryableNoNumberCountries.push(countryLabel);
|
||
}
|
||
continue;
|
||
}
|
||
let boughtActivation = null;
|
||
for (const price of pricesToTry) {
|
||
try {
|
||
const payload = await fetchPayload(config, '/api/order/purchase', 'NexSMS purchase', {
|
||
method: 'POST',
|
||
body: {
|
||
serviceCode: config.serviceCode,
|
||
countryId,
|
||
quantity: 1,
|
||
price,
|
||
},
|
||
});
|
||
if (!isSuccessPayload(payload)) {
|
||
if (isNoNumbersError(payload)) {
|
||
continue;
|
||
}
|
||
if (isTerminalError(payload)) {
|
||
throw new Error(`NexSMS purchase 失败：${describePayload(payload) || 'empty response'}`);
|
||
}
|
||
lastError = new Error(`NexSMS purchase 失败：${describePayload(payload) || 'empty response'}`);
|
||
continue;
|
||
}
|
||
boughtActivation = normalizeActivation(payload, {
|
||
countryId,
|
||
countryLabel,
|
||
serviceCode: config.serviceCode,
|
||
selectedPrice: price,
|
||
});
|
||
if (!boughtActivation) {
|
||
lastError = new Error('NexSMS 购买成功，但未返回手机号。');
|
||
continue;
|
||
}
|
||
return boughtActivation;
|
||
} catch (error) {
|
||
if (isTerminalError(error?.payload || error?.message, error?.status)) {
|
||
throw new Error(`NexSMS purchase 失败：${describePayload(error?.payload || error?.message) || 'unknown terminal error'}`);
|
||
}
|
||
if (isNoNumbersError(error?.payload || error?.message)) {
|
||
continue;
|
||
}
|
||
lastError = error;
|
||
}
|
||
}
|
||
if (!boughtActivation) {
|
||
const fallbackReason = describePayload(pricePlan.rawPayload) || '暂无可用号码';
|
||
noNumbersByCountry.push(`${countryLabel}: ${fallbackReason}`);
|
||
retryableNoNumberCountries.push(countryLabel);
|
||
}
|
||
}
|
||
finalNoNumbersByCountry = noNumbersByCountry;
|
||
finalLastError = lastError;
|
||
if (
|
||
noNumbersByCountry.length
|
||
&& round < maxAcquireRounds
|
||
&& retryableNoNumberCountries.length > 0
|
||
) {
|
||
if (typeof deps.addLog === 'function') {
|
||
await deps.addLog(
|
||
`步骤 9：NexSMS 暂无可用号码（第 ${round}/${maxAcquireRounds} 轮）；${Math.ceil(retryDelayMs / 1000)} 秒后重试。国家：${retryableNoNumberCountries.join(', ')}。`,
|
||
'warn'
|
||
);
|
||
}
|
||
await deps.sleepWithStop?.(retryDelayMs);
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
|
||
if (finalNoNumbersByCountry.length) {
|
||
throw new Error(`NexSMS 已尝试 ${countryCandidates.length} 个候选国家，均无可用号码：${finalNoNumbersByCountry.join(' | ')}。`);
|
||
}
|
||
if (finalLastError) {
|
||
throw finalLastError;
|
||
}
|
||
throw new Error('NexSMS 获取手机号失败。');
|
||
}
|
||
|
||
function extractVerificationCode(value = '') {
|
||
const text = String(value || '').trim();
|
||
if (!text) {
|
||
return '';
|
||
}
|
||
return text.match(/\b(\d{4,8})\b/)?.[1] || '';
|
||
}
|
||
|
||
async function pollActivationCode(state = {}, activation, options = {}, deps = {}) {
|
||
const normalizedActivation = normalizeActivation(activation);
|
||
if (!normalizedActivation) {
|
||
throw new Error('缺少手机号接码订单。');
|
||
}
|
||
const config = resolveConfig(state, deps);
|
||
const timeoutMs = Math.max(1000, Number(options.timeoutMs) || DEFAULT_POLL_TIMEOUT_MS);
|
||
const intervalMs = Math.max(1000, Number(options.intervalMs) || DEFAULT_POLL_INTERVAL_MS);
|
||
const maxRoundsRaw = Math.floor(Number(options.maxRounds));
|
||
const maxRounds = Number.isFinite(maxRoundsRaw) && maxRoundsRaw > 0 ? maxRoundsRaw : 0;
|
||
const start = Date.now();
|
||
let pollCount = 0;
|
||
let lastResponse = '';
|
||
|
||
const emitWaitingForCode = async (statusText) => {
|
||
if (typeof options.onWaitingForCode === 'function') {
|
||
await options.onWaitingForCode({
|
||
activation: normalizedActivation,
|
||
elapsedMs: Date.now() - start,
|
||
pollCount,
|
||
statusText,
|
||
timeoutMs,
|
||
});
|
||
}
|
||
};
|
||
|
||
while (Date.now() - start < timeoutMs) {
|
||
if (maxRounds > 0 && pollCount >= maxRounds) {
|
||
break;
|
||
}
|
||
deps.throwIfStopped?.();
|
||
const payload = await fetchPayload(config, '/api/sms/messages', 'NexSMS get sms messages', {
|
||
query: {
|
||
phoneNumber: normalizedActivation.phoneNumber,
|
||
format: 'json_latest',
|
||
},
|
||
});
|
||
const text = describePayload(payload);
|
||
lastResponse = text;
|
||
pollCount += 1;
|
||
if (typeof options.onStatus === 'function') {
|
||
await options.onStatus({
|
||
activation: normalizedActivation,
|
||
elapsedMs: Date.now() - start,
|
||
pollCount,
|
||
statusText: text || 'PENDING',
|
||
timeoutMs,
|
||
});
|
||
}
|
||
if (isSuccessPayload(payload)) {
|
||
const code = extractVerificationCode(payload?.data?.code || payload?.data?.text || payload?.data?.message || '');
|
||
if (code) {
|
||
return code;
|
||
}
|
||
await emitWaitingForCode(text || 'PENDING');
|
||
await deps.sleepWithStop?.(intervalMs);
|
||
continue;
|
||
}
|
||
if (isPendingMessage(payload)) {
|
||
await emitWaitingForCode(text || 'PENDING');
|
||
await deps.sleepWithStop?.(intervalMs);
|
||
continue;
|
||
}
|
||
if (isTerminalError(payload)) {
|
||
throw new Error(`NexSMS get sms messages 失败：${text || 'unknown terminal error'}`);
|
||
}
|
||
await emitWaitingForCode(text || 'PENDING');
|
||
await deps.sleepWithStop?.(intervalMs);
|
||
}
|
||
throw new Error(`${PHONE_CODE_TIMEOUT_ERROR_PREFIX}等待手机验证码超时。${lastResponse ? ` NexSMS 最后状态：${lastResponse}` : ''}`);
|
||
}
|
||
|
||
async function closeActivation(state = {}, activation, deps = {}, actionLabel = 'NexSMS close activation') {
|
||
const normalizedActivation = normalizeActivation(activation);
|
||
if (!normalizedActivation) {
|
||
return '';
|
||
}
|
||
const config = resolveConfig(state, deps);
|
||
const payload = await fetchPayload(config, '/api/close/activation', actionLabel, {
|
||
method: 'POST',
|
||
body: {
|
||
phoneNumber: normalizedActivation.phoneNumber,
|
||
},
|
||
});
|
||
if (!isSuccessPayload(payload)) {
|
||
throw new Error(`NexSMS close activation 失败：${describePayload(payload) || 'empty response'}`);
|
||
}
|
||
return describePayload(payload);
|
||
}
|
||
|
||
async function reuseActivation() {
|
||
throw new Error('NexSMS 当前流程不支持复用手机号订单。');
|
||
}
|
||
|
||
async function finishActivation() {
|
||
return 'NexSMS complete skipped';
|
||
}
|
||
|
||
async function cancelActivation(state = {}, activation, deps = {}) {
|
||
return closeActivation(state, activation, deps, 'NexSMS close activation');
|
||
}
|
||
|
||
async function banActivation(state = {}, activation, deps = {}) {
|
||
return closeActivation(state, activation, deps, 'NexSMS close activation');
|
||
}
|
||
|
||
async function requestAdditionalSms() {
|
||
return '';
|
||
}
|
||
|
||
async function rotateActivation(state = {}, activation, options = {}, deps = {}) {
|
||
const releaseAction = String(options?.releaseAction || '').trim().toLowerCase() === 'ban'
|
||
? 'ban'
|
||
: 'cancel';
|
||
if (releaseAction === 'ban') {
|
||
await banActivation(state, activation, deps);
|
||
} else {
|
||
await cancelActivation(state, activation, deps);
|
||
}
|
||
return {
|
||
currentTicketId: String(activation?.activationId || activation?.phoneNumber || ''),
|
||
nextActivation: null,
|
||
};
|
||
}
|
||
|
||
function createProvider(deps = {}) {
|
||
const providerDeps = {
|
||
fetchImpl: deps.fetchImpl,
|
||
sleepWithStop: deps.sleepWithStop,
|
||
throwIfStopped: deps.throwIfStopped,
|
||
addLog: deps.addLog,
|
||
requestTimeoutMs: deps.requestTimeoutMs || DEFAULT_REQUEST_TIMEOUT_MS,
|
||
};
|
||
const capabilities = Object.freeze({
|
||
supportsReusableActivation: false,
|
||
supportsAutomaticFreeReuse: false,
|
||
supportsFreeReusePreservation: false,
|
||
supportsPageResend: true,
|
||
supportsPageResendProbe: true,
|
||
requiresCountrySelection: true,
|
||
});
|
||
return {
|
||
id: PROVIDER_ID,
|
||
label: 'NexSMS',
|
||
capabilities,
|
||
defaultCountryId: DEFAULT_COUNTRY_ID,
|
||
defaultCountryLabel: DEFAULT_COUNTRY_LABEL,
|
||
defaultProduct: DEFAULT_SERVICE_LABEL,
|
||
defaultServiceCode: DEFAULT_SERVICE_CODE,
|
||
normalizeCountryId: normalizeNexSmsCountryId,
|
||
normalizeCountryLabel: normalizeNexSmsCountryLabel,
|
||
normalizeCountryOrder: normalizeNexSmsCountryOrder,
|
||
normalizeCountryKey,
|
||
normalizeServiceCode: normalizeNexSmsServiceCode,
|
||
normalizeActivation,
|
||
resolveCountryCandidates,
|
||
resolveCountryLabel,
|
||
resolveActivationCountry,
|
||
getActivationCountryKey,
|
||
getActivationPrice,
|
||
requestActivation: (state, options) => requestActivation(state, options, providerDeps),
|
||
reuseActivation: (state, activation) => reuseActivation(state, activation, providerDeps),
|
||
finishActivation: (state, activation) => finishActivation(state, activation, providerDeps),
|
||
cancelActivation: (state, activation) => cancelActivation(state, activation, providerDeps),
|
||
banActivation: (state, activation) => banActivation(state, activation, providerDeps),
|
||
requestAdditionalSms: (state, activation) => requestAdditionalSms(state, activation, providerDeps),
|
||
rotateActivation: (state, activation, options) => rotateActivation(state, activation, options, providerDeps),
|
||
pollActivationCode: (state, activation, options) => pollActivationCode(state, activation, options, providerDeps),
|
||
prepareActivationForReuse: reuseActivation,
|
||
canPersistReusableActivation: () => false,
|
||
canPreserveActivationForFreeReuse: () => false,
|
||
shouldUsePageResend: () => true,
|
||
shouldProbePageResend: () => true,
|
||
fetchBalance: (state) => fetchBalance(state, providerDeps),
|
||
fetchPrices: (state, countryConfig) => fetchPrices(state, countryConfig, providerDeps),
|
||
resolveCountryPricePlan: (state, countryConfig) => resolveCountryPricePlan(state, countryConfig, providerDeps),
|
||
resolvePriceRange,
|
||
formatPriceRangeText,
|
||
describePayload,
|
||
isSuccessPayload,
|
||
isNoNumbersError,
|
||
isPendingMessage,
|
||
isTerminalError,
|
||
};
|
||
}
|
||
|
||
return {
|
||
PROVIDER_ID,
|
||
DEFAULT_BASE_URL,
|
||
DEFAULT_COUNTRY_ID,
|
||
DEFAULT_COUNTRY_LABEL,
|
||
DEFAULT_SERVICE_CODE,
|
||
DEFAULT_SERVICE_LABEL,
|
||
createProvider,
|
||
describePayload,
|
||
isSuccessPayload,
|
||
normalizeNexSmsCountryId,
|
||
normalizeNexSmsCountryLabel,
|
||
normalizeNexSmsCountryOrder,
|
||
normalizeCountryKey,
|
||
normalizeNexSmsServiceCode,
|
||
normalizeActivation,
|
||
resolveActivationCountry,
|
||
};
|
||
});
|