dubs-server 1.0.0

package/controllers/livescoresController.js

@@ -0,0 +1,376 @@
+/**
+ * 🏀 Live Scores Controller
+ *
+ * Fetches live sports scores from ESPN API
+ * Supports: MLB, NBA, NHL, NFL, EPL, UFC, NCAAF, NCAAB
+ */
+
+const axios = require('axios');
+
+const ESPN_URLS = {
+  MLB: 'https://site.api.espn.com/apis/site/v2/sports/baseball/mlb/scoreboard',
+  NBA: 'https://site.api.espn.com/apis/site/v2/sports/basketball/nba/scoreboard',
+  NHL: 'https://site.api.espn.com/apis/site/v2/sports/hockey/nhl/scoreboard',
+  NFL: 'https://site.api.espn.com/apis/site/v2/sports/football/nfl/scoreboard',
+  EPL: 'https://site.api.espn.com/apis/site/v2/sports/soccer/eng.1/scoreboard',
+  UFC: 'https://site.api.espn.com/apis/site/v2/sports/mma/ufc/scoreboard',
+  NCAAF: 'https://site.api.espn.com/apis/site/v2/sports/football/college-football/scoreboard',
+  NCAAB: 'https://site.api.espn.com/apis/site/v2/sports/basketball/mens-college-basketball/scoreboard'
+};
+
+/**
+ * Fetch and parse scores for a specific league
+ */
+async function fetchScoresForLeague(url, league) {
+  try {
+    console.log(`[LiveScores] Fetching scores from: ${url}`);
+    const { data } = await axios.get(url);
+
+    let scores = data.events.map(event => {
+      const competition = event.competitions?.[0];
+      const competitors = competition?.competitors || [];
+      const statusObj = event.status || {};
+
+      return {
+        date: event.date.split('T')[0],
+        game: event.name,
+        status: statusObj.type?.description || 'Unknown',
+        // Period/quarter info from ESPN
+        period: statusObj.period || null,
+        displayClock: statusObj.displayClock || null,
+        detail: statusObj.type?.detail || null,
+        shortDetail: statusObj.type?.shortDetail || null,
+        competitors: competitors.map(team => ({
+          name: team.team?.displayName,
+          homeAway: team.homeAway,
+          score: parseInt(team.score, 10) || 0,
+          logo: team.team?.logo || null,
+          abbreviation: team.team?.abbreviation || ''
+        }))
+      };
+    });
+
+    // In development, append mock data for testing
+    if (process.env.NODE_ENV === 'development') {
+      const today = new Date().toISOString().split('T')[0];
+
+      // Mock NBA game (Amy wins)
+      if (league === 'NBA') {
+        scores.push({
+          date: today,
+          game: "Amy @ Adam",
+          status: "Final",
+          competitors: [
+            { name: "Amy", homeAway: "away", score: 3 },
+            { name: "Adam", homeAway: "home", score: 2 }
+          ]
+        });
+      }
+
+      // Mock EPL game (Draw - equal scores for testing draw betting)
+      if (league === 'EPL') {
+        scores.push({
+          date: today,
+          game: "Chelsea @ Arsenal",
+          status: "Final",
+          competitors: [
+            { name: "Chelsea", homeAway: "away", score: 1 },
+            { name: "Arsenal", homeAway: "home", score: 1 }
+          ]
+        });
+      }
+
+      // Mock NCAAF game (Ohio State wins)
+      if (league === 'NCAAF') {
+        scores.push({
+          date: today,
+          game: "Michigan @ Ohio State",
+          status: "Final",
+          competitors: [
+            { name: "Michigan", homeAway: "away", score: 24 },
+            { name: "Ohio State", homeAway: "home", score: 31 }
+          ]
+        });
+      }
+
+      // Mock NCAAB game (Duke wins)
+      if (league === 'NCAAB') {
+        scores.push({
+          date: today,
+          game: "North Carolina @ Duke",
+          status: "Final",
+          competitors: [
+            { name: "North Carolina", homeAway: "away", score: 78 },
+            { name: "Duke", homeAway: "home", score: 85 }
+          ]
+        });
+      }
+    }
+
+    console.log(`[LiveScores] Successfully fetched ${scores.length} games`);
+    return scores;
+
+  } catch (error) {
+    console.error(`[LiveScores] Failed to fetch from ${url}:`, error.message);
+    return [];
+  }
+}
+
+/**
+ * ═══════════════════════════════════════════════════════════════════════════
+ * 🥊 UFC SCORES - ISOLATED HANDLER
+ * ═══════════════════════════════════════════════════════════════════════════
+ * This function is completely separate from team sports to prevent regressions.
+ * UFC data structure is different: individual fighters with winner:boolean
+ * instead of teams with scores.
+ *
+ * Transforms UFC data to match the standard format expected by the oracle:
+ * - winner:true  → score: 1
+ * - winner:false → score: 0
+ * - competitor order 1 → homeAway: 'home'
+ * - competitor order 2 → homeAway: 'away'
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+async function fetchUFCScores(url) {
+  try {
+    console.log(`[LiveScores:UFC] Fetching UFC scores from: ${url}`);
+    const { data } = await axios.get(url);
+
+    const scores = [];
+
+    // ESPN UFC returns events, each containing multiple competitions (fights)
+    if (!data.events || !Array.isArray(data.events)) {
+      console.log(`[LiveScores:UFC] No events found in response`);
+      return scores;
+    }
+
+    for (const event of data.events) {
+      // Each event (e.g., "UFC 324") contains multiple competitions (fights)
+      if (!event.competitions || !Array.isArray(event.competitions)) {
+        continue;
+      }
+
+      for (const competition of event.competitions) {
+        // Each competition is a single fight between two fighters
+        const competitors = competition.competitors || [];
+
+        if (competitors.length !== 2) {
+          continue; // Skip if not exactly 2 fighters
+        }
+
+        // Determine fight status
+        const status = competition.status?.type;
+        let statusDescription = status?.description || 'Unknown';
+
+        // Map UFC status to standard format the oracle understands
+        // UFC uses: "Scheduled", "In Progress", "Final", etc.
+        if (status?.completed === true || status?.state === 'post') {
+          statusDescription = 'Final';
+        }
+
+        // Extract UFC-specific live data
+        const currentRound = competition.status?.period || 0;
+        const totalRounds = competition.format?.regulation?.periods || 3; // 3 for regular, 5 for title fights
+        const clock = competition.status?.displayClock || '';
+        const fightState = status?.state || 'pre'; // 'pre', 'in', 'post'
+        const statusDetail = status?.detail || '';
+        const statusShortDetail = status?.shortDetail || '';
+
+        // Parse competitors - order 1 is "home", order 2 is "away"
+        // Transform winner:boolean to score (1 for winner, 0 for loser)
+        const fighter1 = competitors.find(c => c.order === 1) || competitors[0];
+        const fighter2 = competitors.find(c => c.order === 2) || competitors[1];
+
+        // Extract fighter records (e.g., "26-5-0")
+        const fighter1Record = fighter1.records?.find(r => r.name === 'overall')?.summary || '';
+        const fighter2Record = fighter2.records?.find(r => r.name === 'overall')?.summary || '';
+
+        const transformedCompetitors = [
+          {
+            name: fighter1.athlete?.fullName || fighter1.athlete?.displayName || 'Unknown',
+            homeAway: 'home',
+            score: fighter1.winner === true ? 1 : 0,
+            winner: fighter1.winner || false,
+            logo: fighter1.athlete?.flag?.href || null,
+            headshot: fighter1.id ? `https://a.espncdn.com/combiner/i?img=/i/headshots/mma/players/full/${fighter1.id}.png&w=350&h=254` : null,
+            country: fighter1.athlete?.flag?.alt || null,
+            abbreviation: fighter1.athlete?.shortName || '',
+            record: fighter1Record,
+            athleteId: fighter1.id || null
+          },
+          {
+            name: fighter2.athlete?.fullName || fighter2.athlete?.displayName || 'Unknown',
+            homeAway: 'away',
+            score: fighter2.winner === true ? 1 : 0,
+            winner: fighter2.winner || false,
+            logo: fighter2.athlete?.flag?.href || null,
+            headshot: fighter2.id ? `https://a.espncdn.com/combiner/i?img=/i/headshots/mma/players/full/${fighter2.id}.png&w=350&h=254` : null,
+            country: fighter2.athlete?.flag?.alt || null,
+            abbreviation: fighter2.athlete?.shortName || '',
+            record: fighter2Record,
+            athleteId: fighter2.id || null
+          }
+        ];
+
+        // Extract date from competition or event
+        const fightDate = competition.date || event.date;
+        const dateOnly = fightDate ? fightDate.split('T')[0] : null;
+
+        // Build the game name as "Fighter1 vs Fighter2"
+        const gameName = `${transformedCompetitors[0].name} vs ${transformedCompetitors[1].name}`;
+
+        scores.push({
+          date: dateOnly,
+          game: gameName,
+          status: statusDescription,
+          eventName: event.name || event.shortName, // e.g., "UFC 324: Gaethje vs. Pimblett"
+          weightClass: competition.type?.abbreviation || '', // e.g., "Lightweight"
+          competitionId: competition.id,
+          competitors: transformedCompetitors,
+          // UFC-specific live data
+          ufcData: {
+            currentRound,
+            totalRounds,
+            clock,
+            fightState, // 'pre', 'in', 'post'
+            statusDetail,
+            statusShortDetail
+          }
+        });
+      }
+    }
+
+    console.log(`[LiveScores:UFC] Successfully parsed ${scores.length} fights`);
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // 🧪 MOCK UFC DATA - Development Testing
+    // ═══════════════════════════════════════════════════════════════════════
+    // In development, append mock UFC fights for testing the oracle.
+    // These match the stub events in sportsRoutes.js
+    //
+    // IMPORTANT: The winner mapping:
+    // - homeAway: 'home' = strHomeTeam (fighter 1)
+    // - homeAway: 'away' = strAwayTeam (fighter 2)
+    // - score: 1 = winner, score: 0 = loser
+    // ═══════════════════════════════════════════════════════════════════════
+    if (process.env.NODE_ENV === 'development') {
+      // Use same date calculation as sportsRoutes.js mock event (5 min from now)
+      const startTime = new Date(Date.now() + 5 * 60000);
+      const mockDate = startTime.toISOString().split('T')[0];
+
+      // Mock UFC Fight: Bautista vs Oliveira - Bautista (HOME) WINS
+      // strHomeTeam = "Mario Bautista" → homeAway: 'home' → score: 1 (winner)
+      // strAwayTeam = "Vinicius Oliveira" → homeAway: 'away' → score: 0 (loser)
+      // MUST match sportsRoutes.js mock event fighters!
+      scores.push({
+        date: mockDate,
+        game: "Mario Bautista vs Vinicius Oliveira",
+        status: "Final",
+        eventName: "[MOCK] UFC Fight Night: Bautista vs Oliveira",
+        weightClass: "Bantamweight",
+        competitionId: "mock-ufc-dev-test",
+        competitors: [
+          {
+            name: "Mario Bautista",
+            homeAway: "home",
+            score: 1,  // WINNER
+            winner: true,
+            logo: "https://a.espncdn.com/combiner/i?img=/i/headshots/mma/players/full/4410868.png&w=350&h=254",
+            abbreviation: "Bautista",
+            record: "16-3-0"
+          },
+          {
+            name: "Vinicius Oliveira",
+            homeAway: "away",
+            score: 0,  // LOSER
+            winner: false,
+            logo: "https://a.espncdn.com/combiner/i?img=/i/headshots/mma/players/full/4884877.png&w=350&h=254",
+            abbreviation: "Oliveira",
+            record: "22-4-0"
+          }
+        ],
+        // UFC-specific data
+        ufcData: {
+          currentRound: 3,
+          totalRounds: 5,
+          clock: '',
+          fightState: 'post',
+          statusDetail: 'Decision - Unanimous',
+          statusShortDetail: 'Final - UD'
+        }
+      });
+
+      console.log(`[LiveScores:UFC] Added mock UFC fight for ${mockDate}`);
+    }
+
+    return scores;
+
+  } catch (error) {
+    console.error(`[LiveScores:UFC] Failed to fetch UFC scores:`, error.message);
+    return [];
+  }
+}
+
+/**
+ * GET /api/livescores
+ */
+const getAllLivescores = async (req, res) => {
+  try {
+    const results = {};
+
+    await Promise.all(
+      Object.entries(ESPN_URLS).map(async ([league, url]) => {
+        // Route UFC to isolated handler, all other sports use existing handler
+        if (league === 'UFC') {
+          results[league] = await fetchUFCScores(url);
+        } else {
+          results[league] = await fetchScoresForLeague(url, league);
+        }
+      })
+    );
+
+    res.json({ success: true, data: results });
+
+  } catch (error) {
+    console.error('[LiveScores] Error fetching all livescores:', error);
+    res.status(500).json({ success: false, error: 'Failed to fetch sports scores' });
+  }
+};
+
+/**
+ * GET /api/livescores/:league
+ */
+const getLivescoresByLeague = async (req, res) => {
+  const { league } = req.params;
+  const leagueUpper = league.toUpperCase();
+  const url = ESPN_URLS[leagueUpper];
+
+  if (!url) {
+    return res.status(400).json({
+      success: false,
+      error: `League "${league}" is not supported. Supported leagues: ${Object.keys(ESPN_URLS).join(', ')}`
+    });
+  }
+
+  try {
+    // Route UFC to isolated handler, all other sports use existing handler
+    let scores;
+    if (leagueUpper === 'UFC') {
+      scores = await fetchUFCScores(url);
+    } else {
+      scores = await fetchScoresForLeague(url, leagueUpper);
+    }
+    res.json({ success: true, data: scores });
+  } catch (error) {
+    console.error(`[LiveScores] Error fetching ${leagueUpper} scores:`, error);
+    res.status(500).json({ success: false, error: `Failed to fetch ${leagueUpper} scores` });
+  }
+};
+
+module.exports = {
+  getAllLivescores,
+  getLivescoresByLeague,
+  fetchScoresForLeague,
+  fetchUFCScores,
+  ESPN_URLS,
+};