bulltrackers-module 1.0.592 → 1.0.593

package/functions/old-generic-api/user-api/helpers/alerts/alert_helpers.js

@@ -0,0 +1,355 @@
+/**
+ * @fileoverview Alert Management API Helpers
+ * Handles fetching and managing user alerts
+ */
+
+const { FieldValue } = require('@google-cloud/firestore');
+const { getAllAlertTypes, getAlertType } = require('../../../../alert-system/helpers/alert_type_registry');
+
+/**
+ * GET /user/me/alert-types
+ * Get all available alert types
+ */
+async function getAlertTypes(req, res, dependencies, config) {
+  try {
+    const alertTypes = getAllAlertTypes();
+    
+    return res.status(200).json({
+      success: true,
+      alertTypes: alertTypes.map(type => ({
+        id: type.id,
+        name: type.name,
+        description: type.description,
+        severity: type.severity,
+        computationName: type.computationName // Include computation name for dynamic watchlists
+      }))
+    });
+  } catch (error) {
+    const { logger } = dependencies;
+    logger.log('ERROR', '[getAlertTypes] Error fetching alert types', error);
+    return res.status(500).json({ error: error.message });
+  }
+}
+
+/**
+ * GET /user/me/dynamic-watchlist-computations
+ * Get available computations for dynamic watchlists (from alert types)
+ */
+async function getDynamicWatchlistComputations(req, res, dependencies, config) {
+  try {
+    const alertTypes = getAllAlertTypes();
+    
+    // Extract unique computations from alert types
+    const computations = alertTypes.map(type => ({
+      computationName: type.computationName,
+      alertTypeName: type.name,
+      description: type.description,
+      severity: type.severity
+    }));
+    
+    return res.status(200).json({
+      success: true,
+      computations
+    });
+  } catch (error) {
+    const { logger } = dependencies;
+    logger.log('ERROR', '[getDynamicWatchlistComputations] Error fetching computations', error);
+    return res.status(500).json({ error: error.message });
+  }
+}
+
+/**
+ * GET /user/me/alerts
+ * Get user's alerts (paginated)
+ */
+async function getUserAlerts(req, res, dependencies, config) {
+  const { db, logger } = dependencies;
+  const { userCid } = req.query;
+  const { unreadOnly, limit = 50, offset = 0, alertType } = req.query;
+  
+  if (!userCid) {
+    return res.status(400).json({ error: "Missing userCid" });
+  }
+  
+  try {
+    const alertsRef = db.collection('user_alerts')
+      .doc(String(userCid))
+      .collection('alerts');
+    
+    let query = alertsRef.orderBy('createdAt', 'desc');
+    
+    // Filter by read status
+    if (unreadOnly === 'true') {
+      query = query.where('read', '==', false);
+    }
+    
+    // Filter by alert type
+    if (alertType) {
+      query = query.where('alertType', '==', alertType);
+    }
+    
+    // Apply pagination
+    query = query.limit(Number(limit)).offset(Number(offset));
+    
+    const snapshot = await query.get();
+    const alerts = [];
+    
+    snapshot.forEach(doc => {
+      const data = doc.data();
+      alerts.push({
+        id: doc.id,
+        ...data,
+        createdAt: data.createdAt?.toDate?.() || data.createdAt,
+        readAt: data.readAt?.toDate?.() || data.readAt
+      });
+    });
+    
+    return res.status(200).json({
+      success: true,
+      alerts: alerts,
+      count: alerts.length,
+      limit: Number(limit),
+      offset: Number(offset)
+    });
+  } catch (error) {
+    logger.log('ERROR', `[getUserAlerts] Error fetching alerts for user ${userCid}`, error);
+    return res.status(500).json({ error: error.message });
+  }
+}
+
+/**
+ * GET /user/me/alerts/count
+ * Get unread alert count
+ */
+async function getAlertCount(req, res, dependencies, config) {
+  const { db, logger } = dependencies;
+  const { userCid } = req.query;
+  
+  if (!userCid) {
+    return res.status(400).json({ error: "Missing userCid" });
+  }
+  
+  try {
+    // Get today's counter
+    const today = new Date().toISOString().split('T')[0];
+    const counterRef = db.collection('user_alerts')
+      .doc(String(userCid))
+      .collection('counters')
+      .doc(today);
+    
+    const counterDoc = await counterRef.get();
+    
+    if (counterDoc.exists) {
+      const data = counterDoc.data();
+      return res.status(200).json({
+        success: true,
+        unreadCount: data.unreadCount || 0,
+        totalCount: data.totalCount || 0,
+        byType: data.byType || {}
+      });
+    }
+    
+    // If no counter exists, count unread alerts directly
+    const unreadSnapshot = await db.collection('user_alerts')
+      .doc(String(userCid))
+      .collection('alerts')
+      .where('read', '==', false)
+      .get();
+    
+    return res.status(200).json({
+      success: true,
+      unreadCount: unreadSnapshot.size,
+      totalCount: unreadSnapshot.size,
+      byType: {}
+    });
+  } catch (error) {
+    logger.log('ERROR', `[getAlertCount] Error fetching alert count for user ${userCid}`, error);
+    return res.status(500).json({ error: error.message });
+  }
+}
+
+/**
+ * PUT /user/me/alerts/:alertId/read
+ * Mark alert as read
+ */
+async function markAlertRead(req, res, dependencies, config) {
+  const { db, logger } = dependencies;
+  const { userCid } = req.query;
+  const { alertId } = req.params;
+  
+  if (!userCid || !alertId) {
+    return res.status(400).json({ error: "Missing userCid or alertId" });
+  }
+  
+  try {
+    const alertRef = db.collection('user_alerts')
+      .doc(String(userCid))
+      .collection('alerts')
+      .doc(alertId);
+    
+    const alertDoc = await alertRef.get();
+    
+    if (!alertDoc.exists) {
+      return res.status(404).json({ error: "Alert not found" });
+    }
+    
+    const alertData = alertDoc.data();
+    
+    // Only update if not already read
+    if (!alertData.read) {
+      await alertRef.update({
+        read: true,
+        readAt: FieldValue.serverTimestamp()
+      });
+      
+      // Update counter
+      const today = new Date().toISOString().split('T')[0];
+      const counterRef = db.collection('user_alerts')
+        .doc(String(userCid))
+        .collection('counters')
+        .doc(today);
+      
+      await counterRef.set({
+        unreadCount: FieldValue.increment(-1),
+        lastUpdated: FieldValue.serverTimestamp()
+      }, { merge: true });
+    }
+    
+    return res.status(200).json({
+      success: true,
+      message: "Alert marked as read"
+    });
+  } catch (error) {
+    logger.log('ERROR', `[markAlertRead] Error marking alert ${alertId} as read`, error);
+    return res.status(500).json({ error: error.message });
+  }
+}
+
+/**
+ * PUT /user/me/alerts/read-all
+ * Mark all alerts as read
+ */
+async function markAllAlertsRead(req, res, dependencies, config) {
+  const { db, logger } = dependencies;
+  const { userCid } = req.query;
+  
+  if (!userCid) {
+    return res.status(400).json({ error: "Missing userCid" });
+  }
+  
+  try {
+    const alertsRef = db.collection('user_alerts')
+      .doc(String(userCid))
+      .collection('alerts');
+    
+    const unreadSnapshot = await alertsRef
+      .where('read', '==', false)
+      .get();
+    
+    if (unreadSnapshot.empty) {
+      return res.status(200).json({
+        success: true,
+        message: "No unread alerts",
+        updated: 0
+      });
+    }
+    
+    const batch = db.batch();
+    let count = 0;
+    
+    unreadSnapshot.forEach(doc => {
+      batch.update(doc.ref, {
+        read: true,
+        readAt: FieldValue.serverTimestamp()
+      });
+      count++;
+    });
+    
+    await batch.commit();
+    
+    // Reset counter
+    const today = new Date().toISOString().split('T')[0];
+    const counterRef = db.collection('user_alerts')
+      .doc(String(userCid))
+      .collection('counters')
+      .doc(today);
+    
+    await counterRef.set({
+      unreadCount: 0,
+      lastUpdated: FieldValue.serverTimestamp()
+    }, { merge: true });
+    
+    return res.status(200).json({
+      success: true,
+      message: "All alerts marked as read",
+      updated: count
+    });
+  } catch (error) {
+    logger.log('ERROR', `[markAllAlertsRead] Error marking all alerts as read for user ${userCid}`, error);
+    return res.status(500).json({ error: error.message });
+  }
+}
+
+/**
+ * DELETE /user/me/alerts/:alertId
+ * Delete specific alert
+ */
+async function deleteAlert(req, res, dependencies, config) {
+  const { db, logger } = dependencies;
+  const { userCid } = req.query;
+  const { alertId } = req.params;
+  
+  if (!userCid || !alertId) {
+    return res.status(400).json({ error: "Missing userCid or alertId" });
+  }
+  
+  try {
+    const alertRef = db.collection('user_alerts')
+      .doc(String(userCid))
+      .collection('alerts')
+      .doc(alertId);
+    
+    const alertDoc = await alertRef.get();
+    
+    if (!alertDoc.exists) {
+      return res.status(404).json({ error: "Alert not found" });
+    }
+    
+    await alertRef.delete();
+    
+    // Update counter if alert was unread
+    const alertData = alertDoc.data();
+    if (!alertData.read) {
+      const today = new Date().toISOString().split('T')[0];
+      const counterRef = db.collection('user_alerts')
+        .doc(String(userCid))
+        .collection('counters')
+        .doc(today);
+      
+      await counterRef.set({
+        unreadCount: FieldValue.increment(-1),
+        totalCount: FieldValue.increment(-1),
+        lastUpdated: FieldValue.serverTimestamp()
+      }, { merge: true });
+    }
+    
+    return res.status(200).json({
+      success: true,
+      message: "Alert deleted"
+    });
+  } catch (error) {
+    logger.log('ERROR', `[deleteAlert] Error deleting alert ${alertId}`, error);
+    return res.status(500).json({ error: error.message });
+  }
+}
+
+module.exports = {
+  getAlertTypes,
+  getDynamicWatchlistComputations,
+  getUserAlerts,
+  getAlertCount,
+  markAlertRead,
+  markAllAlertsRead,
+  deleteAlert
+};
+

package/functions/old-generic-api/user-api/helpers/alerts/subscription_helpers.js

@@ -0,0 +1,327 @@
+/**
+ * @fileoverview Alert Subscription Management Helpers
+ * Handles subscriptions for watchlist alerts (static and dynamic)
+ */
+
+const { FieldValue } = require('@google-cloud/firestore');
+
+/**
+ * POST /user/me/subscriptions
+ * Subscribe to alerts for a PI in a watchlist
+ */
+async function subscribeToAlerts(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid, watchlistId, piCid, alertTypes, thresholds } = req.body;
+    
+    if (!userCid || !watchlistId || !piCid) {
+        return res.status(400).json({ error: "Missing required fields: userCid, watchlistId, piCid" });
+    }
+    
+    try {
+        // Verify watchlist exists and belongs to user
+        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+        const watchlistRef = db.collection(watchlistsCollection)
+            .doc(String(userCid))
+            .collection('lists')
+            .doc(watchlistId);
+        
+        const watchlistDoc = await watchlistRef.get();
+        
+        if (!watchlistDoc.exists) {
+            return res.status(404).json({ error: "Watchlist not found" });
+        }
+        
+        const watchlistData = watchlistDoc.data();
+        
+        // Verify PI is in the watchlist
+        let piInWatchlist = false;
+        if (watchlistData.type === 'static') {
+            piInWatchlist = watchlistData.items?.some(item => item.cid === Number(piCid));
+        } else if (watchlistData.type === 'dynamic') {
+            // For dynamic watchlists, we'll check if the PI is in the current computation result
+            // This is a simplified check - in production, you'd fetch the latest computation result
+            piInWatchlist = true; // Allow subscriptions for dynamic watchlists
+        }
+        
+        if (!piInWatchlist && watchlistData.type === 'static') {
+            return res.status(400).json({ error: "PI is not in this watchlist" });
+        }
+        
+        // Default alert types (all enabled) if not provided
+        const defaultAlertTypes = {
+            newPositions: true,
+            volatilityChanges: true,
+            increasedRisk: true,
+            newSector: true,
+            increasedPositionSize: true,
+            newSocialPost: true
+        };
+        
+        const subscriptionData = {
+            userCid: Number(userCid),
+            piCid: Number(piCid),
+            watchlistId: watchlistId,
+            alertTypes: alertTypes || defaultAlertTypes,
+            thresholds: thresholds || {},
+            subscribedAt: FieldValue.serverTimestamp(),
+            lastAlertAt: null
+        };
+        
+        // Store subscription
+        const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
+        const subscriptionRef = db.collection(subscriptionsCollection)
+            .doc(String(userCid))
+            .collection('alerts')
+            .doc(String(piCid));
+        
+        await subscriptionRef.set(subscriptionData, { merge: true });
+        
+        logger.log('SUCCESS', `[subscribeToAlerts] User ${userCid} subscribed to alerts for PI ${piCid} in watchlist ${watchlistId}`);
+        
+        return res.status(200).json({
+            success: true,
+            subscription: subscriptionData
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[subscribeToAlerts] Error creating subscription for user ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * PUT /user/me/subscriptions/:piCid
+ * Update alert subscription settings
+ */
+async function updateSubscription(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    const { piCid } = req.params;
+    const { alertTypes, thresholds } = req.body;
+    
+    if (!userCid || !piCid) {
+        return res.status(400).json({ error: "Missing userCid or piCid" });
+    }
+    
+    try {
+        const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
+        const subscriptionRef = db.collection(subscriptionsCollection)
+            .doc(String(userCid))
+            .collection('alerts')
+            .doc(String(piCid));
+        
+        const subscriptionDoc = await subscriptionRef.get();
+        
+        if (!subscriptionDoc.exists) {
+            return res.status(404).json({ error: "Subscription not found" });
+        }
+        
+        const updates = {};
+        
+        if (alertTypes !== undefined) {
+            updates.alertTypes = alertTypes;
+        }
+        
+        if (thresholds !== undefined) {
+            updates.thresholds = thresholds;
+        }
+        
+        if (Object.keys(updates).length === 0) {
+            return res.status(400).json({ error: "No updates provided" });
+        }
+        
+        updates.updatedAt = FieldValue.serverTimestamp();
+        
+        await subscriptionRef.update(updates);
+        
+        logger.log('SUCCESS', `[updateSubscription] Updated subscription for user ${userCid}, PI ${piCid}`);
+        
+        const updatedDoc = await subscriptionRef.get();
+        return res.status(200).json({
+            success: true,
+            subscription: {
+                id: updatedDoc.id,
+                ...updatedDoc.data()
+            }
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[updateSubscription] Error updating subscription for user ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * DELETE /user/me/subscriptions/:piCid
+ * Unsubscribe from alerts for a PI
+ */
+async function unsubscribeFromAlerts(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    const { piCid } = req.params;
+    
+    if (!userCid || !piCid) {
+        return res.status(400).json({ error: "Missing userCid or piCid" });
+    }
+    
+    try {
+        const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
+        const subscriptionRef = db.collection(subscriptionsCollection)
+            .doc(String(userCid))
+            .collection('alerts')
+            .doc(String(piCid));
+        
+        const subscriptionDoc = await subscriptionRef.get();
+        
+        if (!subscriptionDoc.exists) {
+            return res.status(404).json({ error: "Subscription not found" });
+        }
+        
+        await subscriptionRef.delete();
+        
+        logger.log('SUCCESS', `[unsubscribeFromAlerts] User ${userCid} unsubscribed from alerts for PI ${piCid}`);
+        
+        return res.status(200).json({
+            success: true,
+            message: "Unsubscribed successfully"
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[unsubscribeFromAlerts] Error unsubscribing user ${userCid} from PI ${piCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * GET /user/me/subscriptions
+ * Get all subscriptions for a user
+ */
+async function getUserSubscriptions(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    
+    if (!userCid) {
+        return res.status(400).json({ error: "Missing userCid" });
+    }
+    
+    try {
+        const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
+        const subscriptionsRef = db.collection(subscriptionsCollection)
+            .doc(String(userCid))
+            .collection('alerts');
+        
+        const snapshot = await subscriptionsRef.get();
+        
+        const subscriptions = [];
+        snapshot.forEach(doc => {
+            subscriptions.push({
+                piCid: Number(doc.id),
+                ...doc.data()
+            });
+        });
+        
+        return res.status(200).json({
+            subscriptions,
+            count: subscriptions.length
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[getUserSubscriptions] Error fetching subscriptions for user ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * POST /user/me/watchlists/:id/subscribe-all
+ * Subscribe to all PIs in a watchlist with default alert settings
+ */
+async function subscribeToWatchlist(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    const { id } = req.params;
+    const { alertTypes, thresholds } = req.body;
+    
+    if (!userCid || !id) {
+        return res.status(400).json({ error: "Missing userCid or watchlist id" });
+    }
+    
+    try {
+        // Get watchlist
+        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+        const watchlistRef = db.collection(watchlistsCollection)
+            .doc(String(userCid))
+            .collection('lists')
+            .doc(id);
+        
+        const watchlistDoc = await watchlistRef.get();
+        
+        if (!watchlistDoc.exists) {
+            return res.status(404).json({ error: "Watchlist not found" });
+        }
+        
+        const watchlistData = watchlistDoc.data();
+        
+        // Default alert types
+        const defaultAlertTypes = alertTypes || {
+            newPositions: true,
+            volatilityChanges: true,
+            increasedRisk: true,
+            newSector: true,
+            increasedPositionSize: true,
+            newSocialPost: true
+        };
+        
+        const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
+        const subscriptionsRef = db.collection(subscriptionsCollection)
+            .doc(String(userCid))
+            .collection('alerts');
+        
+        let subscribedCount = 0;
+        
+        if (watchlistData.type === 'static') {
+            // Subscribe to all PIs in static watchlist
+            const items = watchlistData.items || [];
+            
+            for (const item of items) {
+                const subscriptionData = {
+                    userCid: Number(userCid),
+                    piCid: item.cid,
+                    watchlistId: id,
+                    alertTypes: item.alertConfig || defaultAlertTypes,
+                    thresholds: thresholds || {},
+                    subscribedAt: FieldValue.serverTimestamp(),
+                    lastAlertAt: null
+                };
+                
+                await subscriptionsRef.doc(String(item.cid)).set(subscriptionData, { merge: true });
+                subscribedCount++;
+            }
+        } else if (watchlistData.type === 'dynamic') {
+            // For dynamic watchlists, we'd need to fetch the current computation result
+            // For now, we'll just set up the subscription structure
+            // The actual PIs will be determined when the computation runs
+            logger.log('INFO', `[subscribeToWatchlist] Dynamic watchlist subscription setup for ${id} (will be populated by computation)`);
+        }
+        
+        logger.log('SUCCESS', `[subscribeToWatchlist] Subscribed user ${userCid} to ${subscribedCount} PIs in watchlist ${id}`);
+        
+        return res.status(200).json({
+            success: true,
+            subscribed: subscribedCount,
+            watchlistId: id,
+            watchlistType: watchlistData.type
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[subscribeToWatchlist] Error subscribing to watchlist ${id} for user ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+module.exports = {
+    subscribeToAlerts,
+    updateSubscription,
+    unsubscribeFromAlerts,
+    getUserSubscriptions,
+    subscribeToWatchlist
+};