dubs-server 1.0.0

package/routes/survivorRoutes.js

@@ -0,0 +1,756 @@
+/**
+ * Survivor Pool Routes
+ * API endpoints for March Madness Survivor Pool feature
+ */
+
+const express = require('express');
+const router = express.Router();
+const survivorController = require('../controllers/survivorController');
+const { pool } = require('../services/db');
+const { authenticate } = require('../middleware/authenticate');
+
+// Socket.IO for real-time updates
+let io = null;
+
+// Inject Socket.IO instance
+router.setSocketIO = (ioInstance) => {
+  io = ioInstance;
+  console.log('[Survivor] Socket.IO injected');
+};
+
+// ============================================
+// POOL MANAGEMENT
+// ============================================
+
+/**
+ * POST /api/survivor/pools
+ * Create a new survivor pool (admin only)
+ */
+router.post('/pools', async (req, res) => {
+  try {
+    const { name, year, buyInLamports, roundDeadline, allowSameTeamTwice, solanaGameId } = req.body;
+
+    // Get creator from auth header or body
+    const createdBy = req.body.createdBy || req.headers['x-wallet-address'];
+
+    if (!name || !year || !buyInLamports) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required fields: name, year, buyInLamports'
+      });
+    }
+
+    const pool = await survivorController.createPool({
+      name,
+      year,
+      buyInLamports,
+      roundDeadline,
+      allowSameTeamTwice,
+      solanaGameId,
+      createdBy
+    });
+
+    res.json({
+      success: true,
+      pool
+    });
+  } catch (error) {
+    console.error('[Survivor] Error creating pool:', error.message);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * GET /api/survivor/pools
+ * List all survivor pools
+ */
+router.get('/pools', async (req, res) => {
+  try {
+    const { status, year } = req.query;
+    const pools = await survivorController.getPools({ status, year: year ? parseInt(year) : undefined });
+
+    res.json({
+      success: true,
+      pools
+    });
+  } catch (error) {
+    console.error('[Survivor] Error listing pools:', error.message);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * GET /api/survivor/pools/:id
+ * Get pool details with leaderboard
+ */
+router.get('/pools/:id', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const survivorPool = await survivorController.getPoolById(poolId);
+
+    if (!survivorPool) {
+      return res.status(404).json({
+        success: false,
+        error: 'Pool not found'
+      });
+    }
+
+    // Get stats
+    const stats = await survivorController.getPoolStats(poolId);
+
+    // Get alive entries for leaderboard
+    const aliveEntries = await survivorController.getAliveEntries(poolId);
+
+    res.json({
+      success: true,
+      pool: survivorPool,
+      stats,
+      leaderboard: aliveEntries.slice(0, 20) // Top 20 for preview
+    });
+  } catch (error) {
+    console.error('[Survivor] Error getting pool:', error.message);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * PATCH /api/survivor/pools/:id
+ * Update pool settings (admin only)
+ */
+router.patch('/pools/:id', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const updates = req.body;
+
+    const updatedPool = await survivorController.updatePool(poolId, updates);
+
+    if (!updatedPool) {
+      return res.status(404).json({
+        success: false,
+        error: 'Pool not found'
+      });
+    }
+
+    // Emit update via Socket.IO if available
+    if (io) {
+      io.emit('survivor:pool_updated', { poolId, pool: updatedPool });
+    }
+
+    res.json({
+      success: true,
+      pool: updatedPool
+    });
+  } catch (error) {
+    console.error('[Survivor] Error updating pool:', error.message);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+// ============================================
+// ENTRY MANAGEMENT
+// ============================================
+
+/**
+ * POST /api/survivor/pools/:id/join
+ * Join a survivor pool
+ */
+router.post('/pools/:id/join', authenticate, async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const { userId, walletAddress } = req.user;
+    const { txSignature } = req.body;
+
+    const entry = await survivorController.joinPool({
+      poolId,
+      userId,
+      walletAddress,
+      txSignature
+    });
+
+    // Emit join event via Socket.IO
+    if (io) {
+      io.emit('survivor:entry_joined', { poolId, entry });
+    }
+
+    res.json({
+      success: true,
+      entry
+    });
+  } catch (error) {
+    console.error('[Survivor] Error joining pool:', error.message);
+    res.status(400).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * GET /api/survivor/pools/:id/my-entry
+ * Get current user's entry and picks
+ */
+router.get('/pools/:id/my-entry', authenticate, async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const { userId } = req.user;
+
+    const entryWithPicks = await survivorController.getUserEntry(poolId, userId);
+
+    if (!entryWithPicks) {
+      return res.status(404).json({
+        success: false,
+        error: 'Entry not found - user has not joined this pool'
+      });
+    }
+
+    // Get pool info too
+    const survivorPool = await survivorController.getPoolById(poolId);
+
+    // Extract picks from entry and format response
+    const { picks, ...entry } = entryWithPicks;
+
+    res.json({
+      success: true,
+      entry,
+      picks: picks || [],
+      pool: survivorPool
+    });
+  } catch (error) {
+    console.error('[Survivor] Error getting user entry:', error.message);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+// ============================================
+// PICKS
+// ============================================
+
+/**
+ * GET /api/survivor/pools/:id/teams
+ * Get available teams for current round
+ */
+router.get('/pools/:id/teams', authenticate, async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const { userId } = req.user;
+
+    const teamsData = await survivorController.getAvailableTeams(poolId, userId);
+
+    res.json({
+      success: true,
+      ...teamsData
+    });
+  } catch (error) {
+    console.error('[Survivor] Error getting teams:', error.message);
+    res.status(400).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * POST /api/survivor/pools/:id/pick
+ * Submit pick for current round
+ */
+router.post('/pools/:id/pick', authenticate, async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const { userId } = req.user;
+    const { teamId, teamName, teamSeed, teamLogo, espnGameId, opponentName, opponentSeed } = req.body;
+
+    if (!teamId || !teamName) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required fields: teamId, teamName'
+      });
+    }
+
+    const pick = await survivorController.submitPick({
+      poolId,
+      userId,
+      teamId,
+      teamName,
+      teamSeed,
+      teamLogo,
+      espnGameId,
+      opponentName,
+      opponentSeed
+    });
+
+    // Emit pick event via Socket.IO
+    if (io) {
+      io.emit('survivor:pick_submitted', { poolId, userId, pick });
+    }
+
+    res.json({
+      success: true,
+      pick
+    });
+  } catch (error) {
+    console.error('[Survivor] Error submitting pick:', error.message);
+    res.status(400).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * GET /api/survivor/pools/:id/picks
+ * Get all picks for user
+ */
+router.get('/pools/:id/picks', authenticate, async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const { userId } = req.user;
+
+    const picks = await survivorController.getUserPicks(poolId, userId);
+
+    res.json({
+      success: true,
+      picks
+    });
+  } catch (error) {
+    console.error('[Survivor] Error getting picks:', error.message);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+// ============================================
+// LEADERBOARD
+// ============================================
+
+/**
+ * GET /api/survivor/pools/:id/alive
+ * Get surviving entries
+ */
+router.get('/pools/:id/alive', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const entries = await survivorController.getAliveEntries(poolId);
+
+    res.json({
+      success: true,
+      count: entries.length,
+      entries
+    });
+  } catch (error) {
+    console.error('[Survivor] Error getting alive entries:', error.message);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * GET /api/survivor/pools/:id/eliminated
+ * Get eliminated entries
+ */
+router.get('/pools/:id/eliminated', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const entries = await survivorController.getEliminatedEntries(poolId);
+
+    res.json({
+      success: true,
+      count: entries.length,
+      entries
+    });
+  } catch (error) {
+    console.error('[Survivor] Error getting eliminated entries:', error.message);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * GET /api/survivor/pools/:id/stats
+ * Get pool statistics
+ */
+router.get('/pools/:id/stats', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const stats = await survivorController.getPoolStats(poolId);
+
+    res.json({
+      success: true,
+      stats
+    });
+  } catch (error) {
+    console.error('[Survivor] Error getting stats:', error.message);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+// ============================================
+// ADMIN / ORACLE ENDPOINTS
+// ============================================
+
+/**
+ * POST /api/survivor/pools/:id/games
+ * Import tournament games (admin)
+ */
+router.post('/pools/:id/games', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const { games } = req.body;
+
+    if (!games || !Array.isArray(games)) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required field: games (array)'
+      });
+    }
+
+    const importedGames = await survivorController.importTournamentGames(poolId, games);
+
+    res.json({
+      success: true,
+      count: importedGames.length,
+      games: importedGames
+    });
+  } catch (error) {
+    console.error('[Survivor] Error importing games:', error.message);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * GET /api/survivor/pools/:id/games
+ * Get tournament games for a pool
+ */
+router.get('/pools/:id/games', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const { round } = req.query;
+
+    console.log(`[Survivor] GET /games - poolId: ${poolId}, round: ${round || 'all'}`);
+
+    let query = 'SELECT * FROM survivor_tournament_games WHERE pool_id = $1';
+    const params = [poolId];
+
+    if (round) {
+      params.push(parseInt(round));
+      query += ` AND round = $${params.length}`;
+    }
+
+    query += ' ORDER BY round, game_date, id';
+
+    const result = await pool.query(query, params);
+
+    console.log(`[Survivor] GET /games - found ${result.rows.length} games`);
+
+    res.json({
+      success: true,
+      count: result.rows.length,
+      games: result.rows
+    });
+  } catch (error) {
+    console.error('[Survivor] Error getting games:', error.message);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * POST /api/survivor/pools/:id/resolve
+ * Resolve current round (oracle)
+ * Called by survivorOracle service after games complete
+ */
+router.post('/pools/:id/resolve', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+
+    // This endpoint is called by the oracle service
+    // Import the oracle and trigger resolution
+    const survivorOracle = require('../services/survivorOracle');
+    const result = await survivorOracle.resolveCurrentRound(poolId);
+
+    // Emit round resolved event
+    if (io) {
+      io.emit('survivor:round_resolved', { poolId, result });
+    }
+
+    res.json({
+      success: true,
+      result
+    });
+  } catch (error) {
+    console.error('[Survivor] Error resolving round:', error.message);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+// ============================================
+// DEV / SIMULATION ENDPOINTS (development only)
+// ============================================
+
+// Only enable in development
+if (process.env.NODE_ENV === 'development' || process.env.ENABLE_SURVIVOR_DEV === 'true') {
+  const survivorSimulator = require('../services/survivorSimulator');
+
+  /**
+   * POST /api/survivor/dev/pools/:id/generate-bracket
+   * Generate mock tournament bracket for testing
+   */
+  router.post('/dev/pools/:id/generate-bracket', async (req, res) => {
+    try {
+      const poolId = parseInt(req.params.id);
+      const games = await survivorSimulator.generateTournamentBracket(poolId);
+
+      // Emit pool updated for real-time bracket refresh
+      if (io) {
+        const updatedPool = await survivorController.getPoolById(poolId);
+        if (updatedPool) {
+          io.emit('survivor:pool_updated', { poolId, pool: updatedPool });
+        }
+      }
+
+      res.json({
+        success: true,
+        message: `Generated ${games.length} tournament games`,
+        count: games.length
+      });
+    } catch (error) {
+      console.error('[Survivor:Dev] Error generating bracket:', error.message);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * POST /api/survivor/dev/pools/:id/simulate-round
+   * Simulate current round with random results
+   */
+  router.post('/dev/pools/:id/simulate-round', async (req, res) => {
+    try {
+      const poolId = parseInt(req.params.id);
+      const { upsetChance = 0.2, favorChalk = false } = req.body;
+
+      const result = await survivorSimulator.simulateRound(poolId, { upsetChance, favorChalk });
+
+      // Emit round resolved event for real-time updates
+      if (io && result.resolution) {
+        io.emit('survivor:round_resolved', { poolId, result: result.resolution });
+
+        // Also emit pool updated with latest pool state
+        const updatedPool = await survivorController.getPoolById(poolId);
+        if (updatedPool) {
+          io.emit('survivor:pool_updated', { poolId, pool: updatedPool });
+        }
+      }
+
+      res.json({
+        success: true,
+        result
+      });
+    } catch (error) {
+      console.error('[Survivor:Dev] Error simulating round:', error.message);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * POST /api/survivor/dev/pools/:id/generate-entries
+   * Generate test entries with random picks
+   */
+  router.post('/dev/pools/:id/generate-entries', async (req, res) => {
+    try {
+      const poolId = parseInt(req.params.id);
+      const { count = 10 } = req.body;
+
+      const result = await survivorSimulator.generateTestEntries(poolId, count);
+
+      res.json({
+        success: true,
+        result
+      });
+    } catch (error) {
+      console.error('[Survivor:Dev] Error generating entries:', error.message);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * POST /api/survivor/dev/pools/:id/set-deadline
+   * Set round deadline to N minutes from now
+   */
+  router.post('/dev/pools/:id/set-deadline', async (req, res) => {
+    try {
+      const poolId = parseInt(req.params.id);
+      const { minutes = 5 } = req.body;
+
+      const result = await survivorSimulator.setDeadline(poolId, minutes);
+
+      // Emit pool updated for real-time refresh
+      if (io) {
+        const updatedPool = await survivorController.getPoolById(poolId);
+        if (updatedPool) {
+          io.emit('survivor:pool_updated', { poolId, pool: updatedPool });
+        }
+      }
+
+      res.json({
+        success: true,
+        result
+      });
+    } catch (error) {
+      console.error('[Survivor:Dev] Error setting deadline:', error.message);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * POST /api/survivor/dev/pools/:id/reset
+   * Reset pool to round 1
+   * Body: { deleteEntries: boolean } - if true, also delete all entries
+   */
+  router.post('/dev/pools/:id/reset', async (req, res) => {
+    try {
+      const poolId = parseInt(req.params.id);
+      const { deleteEntries = false } = req.body;
+
+      const result = await survivorSimulator.resetPool(poolId, { deleteEntries });
+
+      // Emit pool updated for real-time refresh
+      if (io) {
+        const updatedPool = await survivorController.getPoolById(poolId);
+        if (updatedPool) {
+          io.emit('survivor:pool_updated', { poolId, pool: updatedPool });
+        }
+      }
+
+      res.json({
+        success: true,
+        result
+      });
+    } catch (error) {
+      console.error('[Survivor:Dev] Error resetting pool:', error.message);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * POST /api/survivor/dev/pools/:id/activate
+   * Activate pool and set to round 2
+   */
+  router.post('/dev/pools/:id/activate', async (req, res) => {
+    try {
+      const poolId = parseInt(req.params.id);
+      const result = await survivorSimulator.activatePool(poolId);
+
+      // Emit pool updated for real-time refresh
+      if (io) {
+        const updatedPool = await survivorController.getPoolById(poolId);
+        if (updatedPool) {
+          io.emit('survivor:pool_updated', { poolId, pool: updatedPool });
+        }
+      }
+
+      res.json({
+        success: true,
+        result
+      });
+    } catch (error) {
+      console.error('[Survivor:Dev] Error activating pool:', error.message);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * DELETE /api/survivor/dev/pools/:id/test-entries
+   * Delete test entries (cleanup)
+   */
+  router.delete('/dev/pools/:id/test-entries', async (req, res) => {
+    try {
+      const poolId = parseInt(req.params.id);
+      const result = await survivorSimulator.deleteTestEntries(poolId);
+
+      res.json({
+        success: true,
+        result
+      });
+    } catch (error) {
+      console.error('[Survivor:Dev] Error deleting test entries:', error.message);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * GET /api/survivor/dev/teams
+   * Get list of mock tournament teams
+   */
+  router.get('/dev/teams', async (req, res) => {
+    try {
+      const { MOCK_TEAMS } = require('../services/survivorSimulator');
+      res.json({
+        success: true,
+        count: MOCK_TEAMS.length,
+        teams: MOCK_TEAMS
+      });
+    } catch (error) {
+      console.error('[Survivor:Dev] Error getting teams:', error.message);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  console.log('[Survivor] Dev/simulation endpoints enabled');
+}
+
+module.exports = router;