dubs-server 1.0.0

package/controllers/pickemController.js

@@ -0,0 +1,554 @@
+/**
+ * Pick'em Controller
+ * Business logic for UFC Pick'em pools
+ * Pattern mirrors survivorController.js
+ */
+
+const { pool } = require('../services/db');
+
+const LAMPORTS_PER_SOL = 1_000_000_000;
+const FEE_PERCENT = 6; // 5% operator + 1% oracle
+
+// ========== HELPERS ==========
+
+function formatPool(row) {
+  if (!row) return null;
+  const buyInSol = Number(row.buy_in_lamports) / LAMPORTS_PER_SOL;
+  const totalEntries = Number(row.total_entries || 0);
+  const totalPotLamports = totalEntries * Number(row.buy_in_lamports);
+  const netPotLamports = Math.floor(totalPotLamports * (1 - FEE_PERCENT / 100));
+  return {
+    id: row.id,
+    name: row.name,
+    espnEventId: row.espn_event_id,
+    eventDate: row.event_date,
+    buyInLamports: Number(row.buy_in_lamports),
+    buyInSol,
+    lockTime: row.lock_time,
+    status: row.status,
+    solanaGameId: row.solana_game_id,
+    solanaGameAddress: row.solana_game_address,
+    totalEntries,
+    totalPotLamports,
+    totalPotSol: totalPotLamports / LAMPORTS_PER_SOL,
+    netPotLamports,
+    netPotSol: netPotLamports / LAMPORTS_PER_SOL,
+    createdBy: row.created_by,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+function formatFight(row) {
+  if (!row) return null;
+  return {
+    id: row.id,
+    poolId: row.pool_id,
+    espnCompetitionId: row.espn_competition_id,
+    fightOrder: row.fight_order,
+    fighterA: {
+      name: row.fighter_a_name,
+      headshot: row.fighter_a_headshot,
+      country: row.fighter_a_country,
+      record: row.fighter_a_record,
+    },
+    fighterB: {
+      name: row.fighter_b_name,
+      headshot: row.fighter_b_headshot,
+      country: row.fighter_b_country,
+      record: row.fighter_b_record,
+    },
+    weightClass: row.weight_class,
+    winner: row.winner,
+    method: row.method,
+    status: row.status,
+  };
+}
+
+function formatEntry(row) {
+  if (!row) return null;
+  return {
+    id: row.id,
+    poolId: row.pool_id,
+    userId: row.user_id,
+    walletAddress: row.wallet_address,
+    entryTxSignature: row.entry_tx_signature,
+    score: row.score,
+    rank: row.rank,
+    username: row.username || null,
+    avatar: row.avatar || null,
+    createdAt: row.created_at,
+  };
+}
+
+function formatPick(row) {
+  if (!row) return null;
+  return {
+    id: row.id,
+    entryId: row.entry_id,
+    fightId: row.fight_id,
+    pick: row.pick,
+    isCorrect: row.is_correct,
+    // Joined fight fields (if present)
+    fighterAName: row.fighter_a_name || null,
+    fighterBName: row.fighter_b_name || null,
+    weightClass: row.weight_class || null,
+    fightWinner: row.winner || null,
+    fightStatus: row.fight_status || null,
+  };
+}
+
+// ========== POOL MANAGEMENT ==========
+
+async function createPool({ name, espnEventId, eventDate, lockTime, solanaGameId, solanaGameAddress, createdBy }) {
+  const result = await pool.query(
+    `INSERT INTO pickem_pools (name, espn_event_id, event_date, lock_time, solana_game_id, solana_game_address, created_by)
+     VALUES ($1, $2, $3, $4, $5, $6, $7)
+     RETURNING *`,
+    [name, espnEventId, eventDate, lockTime, solanaGameId || null, solanaGameAddress || null, createdBy || null]
+  );
+  return formatPool(result.rows[0]);
+}
+
+async function getPools({ status } = {}) {
+  let query = 'SELECT * FROM pickem_pools';
+  const params = [];
+  if (status) {
+    query += ' WHERE status = $1';
+    params.push(status);
+  }
+  query += ' ORDER BY event_date DESC';
+  const result = await pool.query(query, params);
+  return result.rows.map(formatPool);
+}
+
+async function getPoolById(poolId) {
+  const result = await pool.query('SELECT * FROM pickem_pools WHERE id = $1', [poolId]);
+  if (result.rows.length === 0) return null;
+  return formatPool(result.rows[0]);
+}
+
+async function updatePool(poolId, updates) {
+  const allowed = ['name', 'lock_time', 'status', 'solana_game_id', 'solana_game_address', 'total_entries'];
+  const setClauses = [];
+  const params = [];
+  let idx = 1;
+
+  for (const [key, value] of Object.entries(updates)) {
+    if (allowed.includes(key)) {
+      setClauses.push(`${key} = $${idx}`);
+      params.push(value);
+      idx++;
+    }
+  }
+  if (setClauses.length === 0) return getPoolById(poolId);
+
+  setClauses.push(`updated_at = NOW()`);
+  params.push(poolId);
+
+  const result = await pool.query(
+    `UPDATE pickem_pools SET ${setClauses.join(', ')} WHERE id = $${idx} RETURNING *`,
+    params
+  );
+  return formatPool(result.rows[0]);
+}
+
+// ========== FIGHT MANAGEMENT ==========
+
+async function importFights(poolId, fights) {
+  const inserted = [];
+  for (const f of fights) {
+    const result = await pool.query(
+      `INSERT INTO pickem_fights (pool_id, espn_competition_id, fight_order,
+        fighter_a_name, fighter_a_headshot, fighter_a_country, fighter_a_record,
+        fighter_b_name, fighter_b_headshot, fighter_b_country, fighter_b_record,
+        weight_class)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+       ON CONFLICT (pool_id, espn_competition_id)
+       DO UPDATE SET
+         fight_order = EXCLUDED.fight_order,
+         fighter_a_name = EXCLUDED.fighter_a_name,
+         fighter_a_headshot = EXCLUDED.fighter_a_headshot,
+         fighter_a_country = EXCLUDED.fighter_a_country,
+         fighter_a_record = EXCLUDED.fighter_a_record,
+         fighter_b_name = EXCLUDED.fighter_b_name,
+         fighter_b_headshot = EXCLUDED.fighter_b_headshot,
+         fighter_b_country = EXCLUDED.fighter_b_country,
+         fighter_b_record = EXCLUDED.fighter_b_record,
+         weight_class = EXCLUDED.weight_class,
+         updated_at = NOW()
+       RETURNING *`,
+      [
+        poolId, f.espnCompetitionId, f.fightOrder,
+        f.fighterAName, f.fighterAHeadshot || null, f.fighterACountry || null, f.fighterARecord || null,
+        f.fighterBName, f.fighterBHeadshot || null, f.fighterBCountry || null, f.fighterBRecord || null,
+        f.weightClass || null,
+      ]
+    );
+    inserted.push(formatFight(result.rows[0]));
+  }
+  return inserted;
+}
+
+async function getFights(poolId) {
+  const result = await pool.query(
+    'SELECT * FROM pickem_fights WHERE pool_id = $1 ORDER BY fight_order ASC',
+    [poolId]
+  );
+  return result.rows.map(formatFight);
+}
+
+async function updateFightResult(fightId, { winner, method, status }) {
+  const result = await pool.query(
+    `UPDATE pickem_fights SET winner = $1, method = $2, status = $3, updated_at = NOW()
+     WHERE id = $4 RETURNING *`,
+    [winner || null, method || null, status, fightId]
+  );
+  return result.rows[0] ? formatFight(result.rows[0]) : null;
+}
+
+// ========== ENTRY MANAGEMENT ==========
+
+async function joinPool({ poolId, userId, walletAddress, txSignature }) {
+  const client = await pool.connect();
+  try {
+    await client.query('BEGIN');
+
+    // Check pool exists and is open
+    const poolResult = await client.query(
+      'SELECT * FROM pickem_pools WHERE id = $1',
+      [poolId]
+    );
+    if (poolResult.rows.length === 0) throw new Error('Pool not found');
+    const pickemPool = poolResult.rows[0];
+    if (pickemPool.status !== 'open') throw new Error(`Pool is ${pickemPool.status}, cannot join`);
+
+    // Insert entry
+    const entryResult = await client.query(
+      `INSERT INTO pickem_entries (pool_id, user_id, wallet_address, entry_tx_signature)
+       VALUES ($1, $2, $3, $4)
+       RETURNING *`,
+      [poolId, userId, walletAddress, txSignature || null]
+    );
+
+    // Increment total_entries
+    await client.query(
+      'UPDATE pickem_pools SET total_entries = total_entries + 1, updated_at = NOW() WHERE id = $1',
+      [poolId]
+    );
+
+    await client.query('COMMIT');
+    return formatEntry(entryResult.rows[0]);
+  } catch (error) {
+    await client.query('ROLLBACK');
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+
+async function getUserEntry(poolId, userId) {
+  const result = await pool.query(
+    `SELECT pe.*, u.username, u.avatar
+     FROM pickem_entries pe
+     LEFT JOIN users u ON pe.user_id = u.id
+     WHERE pe.pool_id = $1 AND pe.user_id = $2`,
+    [poolId, userId]
+  );
+  if (result.rows.length === 0) return null;
+
+  const entry = formatEntry(result.rows[0]);
+
+  // Attach picks
+  const picksResult = await pool.query(
+    `SELECT pp.*, pf.fighter_a_name, pf.fighter_b_name, pf.weight_class, pf.winner, pf.status as fight_status
+     FROM pickem_picks pp
+     JOIN pickem_fights pf ON pp.fight_id = pf.id
+     WHERE pp.entry_id = $1
+     ORDER BY pf.fight_order ASC`,
+    [entry.id]
+  );
+  entry.picks = picksResult.rows.map(formatPick);
+
+  return entry;
+}
+
+// ========== PICKS ==========
+
+async function submitPicks({ poolId, userId, picks }) {
+  const client = await pool.connect();
+  try {
+    await client.query('BEGIN');
+
+    // 1. Validate pool is open and not past lock_time
+    const poolResult = await client.query(
+      'SELECT * FROM pickem_pools WHERE id = $1',
+      [poolId]
+    );
+    if (poolResult.rows.length === 0) throw new Error('Pool not found');
+    const pickemPool = poolResult.rows[0];
+    if (pickemPool.status !== 'open') throw new Error(`Pool is ${pickemPool.status}, cannot submit picks`);
+    if (new Date() >= new Date(pickemPool.lock_time)) throw new Error('Lock time has passed, picks are closed');
+
+    // 2. Validate entry exists
+    const entryResult = await client.query(
+      'SELECT * FROM pickem_entries WHERE pool_id = $1 AND user_id = $2',
+      [poolId, userId]
+    );
+    if (entryResult.rows.length === 0) throw new Error('Must join pool before submitting picks');
+    const entry = entryResult.rows[0];
+
+    // 3. Validate all active fights are covered
+    const fightsResult = await client.query(
+      "SELECT id FROM pickem_fights WHERE pool_id = $1 AND status NOT IN ('cancelled', 'no_contest')",
+      [poolId]
+    );
+    const validFightIds = new Set(fightsResult.rows.map(r => r.id));
+
+    if (picks.length !== validFightIds.size) {
+      throw new Error(`Must pick all ${validFightIds.size} fights, received ${picks.length}`);
+    }
+    for (const p of picks) {
+      if (!validFightIds.has(p.fightId)) throw new Error(`Invalid fight ID: ${p.fightId}`);
+      if (p.pick !== 'a' && p.pick !== 'b') throw new Error(`Invalid pick "${p.pick}", must be "a" or "b"`);
+    }
+
+    // 4. Upsert all picks
+    const insertedPicks = [];
+    for (const p of picks) {
+      const result = await client.query(
+        `INSERT INTO pickem_picks (entry_id, fight_id, pick)
+         VALUES ($1, $2, $3)
+         ON CONFLICT (entry_id, fight_id)
+         DO UPDATE SET pick = EXCLUDED.pick, updated_at = NOW()
+         RETURNING *`,
+        [entry.id, p.fightId, p.pick]
+      );
+      insertedPicks.push(result.rows[0]);
+    }
+
+    await client.query('COMMIT');
+    return insertedPicks.map(formatPick);
+  } catch (error) {
+    await client.query('ROLLBACK');
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+
+async function getUserPicks(poolId, userId) {
+  const entryResult = await pool.query(
+    'SELECT id FROM pickem_entries WHERE pool_id = $1 AND user_id = $2',
+    [poolId, userId]
+  );
+  if (entryResult.rows.length === 0) return [];
+
+  const result = await pool.query(
+    `SELECT pp.*, pf.fighter_a_name, pf.fighter_b_name, pf.weight_class, pf.winner, pf.status as fight_status
+     FROM pickem_picks pp
+     JOIN pickem_fights pf ON pp.fight_id = pf.id
+     WHERE pp.entry_id = $1
+     ORDER BY pf.fight_order ASC`,
+    [entryResult.rows[0].id]
+  );
+  return result.rows.map(formatPick);
+}
+
+// ========== SCORING ==========
+
+async function computeScores(poolId) {
+  const client = await pool.connect();
+  try {
+    await client.query('BEGIN');
+
+    // 1. Mark picks correct/incorrect based on resolved fights
+    await client.query(
+      `UPDATE pickem_picks pp
+       SET is_correct = (pp.pick = pf.winner), updated_at = NOW()
+       FROM pickem_fights pf
+       WHERE pp.fight_id = pf.id
+         AND pf.pool_id = $1
+         AND pf.status = 'final'
+         AND pf.winner IS NOT NULL`,
+      [poolId]
+    );
+
+    // 2. Cancelled/no_contest fights: exclude from scoring
+    await client.query(
+      `UPDATE pickem_picks pp
+       SET is_correct = NULL, updated_at = NOW()
+       FROM pickem_fights pf
+       WHERE pp.fight_id = pf.id
+         AND pf.pool_id = $1
+         AND pf.status IN ('cancelled', 'no_contest')`,
+      [poolId]
+    );
+
+    // 3. Compute scores: count correct picks per entry
+    await client.query(
+      `UPDATE pickem_entries pe
+       SET score = (
+         SELECT COUNT(*) FROM pickem_picks pp WHERE pp.entry_id = pe.id AND pp.is_correct = true
+       ),
+       updated_at = NOW()
+       WHERE pe.pool_id = $1`,
+      [poolId]
+    );
+
+    // 4. Compute ranks using DENSE_RANK
+    await client.query(
+      `UPDATE pickem_entries pe
+       SET rank = sub.rank
+       FROM (
+         SELECT id, DENSE_RANK() OVER (ORDER BY score DESC) as rank
+         FROM pickem_entries WHERE pool_id = $1
+       ) sub
+       WHERE pe.id = sub.id`,
+      [poolId]
+    );
+
+    // 5. Get results
+    const result = await client.query(
+      'SELECT pe.*, u.username, u.avatar FROM pickem_entries pe LEFT JOIN users u ON pe.user_id = u.id WHERE pe.pool_id = $1 ORDER BY score DESC, created_at ASC',
+      [poolId]
+    );
+
+    const entries = result.rows.map(formatEntry);
+    const maxScore = entries.length > 0 ? entries[0].score : 0;
+    const winners = entries.filter(e => e.score === maxScore);
+
+    await client.query('COMMIT');
+
+    return { entries, maxScore, winnerCount: winners.length, winners };
+  } catch (error) {
+    await client.query('ROLLBACK');
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+
+// ========== LEADERBOARD ==========
+
+async function getLeaderboard(poolId) {
+  const result = await pool.query(
+    `SELECT pe.*, u.username, u.avatar
+     FROM pickem_entries pe
+     LEFT JOIN users u ON pe.user_id = u.id
+     WHERE pe.pool_id = $1
+     ORDER BY pe.score DESC, pe.created_at ASC`,
+    [poolId]
+  );
+
+  const entries = result.rows.map(formatEntry);
+  const entryIds = entries.map(e => e.id);
+
+  if (entryIds.length > 0) {
+    const picksResult = await pool.query(
+      `SELECT pp.*, pf.fighter_a_name, pf.fighter_b_name, pf.weight_class,
+              pf.winner, pf.status as fight_status, pf.fight_order
+       FROM pickem_picks pp
+       JOIN pickem_fights pf ON pp.fight_id = pf.id
+       WHERE pp.entry_id = ANY($1)
+       ORDER BY pf.fight_order ASC`,
+      [entryIds]
+    );
+
+    const picksByEntry = {};
+    for (const row of picksResult.rows) {
+      if (!picksByEntry[row.entry_id]) picksByEntry[row.entry_id] = [];
+      picksByEntry[row.entry_id].push({
+        ...formatPick(row),
+        fightOrder: row.fight_order,
+      });
+    }
+
+    return entries.map(e => ({ ...e, picks: picksByEntry[e.id] || [] }));
+  }
+
+  return entries;
+}
+
+async function getWinners(poolId) {
+  const result = await pool.query(
+    `SELECT pe.*, u.username, u.avatar
+     FROM pickem_entries pe
+     LEFT JOIN users u ON pe.user_id = u.id
+     WHERE pe.pool_id = $1 AND pe.rank = 1`,
+    [poolId]
+  );
+  return result.rows.map(formatEntry);
+}
+
+// ========== STATS ==========
+
+async function getPoolStats(poolId) {
+  const poolResult = await pool.query('SELECT * FROM pickem_pools WHERE id = $1', [poolId]);
+  if (poolResult.rows.length === 0) return null;
+  const p = poolResult.rows[0];
+
+  const fightsResult = await pool.query(
+    "SELECT COUNT(*) as total, COUNT(*) FILTER (WHERE status IN ('final', 'cancelled', 'no_contest')) as resolved FROM pickem_fights WHERE pool_id = $1",
+    [poolId]
+  );
+  const { total: totalFights, resolved: resolvedFights } = fightsResult.rows[0];
+
+  const totalEntries = Number(p.total_entries || 0);
+  const totalPotLamports = totalEntries * Number(p.buy_in_lamports);
+
+  return {
+    totalEntries,
+    totalPotLamports,
+    totalPotSol: totalPotLamports / LAMPORTS_PER_SOL,
+    netPotLamports: Math.floor(totalPotLamports * (1 - FEE_PERCENT / 100)),
+    netPotSol: Math.floor(totalPotLamports * (1 - FEE_PERCENT / 100)) / LAMPORTS_PER_SOL,
+    totalFights: Number(totalFights),
+    resolvedFights: Number(resolvedFights),
+    allFightsResolved: Number(resolvedFights) === Number(totalFights) && Number(totalFights) > 0,
+    status: p.status,
+    lockTime: p.lock_time,
+  };
+}
+
+// ========== PAYOUTS ==========
+
+async function recordPayout({ poolId, entryId, walletAddress, amountLamports, txSignature, status }) {
+  const result = await pool.query(
+    `INSERT INTO pickem_payouts (pool_id, entry_id, wallet_address, amount_lamports, payout_tx_signature, status)
+     VALUES ($1, $2, $3, $4, $5, $6)
+     ON CONFLICT (pool_id, entry_id)
+     DO UPDATE SET payout_tx_signature = EXCLUDED.payout_tx_signature, status = EXCLUDED.status, updated_at = NOW()
+     RETURNING *`,
+    [poolId, entryId, walletAddress, amountLamports, txSignature || null, status || 'pending']
+  );
+  return result.rows[0];
+}
+
+async function getPayouts(poolId) {
+  const result = await pool.query(
+    'SELECT * FROM pickem_payouts WHERE pool_id = $1 ORDER BY amount_lamports DESC',
+    [poolId]
+  );
+  return result.rows;
+}
+
+module.exports = {
+  createPool,
+  getPools,
+  getPoolById,
+  updatePool,
+  importFights,
+  getFights,
+  updateFightResult,
+  joinPool,
+  getUserEntry,
+  submitPicks,
+  getUserPicks,
+  computeScores,
+  getLeaderboard,
+  getWinners,
+  getPoolStats,
+  recordPayout,
+  getPayouts,
+};