dubs-server 1.0.0

package/services/telegramNotifications.js

@@ -0,0 +1,461 @@
+// 🔔 Telegram Notification Service for Oracle
+// Sends notifications to Telegram users when games are resolved
+
+const axios = require('axios');
+const urlHelper = require('../utils/urlHelper');
+
+const BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN;
+const TELEGRAM_API = `https://api.telegram.org/bot${BOT_TOKEN}`;
+
+/**
+ * Escape special Markdown characters in user-generated text
+ * Prevents Telegram API parse errors from user messages containing *, _, `, [, etc.
+ */
+function escapeMarkdown(text) {
+  if (!text) return '';
+  // Escape Markdown special characters: _ * ` [
+  return text
+    .replace(/\\/g, '\\\\')  // Escape backslashes first
+    .replace(/_/g, '\\_')
+    .replace(/\*/g, '\\*')
+    .replace(/`/g, '\\`')
+    .replace(/\[/g, '\\[');
+}
+
+/**
+ * Send a Telegram message
+ */
+async function sendTelegramMessage(chatId, message, options = {}) {
+  if (!BOT_TOKEN) {
+    console.log('[TelegramNotif] ⚠️ TELEGRAM_BOT_TOKEN not set - skipping notification');
+    return false;
+  }
+
+  try {
+    const payload = {
+      chat_id: chatId,
+      text: message,
+      parse_mode: 'Markdown',
+      disable_web_page_preview: true,
+      ...options
+    };
+
+    console.log(`[TelegramNotif] 🚀 Calling Telegram API for chat_id: ${chatId}`);
+    const response = await axios.post(`${TELEGRAM_API}/sendMessage`, payload);
+    
+    if (response.data.ok) {
+      console.log(`[TelegramNotif] ✅ Telegram API returned OK for chat_id: ${chatId}`);
+    } else {
+      console.log(`[TelegramNotif] ⚠️ Telegram API returned not OK:`, response.data);
+    }
+    
+    return response.data.ok;
+  } catch (error) {
+    // Log more details about the error
+    if (error.response) {
+      console.error(`[TelegramNotif] ❌ Telegram API error (${error.response.status}):`, error.response.data?.description || error.message);
+    } else {
+      console.error('[TelegramNotif] ❌ Failed to send Telegram message:', error.message);
+    }
+    return false;
+  }
+}
+
+/**
+ * Notify user about game result (DEPRECATED - use notifyGroupGameResult instead)
+ */
+async function notifyGameResult(telegramUserId, gameData, result) {
+  const { gameId, sportsEvent, participants } = gameData;
+  const { winner, homeScore, awayScore } = result;
+  
+  // Find this user's participation
+  const userParticipant = participants?.find(p => p.telegramUserId === telegramUserId);
+  
+  if (!userParticipant) {
+    return false; // User not in this game
+  }
+  
+  const userTeam = userParticipant.teamChoice;
+  const didWin = userTeam === winner;
+  
+  const emoji = didWin ? '🎉' : '😔';
+  const status = didWin ? '*YOU WON!*' : '*Game Over*';
+  const homeTeam = sportsEvent?.strHomeTeam || 'Home';
+  const awayTeam = sportsEvent?.strAwayTeam || 'Away';
+  
+  const claimCommand = didWin ? `/claim ${gameId}` : '';
+  
+  const message = `
+${emoji} *Game Result*
+
+${status}
+
+*${awayTeam}* ${awayScore} - ${homeScore} *${homeTeam}*
+
+${didWin ? '🏆 You picked the winning team!' : '💪 Better luck next time!'}
+
+Your team: ${userTeam === 'home' ? homeTeam : awayTeam}
+Winner: ${winner === 'home' ? homeTeam : awayTeam}
+
+${didWin ? '💰 *Claim your winnings:*\n\`' + claimCommand + '\`\n\n_Tap to copy, then send as a message!_' : ''}
+  `.trim();
+
+  return await sendTelegramMessage(telegramUserId, message);
+}
+
+/**
+ * Notify group chat about game result with winners and losers
+ */
+async function notifyGroupGameResult(gameData, result) {
+  const { gameId, sportsEvent, participants, telegramChatId } = gameData;
+  const { winner, homeScore, awayScore } = result;
+  
+  if (!telegramChatId) {
+    console.log('⚠️ No telegramChatId found - cannot send group notification');
+    return false;
+  }
+  
+  const homeTeam = sportsEvent?.strHomeTeam || 'Home';
+  const awayTeam = sportsEvent?.strAwayTeam || 'Away';
+  
+  // Separate winners and losers
+  const winners = [];
+  const losers = [];
+  
+  participants?.forEach(participant => {
+    const didWin = participant.teamChoice === winner;
+    const username = participant.username || 'User';
+    
+    if (didWin) {
+      winners.push(username);
+    } else {
+      losers.push(username);
+    }
+  });
+  
+  // Build the message
+  let message = `
+🏁 *GAME FINISHED!*
+
+*${awayTeam}* ${awayScore} - ${homeScore} *${homeTeam}*
+
+🏆 *Winner:* ${winner === 'home' ? homeTeam : awayTeam}
+`;
+
+  if (winners.length > 0) {
+    message += `\n\n🎉 *Winners:*\n`;
+    winners.forEach(username => {
+      message += `• ${username}\n`;
+    });
+    message += `\n💰 *Claim your winnings:*\n\`/claim ${gameId}\`\n\n_Tap to copy, then send as a message!_`;
+  }
+  
+  if (losers.length > 0) {
+    message += `\n\n😔 *Better luck next time:*\n`;
+    losers.forEach(username => {
+      message += `• ${username}\n`;
+    });
+  }
+  
+  message = message.trim();
+  
+  return await sendTelegramMessage(telegramChatId, message);
+}
+
+/**
+ * Get Telegram user IDs from wallet addresses (requires mapping)
+ * For now, you'll need to store wallet -> telegramUserId mapping
+ */
+async function getParticipantTelegramIds(gameData) {
+  // TODO: Implement wallet address -> Telegram ID mapping
+  // This could be done via:
+  // 1. Firebase lookup
+  // 2. Bot's userManager (needs to be accessible)
+  // 3. Separate database
+  
+  // For now, return empty array
+  // You'll need to add this mapping when users create games
+  return [];
+}
+
+/**
+ * Notify group chat that game is starting soon (10 min warning)
+ */
+async function notifyGameStartingSoon(gameData, minutesUntilStart) {
+  const { gameId, sportsEvent, participants, telegramChatId } = gameData;
+  
+  if (!telegramChatId) {
+    console.log('⚠️ No telegramChatId found - cannot send group notification');
+    return false;
+  }
+  
+  const homeTeam = sportsEvent?.strHomeTeam || 'Home';
+  const awayTeam = sportsEvent?.strAwayTeam || 'Away';
+  
+  // Build the message
+  let message = `
+⏰ *GAME STARTING SOON!*
+
+*${awayTeam}* @ *${homeTeam}*
+
+🔒 Betting closes in *${minutesUntilStart} minute${minutesUntilStart !== 1 ? 's' : ''}*!
+
+`;
+
+  if (participants && participants.length > 0) {
+    message += `👥 *Current Bets:* ${participants.length} player${participants.length !== 1 ? 's' : ''}\n`;
+    
+    const homeCount = participants.filter(p => p.teamChoice === 'home').length;
+    const awayCount = participants.filter(p => p.teamChoice === 'away').length;
+    
+    if (homeCount > 0 || awayCount > 0) {
+      message += `   • ${homeTeam}: ${homeCount}\n`;
+      message += `   • ${awayTeam}: ${awayCount}\n`;
+    }
+  }
+  
+  message += `\n⚡ Last chance to join: \`/join ${gameId}\``;
+  message = message.trim();
+  
+  return await sendTelegramMessage(telegramChatId, message);
+}
+
+/**
+ * Notify group chat that game is starting NOW (betting closed)
+ */
+async function notifyGameStartingNow(gameData) {
+  const { gameId, sportsEvent, participants, telegramChatId } = gameData;
+  
+  if (!telegramChatId) {
+    console.log('⚠️ No telegramChatId found - cannot send group notification');
+    return false;
+  }
+  
+  const homeTeam = sportsEvent?.strHomeTeam || 'Home';
+  const awayTeam = sportsEvent?.strAwayTeam || 'Away';
+  
+  // Build the message
+  let message = `
+🚨 *GAME STARTING NOW!*
+
+*${awayTeam}* @ *${homeTeam}*
+
+🔒 *Betting is now CLOSED*
+
+`;
+
+  if (participants && participants.length > 0) {
+    const homeCount = participants.filter(p => p.teamChoice === 'home').length;
+    const awayCount = participants.filter(p => p.teamChoice === 'away').length;
+    
+    message += `👥 *Final Bets:* ${participants.length} player${participants.length !== 1 ? 's' : ''}\n`;
+    message += `   🏠 ${homeTeam}: ${homeCount}\n`;
+    message += `   ✈️  ${awayTeam}: ${awayCount}\n\n`;
+    
+    message += `🎮 *Game is LIVE!* Good luck everyone! 🍀\n`;
+    message += `\n📊 Results will be posted automatically when the game finishes.`;
+  } else {
+    message += `_No bets placed on this game._`;
+  }
+  
+  message = message.trim();
+  
+  return await sendTelegramMessage(telegramChatId, message);
+}
+
+/**
+ * Forward chat notification to Telegram if user has connected their account
+ * @param {object} pool - Database pool
+ * @param {string} userId - User ID to send notification to
+ * @param {string} notificationType - Type of notification (game_invite, game_joined, etc.)
+ * @param {string} senderUsername - Username of the sender
+ * @param {string} message - Notification message text
+ * @param {object} metadata - Optional metadata (e.g., { gameId: 'sport-xxx' } for game invites)
+ */
+async function forwardChatNotification(pool, userId, notificationType, senderUsername, message = '', metadata = {}) {
+  try {
+    console.log(`[TelegramNotif] 📤 Attempting to forward ${notificationType} notification to user ${userId} from @${senderUsername}`);
+    
+    // Get user's telegram_user_id and preferences
+    const result = await pool.query(
+      `SELECT u.telegram_user_id, u.username,
+              COALESCE(p.notify_reply, true) as notify_reply,
+              COALESCE(p.notify_reaction, true) as notify_reaction,
+              COALESCE(p.notify_friend_request, true) as notify_friend_request,
+              COALESCE(p.notify_friend_request_accepted, true) as notify_friend_request_accepted,
+              COALESCE(p.notify_friend_request_declined, true) as notify_friend_request_declined,
+              COALESCE(p.notify_referral, true) as notify_referral,
+              COALESCE(p.notify_mention, true) as notify_mention,
+              COALESCE(p.notify_friend_message, true) as notify_friend_message,
+              COALESCE(p.notify_game_joined, true) as notify_game_joined,
+              COALESCE(p.notify_game_invite, true) as notify_game_invite
+       FROM users u
+       LEFT JOIN telegram_notification_preferences p ON u.id = p.user_id
+       WHERE u.id = $1 AND u.telegram_user_id IS NOT NULL`,
+      [userId]
+    );
+
+    if (result.rows.length === 0) {
+      console.log(`[TelegramNotif] ⏭️ User ${userId} doesn't have Telegram connected - skipping`);
+      return false; // User doesn't have Telegram connected
+    }
+
+    const prefs = result.rows[0];
+    const telegramUserId = prefs.telegram_user_id;
+    const recipientUsername = prefs.username;
+    
+    console.log(`[TelegramNotif] 👤 Found user @${recipientUsername} with Telegram ID: ${telegramUserId}`);
+
+    // Check if user wants this notification type
+    const prefMap = {
+      'reply': prefs.notify_reply,
+      'reaction': prefs.notify_reaction,
+      'friend_request': prefs.notify_friend_request,
+      'friend_request_accepted': prefs.notify_friend_request_accepted,
+      'friend_request_declined': prefs.notify_friend_request_declined,
+      'referral': prefs.notify_referral,
+      'mention': prefs.notify_mention,
+      'friend_message': prefs.notify_friend_message,
+      'game_joined': prefs.notify_game_joined,
+      'game_invite': prefs.notify_game_invite,
+      'dm_message': prefs.notify_friend_message, // Use friend_message pref for DMs
+      'connect4_your_turn': prefs.notify_game_invite, // Use game_invite pref for Connect4 turn notifications
+    };
+
+    if (prefMap[notificationType] === false) {
+      console.log(`[TelegramNotif] 🔇 User @${recipientUsername} has disabled ${notificationType} notifications - skipping`);
+      return false; // User disabled this notification type
+    }
+
+    // Format notification message based on type
+    // Escape user-generated content to prevent Markdown parse errors
+    const safeSenderUsername = escapeMarkdown(senderUsername);
+    const safeMessage = escapeMarkdown(message);
+    
+    let notificationText = '🔔 *Notification*\n\n';
+    
+    switch (notificationType) {
+      case 'reply':
+        notificationText += `${safeSenderUsername} replied to your message`;
+        if (safeMessage) notificationText += `\n\n"${safeMessage}"`;
+        break;
+      case 'reaction':
+        notificationText += `${safeSenderUsername} reacted ${safeMessage} to your message`;
+        break;
+      case 'friend_request':
+        notificationText += `${safeSenderUsername} sent you a friend request`;
+        break;
+      case 'friend_request_accepted':
+        notificationText += `${safeSenderUsername} accepted your friend request!`;
+        break;
+      case 'friend_request_declined':
+        notificationText += `${safeSenderUsername} declined your friend request`;
+        break;
+      case 'referral':
+        notificationText += `🎉 ${safeSenderUsername} joined using your referral code!`;
+        break;
+      case 'game_joined':
+        notificationText += `🏆 ${safeSenderUsername} joined your bet!\n\n${safeMessage}`;
+        break;
+      case 'game_invite':
+        notificationText += `🎮 ${safeSenderUsername} invited you to join their bet!\n\n${safeMessage}`;
+        // CTA button will be added below if gameId is provided
+        break;
+      case 'mention':
+        notificationText += `${safeSenderUsername} mentioned you`;
+        if (safeMessage) notificationText += `\n\n"${safeMessage}"`;
+        break;
+      case 'friend_message':
+        notificationText += `${safeSenderUsername} sent you a message`;
+        if (safeMessage) notificationText += `\n\n"${safeMessage}"`;
+        break;
+      case 'dm_message':
+        notificationText += `💬 ${safeSenderUsername} sent you a direct message`;
+        if (safeMessage) notificationText += `\n\n"${safeMessage}"`;
+        break;
+      case 'game_won':
+        notificationText = `🏆 *You Won!*\n\n${safeMessage}`;
+        break;
+      case 'game_lost':
+        notificationText = `🎱 *Game Finished*\n\n${safeMessage}`;
+        break;
+      case 'game_starting_soon':
+        notificationText = `⏰ *Game Starting Soon!*\n\n${safeMessage}`;
+        break;
+      case 'game_starting_now':
+        notificationText = `🚨 *Game Starting NOW!*\n\n${safeMessage}`;
+        break;
+      case 'whats_new':
+        notificationText = `✨ *What's New on Dubs!*\n\n${safeMessage}`;
+        break;
+      case 'connect4_your_turn':
+        notificationText = `🔴🟡 *Your Turn!*\n\n${safeSenderUsername} made a move in 4 the Pot - it's your turn!`;
+        break;
+      default:
+        notificationText += `${safeSenderUsername} - ${notificationType}`;
+    }
+
+    console.log(`[TelegramNotif] 📨 Sending ${notificationType} notification to Telegram user ${telegramUserId}...`);
+    
+    // Build message options (CTA buttons for certain notification types)
+    const messageOptions = {};
+    
+    // Add CTA button for game-related notifications
+    if (metadata.gameId) {
+      const gameUrl = urlHelper.getGameShareUrl(metadata.gameId);
+      console.log(`[TelegramNotif] 🔗 Adding CTA button with URL: ${gameUrl}`);
+      
+      // Different button text based on notification type
+      let buttonText = '🎮 View Game';
+      if (notificationType === 'game_invite') {
+        buttonText = '🎮 Join Game';
+      } else if (notificationType === 'game_joined') {
+        buttonText = '🎮 View Game';
+      } else if (notificationType === 'connect4_your_turn') {
+        buttonText = '🔴🟡 Make Your Move';
+      }
+      
+      messageOptions.reply_markup = {
+        inline_keyboard: [[
+          { text: buttonText, url: gameUrl }
+        ]]
+      };
+    }
+    
+    // Add CTA button for What's New notifications
+    if (notificationType === 'whats_new' && metadata.postId) {
+      const whatsNewUrl = urlHelper.getWhatsNewUrl(metadata.postId);
+      console.log(`[TelegramNotif] 🔗 Adding What's New CTA button with URL: ${whatsNewUrl}`);
+      
+      messageOptions.reply_markup = {
+        inline_keyboard: [[
+          { text: '✨ See What\'s New', url: whatsNewUrl }
+        ]]
+      };
+    }
+    
+    const sent = await sendTelegramMessage(telegramUserId, notificationText, messageOptions);
+    
+    if (sent) {
+      console.log(`[TelegramNotif] ✅ Successfully sent ${notificationType} notification to @${recipientUsername}`);
+    } else {
+      console.log(`[TelegramNotif] ❌ Failed to send ${notificationType} notification to @${recipientUsername}`);
+    }
+    
+    return sent;
+  } catch (error) {
+    console.error(`[TelegramNotif] ❌ Error forwarding ${notificationType} notification to Telegram:`, error.message);
+    return false;
+  }
+}
+
+module.exports = {
+  sendTelegramMessage,
+  notifyGameResult,
+  notifyGroupGameResult,
+  notifyGameStartingSoon,
+  notifyGameStartingNow,
+  getParticipantTelegramIds,
+  forwardChatNotification
+};
+