dubs-server 1.0.0

package/services/whatsNewService.js

@@ -0,0 +1,388 @@
+/**
+ * 📢 What's New Service
+ * 
+ * Manages feature announcements and user read tracking
+ * Admin wallet: Hvv1ctqHLR5wonuuRguefS6EpGUe7tFRBX2YWHGr3mes
+ */
+
+const { pool } = require('./db');
+const notificationCacheService = require('./notificationCacheService');
+const { forwardChatNotification } = require('./telegramNotifications');
+
+// Admin wallet - only this address can create/edit/delete posts
+const ADMIN_WALLET = 'Hvv1ctqHLR5wonuuRguefS6EpGUe7tFRBX2YWHGr3mes';
+
+/**
+ * Check if a wallet address is an admin
+ */
+function isAdmin(walletAddress) {
+  return walletAddress === ADMIN_WALLET;
+}
+
+/**
+ * Get all published posts (for users)
+ * Ordered by: pinned first, then by created_at desc
+ */
+async function getPosts(userId = null) {
+  try {
+    let query;
+    let params;
+    
+    if (userId) {
+      // Include read status for authenticated users
+      query = `
+        SELECT 
+          p.*,
+          CASE WHEN r.id IS NOT NULL THEN TRUE ELSE FALSE END as is_read
+        FROM whats_new_posts p
+        LEFT JOIN user_whats_new_reads r ON r.post_id = p.id AND r.user_id = $1
+        WHERE p.is_published = TRUE
+        ORDER BY p.is_pinned DESC, p.created_at DESC
+        LIMIT 50
+      `;
+      params = [userId];
+    } else {
+      // For unauthenticated users, just return posts
+      query = `
+        SELECT p.*, FALSE as is_read
+        FROM whats_new_posts p
+        WHERE p.is_published = TRUE
+        ORDER BY p.is_pinned DESC, p.created_at DESC
+        LIMIT 50
+      `;
+      params = [];
+    }
+    
+    const result = await pool.query(query, params);
+    return result.rows;
+  } catch (error) {
+    console.error('[WhatsNew] Error fetching posts:', error);
+    throw error;
+  }
+}
+
+/**
+ * Get all posts including unpublished (for admin)
+ */
+async function getAllPostsAdmin() {
+  try {
+    const query = `
+      SELECT *
+      FROM whats_new_posts
+      ORDER BY is_pinned DESC, created_at DESC
+      LIMIT 100
+    `;
+    
+    const result = await pool.query(query);
+    return result.rows;
+  } catch (error) {
+    console.error('[WhatsNew] Error fetching admin posts:', error);
+    throw error;
+  }
+}
+
+/**
+ * Get unread count for a user
+ */
+async function getUnreadCount(userId) {
+  try {
+    const query = `
+      SELECT COUNT(*) as count
+      FROM whats_new_posts p
+      LEFT JOIN user_whats_new_reads r ON r.post_id = p.id AND r.user_id = $1
+      WHERE p.is_published = TRUE AND r.id IS NULL
+    `;
+    
+    const result = await pool.query(query, [userId]);
+    return parseInt(result.rows[0].count, 10) || 0;
+  } catch (error) {
+    console.error('[WhatsNew] Error getting unread count:', error);
+    return 0;
+  }
+}
+
+/**
+ * Mark posts as read for a user
+ */
+async function markAsRead(userId, postIds) {
+  if (!postIds || postIds.length === 0) return;
+  
+  try {
+    // Use INSERT ... ON CONFLICT to handle duplicates gracefully
+    const values = postIds.map((postId, idx) => `($1, $${idx + 2})`).join(', ');
+    const query = `
+      INSERT INTO user_whats_new_reads (user_id, post_id)
+      VALUES ${values}
+      ON CONFLICT (user_id, post_id) DO NOTHING
+    `;
+    
+    await pool.query(query, [userId, ...postIds]);
+    console.log(`[WhatsNew] Marked ${postIds.length} posts as read for user ${userId}`);
+  } catch (error) {
+    console.error('[WhatsNew] Error marking posts as read:', error);
+    throw error;
+  }
+}
+
+/**
+ * Mark all posts as read for a user
+ */
+async function markAllAsRead(userId) {
+  try {
+    const query = `
+      INSERT INTO user_whats_new_reads (user_id, post_id)
+      SELECT $1, p.id
+      FROM whats_new_posts p
+      LEFT JOIN user_whats_new_reads r ON r.post_id = p.id AND r.user_id = $1
+      WHERE p.is_published = TRUE AND r.id IS NULL
+      ON CONFLICT (user_id, post_id) DO NOTHING
+    `;
+    
+    const result = await pool.query(query, [userId]);
+    console.log(`[WhatsNew] Marked all posts as read for user ${userId}`);
+    return result.rowCount;
+  } catch (error) {
+    console.error('[WhatsNew] Error marking all as read:', error);
+    throw error;
+  }
+}
+
+/**
+ * Broadcast notification to all users when a new post is published
+ */
+async function broadcastNotification(post) {
+  try {
+    console.log(`[WhatsNew] 📢 Broadcasting notification for post: "${post.title}" (id: ${post.id})`);
+    
+    // Get all active users
+    const usersResult = await pool.query(`
+      SELECT id, wallet_address, username
+      FROM users
+      WHERE onboarding_complete = TRUE
+    `);
+    
+    const users = usersResult.rows;
+    console.log(`[WhatsNew] Found ${users.length} users to notify`);
+    
+    if (users.length === 0) {
+      return 0;
+    }
+    
+    // Build notification data
+    const notificationData = {
+      postId: post.id,
+      title: post.title,
+      category: post.category,
+      version: post.version,
+      gifUrl: post.gif_url,
+    };
+    
+    // Batch insert notifications for all users
+    // Using a CTE to generate values for all users
+    const insertQuery = `
+      INSERT INTO chat_notifications (user_id, notification_type, notification_data, read, created_at)
+      SELECT 
+        u.id,
+        'whats_new',
+        $1::jsonb,
+        FALSE,
+        NOW()
+      FROM users u
+      WHERE u.onboarding_complete = TRUE
+      RETURNING id, user_id
+    `;
+    
+    const insertResult = await pool.query(insertQuery, [JSON.stringify(notificationData)]);
+    const insertedCount = insertResult.rowCount;
+    
+    console.log(`[WhatsNew] ✅ Created ${insertedCount} notifications for post "${post.title}"`);
+    
+    // Get chatNamespace for WebSocket emissions
+    const chatNamespace = global.chatNamespace;
+    
+    // Cache notifications to Redis and emit WebSocket events for each user
+    for (const row of insertResult.rows) {
+      const notificationPayload = {
+        id: row.id,
+        type: 'whats_new',
+        read: false,
+        messageId: null,
+        message: post.title,
+        senderUsername: 'Dubs Team',
+        senderWallet: ADMIN_WALLET,
+        senderAvatar: null,
+        createdAt: new Date().toISOString(),
+        notificationData: notificationData,
+      };
+      
+      // Cache to Redis (non-blocking)
+      notificationCacheService.cacheNotification(row.user_id, notificationPayload)
+        .catch(err => console.error('[WhatsNew] Cache error for user', row.user_id, ':', err.message));
+      
+      // Emit WebSocket event to connected users
+      if (chatNamespace) {
+        chatNamespace.to(`user-${row.user_id}`).emit('notification', notificationPayload);
+        console.log(`[WhatsNew] 🔔 WebSocket notification sent to user-${row.user_id}`);
+      }
+      
+      // Send Telegram notification (non-blocking)
+      forwardChatNotification(
+        pool, 
+        row.user_id, 
+        'whats_new', 
+        'Dubs Team', 
+        post.title,
+        { postId: post.id }
+      ).catch(err => console.error('[WhatsNew] Telegram error for user', row.user_id, ':', err.message));
+    }
+    
+    return insertedCount;
+  } catch (error) {
+    console.error('[WhatsNew] Error broadcasting notification:', error);
+    // Don't throw - this shouldn't block post creation
+    return 0;
+  }
+}
+
+/**
+ * Create a new post (admin only)
+ */
+async function createPost({ title, content, gifUrl, category, version, isPinned, isPublished, createdBy }) {
+  try {
+    const query = `
+      INSERT INTO whats_new_posts (title, content, gif_url, category, version, is_pinned, is_published, created_by)
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+      RETURNING *
+    `;
+    
+    const result = await pool.query(query, [
+      title,
+      content,
+      gifUrl || null,
+      category || 'feature',
+      version || null,
+      isPinned || false,
+      isPublished !== false, // Default to true
+      createdBy,
+    ]);
+    
+    const post = result.rows[0];
+    console.log('[WhatsNew] Created post:', post.id, title);
+    
+    // If the post is published, broadcast notifications to all users
+    if (post.is_published) {
+      const notifiedCount = await broadcastNotification(post);
+      console.log(`[WhatsNew] Notified ${notifiedCount} users about new post`);
+    }
+    
+    return post;
+  } catch (error) {
+    console.error('[WhatsNew] Error creating post:', error);
+    throw error;
+  }
+}
+
+/**
+ * Update a post (admin only)
+ */
+async function updatePost(postId, { title, content, gifUrl, category, version, isPinned, isPublished }) {
+  try {
+    // First, check the current published status
+    const currentPost = await getPostById(postId);
+    const wasPublished = currentPost ? currentPost.is_published : false;
+    
+    const query = `
+      UPDATE whats_new_posts
+      SET 
+        title = COALESCE($1, title),
+        content = COALESCE($2, content),
+        gif_url = $3,
+        category = COALESCE($4, category),
+        version = $5,
+        is_pinned = COALESCE($6, is_pinned),
+        is_published = COALESCE($7, is_published)
+      WHERE id = $8
+      RETURNING *
+    `;
+    
+    const result = await pool.query(query, [
+      title,
+      content,
+      gifUrl,
+      category,
+      version,
+      isPinned,
+      isPublished,
+      postId,
+    ]);
+    
+    if (result.rows.length === 0) {
+      throw new Error('Post not found');
+    }
+    
+    const updatedPost = result.rows[0];
+    console.log('[WhatsNew] Updated post:', postId);
+    
+    // If the post was just published (changed from unpublished to published), broadcast notifications
+    if (!wasPublished && updatedPost.is_published) {
+      console.log('[WhatsNew] Post was just published, broadcasting notifications...');
+      const notifiedCount = await broadcastNotification(updatedPost);
+      console.log(`[WhatsNew] Notified ${notifiedCount} users about newly published post`);
+    }
+    
+    return updatedPost;
+  } catch (error) {
+    console.error('[WhatsNew] Error updating post:', error);
+    throw error;
+  }
+}
+
+/**
+ * Delete a post (admin only)
+ */
+async function deletePost(postId) {
+  try {
+    const query = `DELETE FROM whats_new_posts WHERE id = $1 RETURNING id`;
+    const result = await pool.query(query, [postId]);
+    
+    if (result.rows.length === 0) {
+      throw new Error('Post not found');
+    }
+    
+    console.log('[WhatsNew] Deleted post:', postId);
+    return true;
+  } catch (error) {
+    console.error('[WhatsNew] Error deleting post:', error);
+    throw error;
+  }
+}
+
+/**
+ * Get a single post by ID
+ */
+async function getPostById(postId) {
+  try {
+    const query = `SELECT * FROM whats_new_posts WHERE id = $1`;
+    const result = await pool.query(query, [postId]);
+    return result.rows[0] || null;
+  } catch (error) {
+    console.error('[WhatsNew] Error fetching post:', error);
+    throw error;
+  }
+}
+
+module.exports = {
+  ADMIN_WALLET,
+  isAdmin,
+  getPosts,
+  getAllPostsAdmin,
+  getUnreadCount,
+  markAsRead,
+  markAllAsRead,
+  createPost,
+  updatePost,
+  deletePost,
+  getPostById,
+  broadcastNotification,
+};
+

package/utils/urlHelper.js

@@ -0,0 +1,95 @@
+/**
+ * URL Helper Utilities
+ * Generates correct URLs for game sharing based on game type and environment
+ */
+
+/**
+ * Get the base app URL based on environment
+ * @returns {string} Base URL (e.g., 'https://dubs.app' or 'https://dev.dubs.app')
+ */
+function getAppBaseUrl() {
+  // Allow explicit override via environment variable
+  if (process.env.DUBS_APP_URL) {
+    return process.env.DUBS_APP_URL.replace(/\/$/, ''); // Remove trailing slash
+  }
+  
+  // Check NODE_ENV - production server has NODE_ENV=production
+  const isProduction = process.env.NODE_ENV === 'production';
+  
+  return isProduction ? 'https://dubs.app' : 'https://dev.dubs.app';
+}
+
+/**
+ * Determine if a game ID is a sports game
+ * Sports games have IDs starting with 'sport-'
+ * @param {string} gameId - The game ID
+ * @returns {boolean} True if sports game
+ */
+function isSportsGame(gameId) {
+  return gameId && gameId.startsWith('sport-');
+}
+
+/**
+ * Determine if a game ID is a pool/billiards game
+ * Pool games have UUID format (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
+ * @param {string} gameId - The game ID
+ * @returns {boolean} True if pool game
+ */
+function isPoolGame(gameId) {
+  if (!gameId) return false;
+  // UUID pattern check
+  const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  return uuidPattern.test(gameId);
+}
+
+/**
+ * Generate the correct web share link for a game
+ * - Sports games: /game/{gameId}
+ * - Pool games: /pool/{gameId}
+ * @param {string} gameId - The game ID
+ * @returns {string} Full web URL for the game
+ */
+function getGameShareUrl(gameId) {
+  const baseUrl = getAppBaseUrl();
+  
+  if (isSportsGame(gameId)) {
+    return `${baseUrl}/game/${gameId}`;
+  } else if (isPoolGame(gameId)) {
+    return `${baseUrl}/pool/${gameId}`;
+  } else {
+    // Default to game path for unknown formats
+    return `${baseUrl}/game/${gameId}`;
+  }
+}
+
+/**
+ * Generate the claim URL for a game (used in winner notifications)
+ * @param {string} gameId - The game ID
+ * @returns {string} Full web URL for claiming winnings
+ */
+function getClaimUrl(gameId) {
+  const baseUrl = getAppBaseUrl();
+  return `${baseUrl}/claim/${gameId}`;
+}
+
+/**
+ * Generate the What's New URL
+ * Just opens the What's New overlay (no specific post highlighting)
+ * @param {number} postId - Ignored (kept for compatibility)
+ * @returns {string} Full web URL for What's New
+ */
+function getWhatsNewUrl(postId) {
+  const baseUrl = getAppBaseUrl();
+  // Simple URL with flag to open What's New overlay
+  return `${baseUrl}/v2?openWhatsNew=true`;
+}
+
+module.exports = {
+  getAppBaseUrl,
+  isSportsGame,
+  isPoolGame,
+  getGameShareUrl,
+  getClaimUrl,
+  getWhatsNewUrl
+};
+