dubs-server 1.0.0

package/services/exchangeRateService.js

@@ -0,0 +1,289 @@
+const axios = require('axios');
+const { pool } = require('./db'); // Shared database pool
+
+class ExchangeRateService {
+  constructor() {
+    this.apiKey = process.env.EXCHANGE_API_KEY || '757419e9be20039acaf308a9';
+    this.apiBaseUrl = process.env.EXCHANGE_API_BASE_URL || 'https://v6.exchangerate-api.com/v6';
+    this.cacheTTL = parseInt(process.env.EXCHANGE_CACHE_TTL) || 300; // 5 minutes in seconds
+    this.baseCurrency = process.env.BASE_CURRENCY || 'USD';
+    this.supportedCurrencies = (process.env.SUPPORTED_CURRENCIES || 'USD,EUR,CAD,GBP,JPY,AUD,CHF,CNY,SEK,NZD').split(',');
+    
+    // Initialize cache table on startup
+    this.initializeCacheTable();
+  }
+
+  /**
+   * Initialize the exchange_rates_cache table if it doesn't exist
+   */
+  async initializeCacheTable() {
+    try {
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS exchange_rates_cache (
+          id SERIAL PRIMARY KEY,
+          base_currency VARCHAR(3) NOT NULL UNIQUE,
+          rates JSONB NOT NULL,
+          last_updated TIMESTAMP NOT NULL DEFAULT NOW(),
+          expires_at TIMESTAMP NOT NULL,
+          created_at TIMESTAMP DEFAULT NOW()
+        );
+        
+        CREATE INDEX IF NOT EXISTS idx_exchange_rates_base ON exchange_rates_cache(base_currency);
+        CREATE INDEX IF NOT EXISTS idx_exchange_rates_expires ON exchange_rates_cache(expires_at);
+      `);
+      console.log('[Exchange Rates] Cache table initialized');
+    } catch (error) {
+      console.error('[Exchange Rates] Error initializing cache table:', error);
+    }
+  }
+
+  /**
+   * Get exchange rates for all supported currencies
+   * @param {string} base - Base currency (default: USD)
+   * @returns {Object} Exchange rates object
+   */
+  async getExchangeRates(base = this.baseCurrency) {
+    try {
+      // Try to get from cache first
+      const cachedRates = await this.getCachedRates(base);
+      if (cachedRates) {
+        console.log(`[Exchange Rates] Retrieved ${base} from cache`);
+        return {
+          ...cachedRates,
+          source: 'cache'
+        };
+      }
+
+      // If not in cache, fetch from API
+      console.log(`[Exchange Rates] Fetching fresh rates for ${base} from API`);
+      const freshRates = await this.fetchFromAPI(base);
+      
+      // Cache the fresh rates
+      await this.cacheRates(base, freshRates);
+      
+      return {
+        ...freshRates,
+        source: 'api'
+      };
+    } catch (error) {
+      console.error('[Exchange Rates] Error getting exchange rates:', error);
+      throw new Error('Failed to retrieve exchange rates');
+    }
+  }
+
+  /**
+   * Get specific currency pair rate
+   * @param {string} from - From currency
+   * @param {string} to - To currency
+   * @returns {Object} Exchange rate data
+   */
+  async getCurrencyPair(from, to) {
+    if (!this.supportedCurrencies.includes(from) || !this.supportedCurrencies.includes(to)) {
+      throw new Error('Unsupported currency pair');
+    }
+
+    const rates = await this.getExchangeRates(from);
+    
+    if (!rates.rates[to]) {
+      throw new Error(`Exchange rate for ${from} to ${to} not available`);
+    }
+
+    return {
+      from,
+      to,
+      rate: rates.rates[to],
+      timestamp: rates.timestamp,
+      date: rates.date,
+      source: rates.source
+    };
+  }
+
+  /**
+   * Convert amount from one currency to another
+   * @param {number} amount - Amount to convert
+   * @param {string} from - From currency
+   * @param {string} to - To currency
+   * @returns {Object} Conversion result
+   */
+  async convertCurrency(amount, from, to) {
+    const pairData = await this.getCurrencyPair(from, to);
+    const convertedAmount = amount * pairData.rate;
+
+    return {
+      originalAmount: amount,
+      convertedAmount: parseFloat(convertedAmount.toFixed(4)),
+      from,
+      to,
+      rate: pairData.rate,
+      timestamp: pairData.timestamp,
+      source: pairData.source
+    };
+  }
+
+  /**
+   * Get cached exchange rates from PostgreSQL
+   * @param {string} base - Base currency
+   * @returns {Object|null} Cached rates or null
+   */
+  async getCachedRates(base) {
+    try {
+      const result = await pool.query(
+        'SELECT rates, last_updated FROM exchange_rates_cache WHERE base_currency = $1 AND expires_at > NOW()',
+        [base]
+      );
+
+      if (result.rows.length > 0) {
+        const row = result.rows[0];
+        return {
+          ...row.rates,
+          lastUpdated: row.last_updated
+        };
+      }
+      
+      return null;
+    } catch (error) {
+      console.error('[Exchange Rates] Error getting cached rates:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Cache exchange rates in PostgreSQL
+   * @param {string} base - Base currency
+   * @param {Object} rates - Exchange rates data
+   */
+  async cacheRates(base, rates) {
+    try {
+      const expiresAt = new Date(Date.now() + this.cacheTTL * 1000);
+      
+      await pool.query(`
+        INSERT INTO exchange_rates_cache (base_currency, rates, last_updated, expires_at)
+        VALUES ($1, $2, NOW(), $3)
+        ON CONFLICT (base_currency) 
+        DO UPDATE SET 
+          rates = $2,
+          last_updated = NOW(),
+          expires_at = $3
+      `, [base, JSON.stringify(rates), expiresAt]);
+      
+      console.log(`[Exchange Rates] Cached ${base} rates with TTL: ${this.cacheTTL}s`);
+    } catch (error) {
+      console.error('[Exchange Rates] Error caching rates:', error);
+      // Don't throw error, caching failure shouldn't break the service
+    }
+  }
+
+  /**
+   * Fetch exchange rates from external API
+   * @param {string} base - Base currency
+   * @returns {Object} Fresh exchange rates
+   */
+  async fetchFromAPI(base) {
+    try {
+      const url = `${this.apiBaseUrl}/${this.apiKey}/latest/${base}`;
+      const response = await axios.get(url, {
+        timeout: 10000, // 10 second timeout
+        headers: {
+          'User-Agent': 'Dubs-Exchange-API/1.0'
+        }
+      });
+
+      if (!response.data || !response.data.conversion_rates) {
+        throw new Error('Invalid response from exchange rate API');
+      }
+
+      // Check if the request was successful
+      if (response.data.result !== 'success') {
+        throw new Error(`API Error: ${response.data['error-type'] || 'Unknown error'}`);
+      }
+
+      // Filter rates to only include supported currencies
+      const filteredRates = {};
+      for (const currency of this.supportedCurrencies) {
+        if (response.data.conversion_rates[currency] !== undefined) {
+          filteredRates[currency] = response.data.conversion_rates[currency];
+        }
+      }
+
+      return {
+        base: response.data.base_code,
+        date: new Date(response.data.time_last_update_unix * 1000).toISOString().split('T')[0],
+        timestamp: Date.now(),
+        rates: filteredRates,
+        lastUpdated: response.data.time_last_update_utc,
+        nextUpdate: response.data.time_next_update_utc
+      };
+    } catch (error) {
+      if (error.response) {
+        console.error('[Exchange Rates] API Error:', error.response.status, error.response.data);
+        
+        // Handle specific API errors
+        if (error.response.status === 403) {
+          throw new Error('Exchange rate API: Invalid or expired API key');
+        } else if (error.response.status === 404) {
+          throw new Error('Exchange rate API: Unsupported currency code');
+        } else if (error.response.status === 429) {
+          throw new Error('Exchange rate API: Rate limit exceeded');
+        }
+        
+        throw new Error(`Exchange rate API error: ${error.response.status}`);
+      } else if (error.request) {
+        console.error('[Exchange Rates] Network Error:', error.message);
+        throw new Error('Network error connecting to exchange rate API');
+      } else {
+        console.error('[Exchange Rates] Error:', error.message);
+        throw new Error('Failed to fetch exchange rates');
+      }
+    }
+  }
+
+  /**
+   * Get list of supported currencies
+   * @returns {Array} List of supported currency codes
+   */
+  getSupportedCurrencies() {
+    return this.supportedCurrencies;
+  }
+
+  /**
+   * Clear cache for a specific base currency
+   * @param {string} base - Base currency
+   */
+  async clearCache(base = this.baseCurrency) {
+    try {
+      await pool.query(
+        'DELETE FROM exchange_rates_cache WHERE base_currency = $1',
+        [base]
+      );
+      console.log(`[Exchange Rates] Cache cleared for ${base}`);
+    } catch (error) {
+      console.error('[Exchange Rates] Error clearing cache:', error);
+      throw new Error('Failed to clear cache');
+    }
+  }
+
+  /**
+   * Clean up expired cache entries
+   */
+  async cleanupExpiredCache() {
+    try {
+      const result = await pool.query(
+        'DELETE FROM exchange_rates_cache WHERE expires_at < NOW()'
+      );
+      if (result.rowCount > 0) {
+        console.log(`[Exchange Rates] Cleaned up ${result.rowCount} expired cache entries`);
+      }
+    } catch (error) {
+      console.error('[Exchange Rates] Error cleaning up cache:', error);
+    }
+  }
+}
+
+module.exports = new ExchangeRateService();
+
+
+
+
+
+
+

package/services/expoPushService.js

@@ -0,0 +1,314 @@
+/**
+ * Expo Push Notification Service
+ * Handles token registration, push sending, and pick'em-specific notifications.
+ */
+
+const { Expo } = require('expo-server-sdk');
+const { pool } = require('./db');
+
+const expo = new Expo();
+
+// ── Token Management ──
+
+/**
+ * Register or reactivate an Expo push token for a user.
+ */
+async function registerToken(userId, token, platform, deviceName, developerAppId) {
+  if (!Expo.isExpoPushToken(token)) {
+    throw new Error(`Invalid Expo push token: ${token}`);
+  }
+
+  const result = await pool.query(
+    `INSERT INTO expo_push_tokens (user_id, token, platform, device_name, developer_app_id, active, updated_at)
+     VALUES ($1, $2, $3, $4, $5, true, NOW())
+     ON CONFLICT (user_id, token)
+     DO UPDATE SET active = true, platform = $3, device_name = $4, developer_app_id = $5, updated_at = NOW()
+     RETURNING *`,
+    [userId, token, platform, deviceName || null, developerAppId || null]
+  );
+
+  console.log(`[ExpoPush] Token registered: ${token.slice(0, 30)}... for user ${userId}`);
+  return result.rows[0];
+}
+
+/**
+ * Deactivate a push token for a user.
+ */
+async function unregisterToken(userId, token) {
+  await pool.query(
+    `UPDATE expo_push_tokens SET active = false, updated_at = NOW()
+     WHERE user_id = $1 AND token = $2`,
+    [userId, token]
+  );
+  console.log(`[ExpoPush] Token unregistered for user ${userId}`);
+}
+
+/**
+ * Get all active tokens for a user, optionally filtered by app.
+ */
+async function getTokensForUser(userId, developerAppId) {
+  const params = [userId];
+  let where = 'WHERE user_id = $1 AND active = true';
+  if (developerAppId) {
+    where += ' AND developer_app_id = $2';
+    params.push(developerAppId);
+  }
+  const result = await pool.query(
+    `SELECT token, platform, device_name, created_at, updated_at FROM expo_push_tokens ${where} ORDER BY updated_at DESC`,
+    params
+  );
+  return result.rows;
+}
+
+/**
+ * Get all active tokens for an app with user info (for dashboard).
+ */
+async function getTokensForApp(developerAppId) {
+  const result = await pool.query(
+    `SELECT ept.token, ept.platform, ept.device_name, ept.active, ept.created_at,
+            u.wallet_address, u.username, u.avatar
+     FROM expo_push_tokens ept
+     JOIN users u ON ept.user_id = u.id
+     WHERE ept.developer_app_id = $1 AND ept.active = true
+     ORDER BY ept.updated_at DESC`,
+    [developerAppId]
+  );
+  return result.rows;
+}
+
+// ── Push Sending ──
+
+/**
+ * Send a push notification to all active tokens for given user IDs.
+ * Auto-deactivates tokens that return DeviceNotRegistered.
+ */
+async function sendToUsers(userIds, notification) {
+  if (!userIds || userIds.length === 0) return { sent: 0, failed: 0 };
+
+  const result = await pool.query(
+    `SELECT id, user_id, token FROM expo_push_tokens
+     WHERE user_id = ANY($1) AND active = true`,
+    [userIds]
+  );
+
+  if (result.rows.length === 0) return { sent: 0, failed: 0 };
+
+  const messages = result.rows
+    .filter(row => Expo.isExpoPushToken(row.token))
+    .map(row => ({
+      to: row.token,
+      sound: 'default',
+      title: notification.title,
+      body: notification.body,
+      data: notification.data || {},
+      channelId: notification.channelId || 'default',
+    }));
+
+  if (messages.length === 0) return { sent: 0, failed: 0 };
+
+  const chunks = expo.chunkPushNotifications(messages);
+  let sent = 0;
+  let failed = 0;
+  const tokensToDeactivate = [];
+
+  for (const chunk of chunks) {
+    try {
+      const receipts = await expo.sendPushNotificationsAsync(chunk);
+      for (let i = 0; i < receipts.length; i++) {
+        const receipt = receipts[i];
+        if (receipt.status === 'ok') {
+          sent++;
+        } else {
+          failed++;
+          if (receipt.details?.error === 'DeviceNotRegistered') {
+            tokensToDeactivate.push(chunk[i].to);
+          }
+          console.error(`[ExpoPush] Error sending to ${chunk[i].to}: ${receipt.message || receipt.details?.error}`);
+        }
+      }
+    } catch (err) {
+      console.error('[ExpoPush] Chunk send error:', err.message);
+      failed += chunk.length;
+    }
+  }
+
+  // Deactivate stale tokens
+  if (tokensToDeactivate.length > 0) {
+    await pool.query(
+      `UPDATE expo_push_tokens SET active = false, updated_at = NOW()
+       WHERE token = ANY($1)`,
+      [tokensToDeactivate]
+    ).catch(err => console.error('[ExpoPush] Failed to deactivate stale tokens:', err.message));
+    console.log(`[ExpoPush] Deactivated ${tokensToDeactivate.length} stale token(s)`);
+  }
+
+  console.log(`[ExpoPush] Sent: ${sent}, Failed: ${failed}`);
+  return { sent, failed };
+}
+
+/**
+ * Send a push notification to a single user.
+ */
+async function sendToUser(userId, notification) {
+  return sendToUsers([userId], notification);
+}
+
+// ── Pick'em Notification Helpers ──
+
+/**
+ * Notify users who picked on a fight that just went live.
+ */
+async function sendFightLiveNotifications(fightId, fight) {
+  // Get all users who have picks on this fight
+  const pickResult = await pool.query(
+    `SELECT DISTINCT pe.user_id
+     FROM pickem_picks pp
+     JOIN pickem_entries pe ON pp.entry_id = pe.id
+     WHERE pp.fight_id = $1`,
+    [fightId]
+  );
+
+  if (pickResult.rows.length === 0) return;
+
+  const userIds = pickResult.rows.map(r => r.user_id);
+  const fighterA = fight.fighterAName || fight.fighter_a_name || 'Fighter A';
+  const fighterB = fight.fighterBName || fight.fighter_b_name || 'Fighter B';
+
+  await sendToUsers(userIds, {
+    title: 'Fight Starting NOW!',
+    body: `${fighterA} vs ${fighterB} is LIVE!`,
+    data: {
+      type: 'fight_live',
+      fightId: String(fightId),
+      poolId: String(fight.poolId || fight.pool_id),
+    },
+    channelId: 'pickem',
+  });
+
+  console.log(`[ExpoPush] Fight live notifications sent for fight ${fightId} to ${userIds.length} user(s)`);
+}
+
+/**
+ * Notify users who picked on a fight that just resolved.
+ * Sends different messages for correct vs incorrect picks.
+ */
+async function sendFightResolvedNotifications(fightId, fight) {
+  const winner = fight.winner;
+  if (!winner) return;
+
+  // Get all picks for this fight with user IDs
+  const pickResult = await pool.query(
+    `SELECT pp.pick, pe.user_id
+     FROM pickem_picks pp
+     JOIN pickem_entries pe ON pp.entry_id = pe.id
+     WHERE pp.fight_id = $1`,
+    [fightId]
+  );
+
+  if (pickResult.rows.length === 0) return;
+
+  const fighterA = fight.fighterAName || fight.fighter_a_name || 'Fighter A';
+  const fighterB = fight.fighterBName || fight.fighter_b_name || 'Fighter B';
+  const winnerName = winner === 'a' ? fighterA : fighterB;
+  const method = fight.method || '';
+  const methodStr = method ? ` by ${method}` : '';
+  const poolId = String(fight.poolId || fight.pool_id);
+
+  const correctUserIds = [];
+  const incorrectUserIds = [];
+
+  for (const row of pickResult.rows) {
+    if (row.pick === winner) {
+      correctUserIds.push(row.user_id);
+    } else {
+      incorrectUserIds.push(row.user_id);
+    }
+  }
+
+  const promises = [];
+
+  if (correctUserIds.length > 0) {
+    promises.push(
+      sendToUsers(correctUserIds, {
+        title: 'Correct Pick!',
+        body: `${winnerName} wins${methodStr}! Your pick was correct!`,
+        data: { type: 'fight_resolved', fightId: String(fightId), poolId, result: 'correct' },
+        channelId: 'pickem',
+      })
+    );
+  }
+
+  if (incorrectUserIds.length > 0) {
+    promises.push(
+      sendToUsers(incorrectUserIds, {
+        title: 'Fight Result',
+        body: `${winnerName} wins${methodStr}. Better luck on the next fight!`,
+        data: { type: 'fight_resolved', fightId: String(fightId), poolId, result: 'incorrect' },
+        channelId: 'pickem',
+      })
+    );
+  }
+
+  await Promise.all(promises);
+  console.log(`[ExpoPush] Fight resolved notifications: ${correctUserIds.length} correct, ${incorrectUserIds.length} incorrect`);
+}
+
+/**
+ * Notify all users in a pool when it resolves with final rankings.
+ */
+async function sendPoolResolvedNotifications(poolId, scores) {
+  if (!scores || !scores.entries || scores.entries.length === 0) return;
+
+  const totalFights = scores.maxScore != null ? undefined : undefined; // scores contain entries with score/rank
+
+  // Get the total number of resolved fights for context
+  const fightCountResult = await pool.query(
+    `SELECT COUNT(*) as total FROM pickem_fights WHERE pool_id = $1 AND status = 'final'`,
+    [poolId]
+  );
+  const totalResolved = parseInt(fightCountResult.rows[0]?.total || '0');
+
+  const promises = [];
+
+  for (const entry of scores.entries) {
+    const rank = entry.rank;
+    const score = entry.score || 0;
+    const userId = entry.user_id || entry.userId;
+    if (!userId) continue;
+
+    const isWinner = rank === 1;
+    const title = isWinner ? "You Won the Pool!" : 'Pool Results';
+    const body = isWinner
+      ? `Congratulations! You finished #1 with ${score}/${totalResolved} correct picks!`
+      : `Final results: You finished #${rank} with ${score}/${totalResolved} correct picks.`;
+
+    promises.push(
+      sendToUser(userId, {
+        title,
+        body,
+        data: {
+          type: 'pool_resolved',
+          poolId: String(poolId),
+          rank: String(rank),
+          score: String(score),
+        },
+        channelId: 'pickem',
+      })
+    );
+  }
+
+  await Promise.all(promises);
+  console.log(`[ExpoPush] Pool resolved notifications sent for pool ${poolId} to ${scores.entries.length} user(s)`);
+}
+
+module.exports = {
+  registerToken,
+  unregisterToken,
+  getTokensForUser,
+  getTokensForApp,
+  sendToUsers,
+  sendToUser,
+  sendFightLiveNotifications,
+  sendFightResolvedNotifications,
+  sendPoolResolvedNotifications,
+};