smartxtrader 3.8.1-xm.0

package/api/_lib/telegram_subscription.js

@@ -0,0 +1,507 @@
+const DEFAULT_SUBSCRIPTION_CHANNEL_USERNAME = 'XYZSTRATTEGY'
+const DEFAULT_SUBSCRIPTION_CHANNEL = `@${DEFAULT_SUBSCRIPTION_CHANNEL_USERNAME}`
+const DEFAULT_SUBSCRIPTION_LINK = `https://t.me/${DEFAULT_SUBSCRIPTION_CHANNEL_USERNAME}`
+
+const BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN || ''
+const TELEGRAM_DEEP_LINK = process.env.TELEGRAM_DEEP_LINK || ''
+const BOT_USERNAME = process.env.TELEGRAM_BOT_USERNAME || ''
+const RAW_SUBSCRIPTION_IDS = process.env.TELEGRAM_SUBSCRIPTION_CHAT_IDS
+  || process.env.TELEGRAM_SUBSCRIPTION_CHAT_ID
+  || DEFAULT_SUBSCRIPTION_CHANNEL
+const SUBSCRIPTION_LINK_OVERRIDE = process.env.TELEGRAM_SUBSCRIPTION_LINK
+  || process.env.TELEGRAM_SUBSCRIPTION_URL
+  || process.env.TELEGRAM_SUBSCRIPTION_DEEP_LINK
+  || ''
+
+const SUBSCRIPTION_CHAT_IDS = Array.from(new Set(
+  RAW_SUBSCRIPTION_IDS
+    .split(',')
+    .map(id => id.trim())
+    .filter(id => id.length > 0),
+))
+
+const getPrimarySubscriptionChat = () => {
+  const primary = SUBSCRIPTION_CHAT_IDS[0] || DEFAULT_SUBSCRIPTION_CHANNEL
+  if (typeof primary === 'string' && primary.trim()) {
+    return primary.trim()
+  }
+  return DEFAULT_SUBSCRIPTION_CHANNEL
+}
+
+const getPrimarySubscriptionLabel = () => {
+  const chatId = getPrimarySubscriptionChat()
+  if (typeof chatId === 'string' && chatId.startsWith('@')) {
+    return chatId.slice(1)
+  }
+  if (typeof chatId === 'string' && chatId.length) {
+    return chatId
+  }
+  return DEFAULT_SUBSCRIPTION_CHANNEL_USERNAME
+}
+
+const SUBSCRIPTION_REQUIRE_ALL = String(process.env.TELEGRAM_SUBSCRIPTION_REQUIRE_ALL || '0') === '1'
+const SUBSCRIPTION_REQUIRED = String(
+  process.env.TELEGRAM_REQUIRE_SUBSCRIPTION
+    || (SUBSCRIPTION_CHAT_IDS.length ? '1' : '0'),
+) !== '0'
+const SUBSCRIPTION_CACHE_SECONDS = Math.max(0, Number(process.env.TELEGRAM_SUBSCRIPTION_CACHE_SECONDS || 60))
+const SUBSCRIPTION_CACHE_MS = SUBSCRIPTION_CACHE_SECONDS * 1000
+
+const fetchFn = typeof fetch === 'function'
+  ? fetch.bind(globalThis)
+  : (...args) => import('node-fetch').then(({ default: fetchModule }) => fetchModule(...args))
+
+const subscriptionCache = new Map()
+
+const BOT_LABEL = BOT_USERNAME ? `@${BOT_USERNAME}` : 'бота'
+
+const nowIsoString = () => new Date().toISOString()
+
+const getSubscribeLink = () => {
+  if (SUBSCRIPTION_LINK_OVERRIDE) {
+    return SUBSCRIPTION_LINK_OVERRIDE
+  }
+
+  const primaryChat = getPrimarySubscriptionChat()
+  if (typeof primaryChat === 'string' && primaryChat.length) {
+    if (primaryChat.startsWith('@')) {
+      return `https://t.me/${primaryChat.slice(1)}`
+    }
+
+    if (/^https?:\/\//i.test(primaryChat)) {
+      return primaryChat
+    }
+  }
+
+  const channelLabel = getPrimarySubscriptionLabel()
+  if (typeof channelLabel === 'string' && channelLabel.length) {
+    return `https://t.me/${channelLabel}`
+  }
+
+  if (TELEGRAM_DEEP_LINK) {
+    return `${TELEGRAM_DEEP_LINK}${TELEGRAM_DEEP_LINK.includes('?') ? '&' : '?'}start=subscribe`
+  }
+
+  if (BOT_USERNAME) {
+    return `https://t.me/${BOT_USERNAME}?start=subscribe`
+  }
+
+  return DEFAULT_SUBSCRIPTION_LINK
+}
+
+const interpretMembership = (member) => {
+  if (!member || typeof member !== 'object') {
+    return { isMember: false, status: null }
+  }
+
+  const status = member.status || null
+
+  if (!status) {
+    return { isMember: false, status: null }
+  }
+
+  if (status === 'creator' || status === 'administrator' || status === 'member') {
+    return { isMember: true, status }
+  }
+
+  if (status === 'restricted') {
+    return { isMember: Boolean(member.is_member), status }
+  }
+
+  return { isMember: false, status }
+}
+
+const fetchChatMemberStatus = async (chatId, userId) => {
+  const url = `https://api.telegram.org/bot${BOT_TOKEN}/getChatMember`
+  const body = {
+    chat_id: chatId,
+    user_id: /^[0-9]+$/.test(String(userId)) ? Number(userId) : String(userId),
+  }
+
+  try {
+    const response = await fetchFn(url, {
+      method : 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body   : JSON.stringify(body),
+    })
+
+    const text = await response.text()
+    let data = null
+
+    try {
+      data = text ? JSON.parse(text) : null
+    } catch (parseError) {
+      data = null
+    }
+
+    if (data && typeof data.ok === 'boolean') {
+      if (data.ok) {
+        return {
+          ok        : true,
+          httpStatus: response.status,
+          member    : data.result || null,
+          raw       : data,
+        }
+      }
+
+      return {
+        ok         : false,
+        httpStatus : response.status,
+        error_code : data.error_code || null,
+        description: data.description || text || null,
+        raw        : data,
+      }
+    }
+
+    if (response.ok) {
+      return {
+        ok        : true,
+        httpStatus: response.status,
+        member    : null,
+        raw       : data,
+      }
+    }
+
+    return {
+      ok         : false,
+      httpStatus : response.status,
+      description: text || null,
+      raw        : data,
+    }
+  } catch (error) {
+    return {
+      ok         : false,
+      httpStatus : null,
+      description: error.message || 'Network error',
+      raw        : null,
+    }
+  }
+}
+
+const cloneStatus = (status) => JSON.parse(JSON.stringify(status))
+
+const buildBaseStatus = () => ({
+  required    : SUBSCRIPTION_REQUIRED,
+  subscribeLink: getSubscribeLink(),
+})
+
+const normalizeChatStatuses = (statuses) => statuses.map((entry) => {
+  const normalized = {
+    chat_id : entry.chat_id,
+    ok      : Boolean(entry.ok),
+    status  : entry.status || null,
+    is_member: Boolean(entry.is_member),
+  }
+
+  if (typeof entry.until_date === 'number') {
+    normalized.until_date = entry.until_date
+  }
+
+  if (typeof entry.custom_title === 'string' && entry.custom_title) {
+    normalized.custom_title = entry.custom_title
+  }
+
+  if (entry.error) {
+    normalized.error = entry.error
+  }
+
+  if (entry.error_code) {
+    normalized.error_code = entry.error_code
+  }
+
+  if (entry.http_status) {
+    normalized.http_status = entry.http_status
+  }
+
+  return normalized
+})
+
+const normalizeErrorString = (value) => {
+  if (!value) {
+    return ''
+  }
+
+  return String(value).trim().toLowerCase()
+}
+
+const detectFailureReason = (errors) => {
+  const normalizedErrors = errors.map(normalizeErrorString)
+
+  if (normalizedErrors.some((error) => error.includes('member list is inaccessible'))) {
+    return 'MEMBER_LIST_INACCESSIBLE'
+  }
+
+  if (normalizedErrors.some((error) => error.includes('not enough rights to get members'))) {
+    return 'MEMBER_LIST_INACCESSIBLE'
+  }
+
+  if (normalizedErrors.some((error) => error.includes('bot was kicked from'))) {
+    return 'BOT_REMOVED_FROM_CHANNEL'
+  }
+
+  if (normalizedErrors.some((error) => error.includes('chat not found'))) {
+    return 'CHAT_NOT_FOUND'
+  }
+
+  return null
+}
+
+const checkUserSubscription = async ({ userId, forceRefresh = false } = {}) => {
+  const base = buildBaseStatus()
+  const checkedAt = nowIsoString()
+
+  if (!userId) {
+    return {
+      ...base,
+      ok         : false,
+      isSubscribed: false,
+      checkedAt,
+      reason     : 'USER_ID_MISSING',
+      message    : 'Telegram user identifier is missing for subscription check.',
+      statusCode : 400,
+    }
+  }
+
+  if (!base.required) {
+    return {
+      ...base,
+      ok         : true,
+      isSubscribed: true,
+      checkedAt,
+      reason     : 'SUBSCRIPTION_NOT_REQUIRED',
+      message    : 'Subscription is not required.',
+      statusCode : 200,
+    }
+  }
+
+  if (!BOT_TOKEN) {
+    return {
+      ...base,
+      ok         : false,
+      isSubscribed: false,
+      checkedAt,
+      reason     : 'BOT_TOKEN_MISSING',
+      message    : 'Telegram bot token is not configured for subscription verification.',
+      statusCode : 500,
+    }
+  }
+
+  if (!SUBSCRIPTION_CHAT_IDS.length) {
+    return {
+      ...base,
+      ok         : false,
+      isSubscribed: false,
+      checkedAt,
+      reason     : 'CHAT_ID_NOT_CONFIGURED',
+      message    : 'Subscription chat identifier is not configured.',
+      statusCode : 500,
+    }
+  }
+
+  const cacheKey = String(userId)
+  if (!forceRefresh && SUBSCRIPTION_CACHE_MS > 0 && subscriptionCache.has(cacheKey)) {
+    const cached = subscriptionCache.get(cacheKey)
+    if (cached && cached.expiresAt > Date.now()) {
+      return cloneStatus(cached.value)
+    }
+    subscriptionCache.delete(cacheKey)
+  }
+
+  const chatStatuses = []
+  const errors = []
+  let memberCount = 0
+  let allRequestsOk = true
+
+  for (const chatId of SUBSCRIPTION_CHAT_IDS) {
+    const result = await fetchChatMemberStatus(chatId, userId)
+    const membership = result.ok ? interpretMembership(result.member) : { isMember: false, status: null }
+
+    if (result.ok && membership.isMember) {
+      memberCount += 1
+    }
+
+    if (!result.ok) {
+      allRequestsOk = false
+      if (result.description) {
+        errors.push(result.description)
+      }
+    }
+
+    chatStatuses.push({
+      chat_id   : chatId,
+      ok        : result.ok,
+      status    : membership.status,
+      is_member : membership.isMember,
+      until_date: result.member?.until_date,
+      custom_title: result.member?.custom_title,
+      error     : result.ok ? null : result.description || null,
+      error_code: result.ok ? null : result.error_code || null,
+      http_status: result.httpStatus || null,
+    })
+  }
+
+  const membershipSatisfied = SUBSCRIPTION_REQUIRE_ALL
+    ? memberCount === SUBSCRIPTION_CHAT_IDS.length
+    : memberCount > 0
+
+  const ok = allRequestsOk
+  const statusCode = ok
+    ? (membershipSatisfied ? 200 : 403)
+    : 503
+
+  const failureReason = ok ? null : detectFailureReason(errors)
+
+  const message = ok
+    ? (membershipSatisfied
+      ? 'Subscription is active.'
+      : 'Active Telegram subscription is required to continue.')
+    : failureReason === 'MEMBER_LIST_INACCESSIBLE'
+      ? 'Bot cannot access the channel member list. Please grant the bot administrator rights in the channel and try again.'
+      : failureReason === 'BOT_REMOVED_FROM_CHANNEL'
+        ? 'Bot was removed from the subscription channel. Please add the bot back to the channel and retry.'
+        : failureReason === 'CHAT_NOT_FOUND'
+          ? 'Subscription channel could not be found. Please verify the channel identifier in the bot configuration.'
+          : `Failed to verify Telegram subscription${errors.length ? `: ${errors.join('; ')}` : '.'}`
+
+  const status = {
+    ...base,
+    ok,
+    isSubscribed: ok ? membershipSatisfied : false,
+    checkedAt,
+    chats      : normalizeChatStatuses(chatStatuses),
+    reason     : ok
+      ? (membershipSatisfied ? 'SUBSCRIBED' : 'NOT_SUBSCRIBED')
+      : 'CHECK_FAILED',
+    failureReason,
+    message,
+    statusCode,
+    error      : ok ? null : (errors.join('; ') || message),
+  }
+
+  if (SUBSCRIPTION_CACHE_MS > 0 && ok) {
+    subscriptionCache.set(cacheKey, {
+      expiresAt: Date.now() + SUBSCRIPTION_CACHE_MS,
+      value    : cloneStatus(status),
+    })
+  }
+
+  return status
+}
+
+const hasActiveSubscription = (status) => {
+  if (!status) {
+    return !SUBSCRIPTION_REQUIRED
+  }
+
+  if (!status.required) {
+    return true
+  }
+
+  return Boolean(status.ok && status.isSubscribed)
+}
+
+const buildSubscriptionStatusMessage = (status) => {
+  if (!status || !status.required) {
+    return 'ℹ️ Подписка не требуется для использования SmartAnalizer.'
+  }
+
+  if (!status.ok) {
+    if (status.failureReason === 'MEMBER_LIST_INACCESSIBLE') {
+      const channelLabel = getPrimarySubscriptionLabel()
+      return `⚠️ Бот ${BOT_LABEL} не имеет доступа к списку участников канала ${channelLabel}. Добавьте бота в администраторы канала и повторите проверку.`
+    }
+
+    if (status.failureReason === 'BOT_REMOVED_FROM_CHANNEL') {
+      const channelLabel = getPrimarySubscriptionLabel()
+      return `⚠️ Бот ${BOT_LABEL} был удалён из канала ${channelLabel}. Добавьте бота обратно и повторите проверку.`
+    }
+
+    if (status.failureReason === 'CHAT_NOT_FOUND') {
+      return '⚠️ Канал подписки не найден. Проверьте конфигурацию бота.'
+    }
+
+    return `⚠️ Не удалось проверить подписку. ${status.message || 'Попробуйте позже.'}`
+  }
+
+  if (status.isSubscribed) {
+    return '✅ Подписка активна. Добро пожаловать в SmartAnalizer!'
+  }
+
+  const link = status.subscribeLink || getSubscribeLink()
+  const channelLabel = getPrimarySubscriptionLabel()
+  const instruction = link
+    ? `Подпишитесь на канал ${channelLabel}: ${link}`
+    : `Подпишитесь на канал ${channelLabel}`
+
+  return `❌ Подписка не найдена. ${instruction}. После подписки нажмите «📦 Проверить подписку».`
+}
+
+const buildSubscriptionInlineKeyboard = (status) => {
+  const link = status?.subscribeLink || getSubscribeLink()
+  if (!link) {
+    return null
+  }
+
+  if (status && !status.ok && ['MEMBER_LIST_INACCESSIBLE', 'BOT_REMOVED_FROM_CHANNEL', 'CHAT_NOT_FOUND'].includes(status.failureReason)) {
+    return null
+  }
+
+  const channelLabel = getPrimarySubscriptionLabel()
+  const buttonText = typeof channelLabel === 'string' && channelLabel.length
+    ? `Подписаться на канал ${channelLabel}`
+    : 'Оформить подписку'
+
+  return {
+    inline_keyboard: [[{ text: buttonText, url: link }]],
+  }
+}
+
+const ensureUserSubscription = async (userId, options = {}) => {
+  const status = await checkUserSubscription({ userId, ...options })
+
+  if (!status.required) {
+    return status
+  }
+
+  if (!status.ok) {
+    const error = new Error(status.message || 'Unable to verify Telegram subscription.')
+    error.code = 'TELEGRAM_SUBSCRIPTION_CHECK_FAILED'
+    error.statusCode = status.statusCode || 503
+    error.details = status
+    throw error
+  }
+
+  if (!status.isSubscribed) {
+    const error = new Error(status.message || 'Active Telegram subscription is required.')
+    error.code = 'TELEGRAM_SUBSCRIPTION_REQUIRED'
+    error.statusCode = status.statusCode || 403
+    error.details = status
+    throw error
+  }
+
+  return status
+}
+
+const invalidateSubscriptionCache = (userId) => {
+  if (typeof userId === 'undefined' || userId === null) {
+    subscriptionCache.clear()
+    return
+  }
+
+  subscriptionCache.delete(String(userId))
+}
+
+module.exports = {
+  checkUserSubscription,
+  ensureUserSubscription,
+  hasActiveSubscription,
+  buildSubscriptionStatusMessage,
+  buildSubscriptionInlineKeyboard,
+  getSubscribeLink,
+  DEFAULT_SUBSCRIPTION_LINK,
+  DEFAULT_SUBSCRIPTION_CHANNEL,
+  DEFAULT_SUBSCRIPTION_CHANNEL_USERNAME,
+  getPrimarySubscriptionChat,
+  getPrimarySubscriptionLabel,
+  invalidateSubscriptionCache,
+}