bulltrackers-module 1.0.494 → 1.0.495

package/functions/alert-system/helpers/alert_helpers.js

@@ -29,15 +29,41 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
     // 3. Generate alert message
     const alertMessage = generateAlertMessage(alertType, piUsername, computationMetadata);
     
+    // Helper function to get Firebase UID from eToro CID
+    async function getFirebaseUidFromCid(etoroCid) {
+      const signedInUsersSnapshot = await db.collection('signedInUsers')
+        .where('etoroCID', '==', Number(etoroCid))
+        .limit(1)
+        .get();
+      
+      if (!signedInUsersSnapshot.empty) {
+        return signedInUsersSnapshot.docs[0].id; // Firebase UID is the document ID
+      }
+      return null;
+    }
+    
     // 4. Create notifications for each subscribed user (using user_notifications collection)
+    // Convert eToro CIDs to Firebase UIDs first
     const batch = db.batch();
     const notificationRefs = [];
     const counterUpdates = {};
+    const uidMapping = {}; // Cache for CID -> UID mappings
     
     for (const subscription of subscriptions) {
+      // Get Firebase UID for this user's eToro CID
+      let firebaseUid = uidMapping[subscription.userCid];
+      if (!firebaseUid) {
+        firebaseUid = await getFirebaseUidFromCid(subscription.userCid);
+        if (!firebaseUid) {
+          logger.log('WARN', `[processAlertForPI] Could not find Firebase UID for user CID ${subscription.userCid}, skipping notification`);
+          continue; // Skip this user if we can't find their Firebase UID
+        }
+        uidMapping[subscription.userCid] = firebaseUid;
+      }
+      
       const notificationId = `alert_${Date.now()}_${subscription.userCid}_${piCid}_${Math.random().toString(36).substring(2, 9)}`;
       const notificationRef = db.collection('user_notifications')
-        .doc(String(subscription.userCid))
+        .doc(firebaseUid) // Use Firebase UID, not eToro CID
         .collection('notifications')
         .doc(notificationId);
       
@@ -48,6 +74,7 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
         message: alertMessage,
         read: false,
         createdAt: FieldValue.serverTimestamp(),
+        timestamp: FieldValue.serverTimestamp(), // Also include timestamp for ordering
         metadata: {
           piCid: Number(piCid),
           piUsername: piUsername,
@@ -65,26 +92,26 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
       batch.set(notificationRef, notificationData);
       notificationRefs.push(notificationRef);
       
-      // Track counter updates
+      // Track counter updates (using Firebase UID as key)
       const dateKey = computationDate || new Date().toISOString().split('T')[0];
-      if (!counterUpdates[subscription.userCid]) {
-        counterUpdates[subscription.userCid] = {
+      if (!counterUpdates[firebaseUid]) {
+        counterUpdates[firebaseUid] = {
           date: dateKey,
           unreadCount: 0,
           totalCount: 0,
           byType: {}
         };
       }
-      counterUpdates[subscription.userCid].unreadCount += 1;
-      counterUpdates[subscription.userCid].totalCount += 1;
-      counterUpdates[subscription.userCid].byType[alertType.id] = 
-        (counterUpdates[subscription.userCid].byType[alertType.id] || 0) + 1;
+      counterUpdates[firebaseUid].unreadCount += 1;
+      counterUpdates[firebaseUid].totalCount += 1;
+      counterUpdates[firebaseUid].byType[alertType.id] = 
+        (counterUpdates[firebaseUid].byType[alertType.id] || 0) + 1;
     }
     
-    // 5. Update notification counters
-    for (const [userCid, counter] of Object.entries(counterUpdates)) {
+    // 5. Update notification counters (using Firebase UIDs)
+    for (const [firebaseUid, counter] of Object.entries(counterUpdates)) {
       const counterRef = db.collection('user_notifications')
-        .doc(String(userCid))
+        .doc(firebaseUid) // Use Firebase UID, not eToro CID
         .collection('counters')
         .doc(counter.date);
       

package/functions/generic-api/user-api/helpers/test_alert_helpers.js

@@ -59,36 +59,73 @@ async function sendTestAlert(req, res, dependencies, config) {
             logger.log('INFO', `[sendTestAlert] Using default alert type: ${alertType.id}`);
         }
         
-        // Determine target user CIDs
-        let targetCids = [];
+        // Helper function to get Firebase UID from eToro CID
+        async function getFirebaseUidFromCid(etoroCid) {
+            const signedInUsersSnapshot = await db.collection('signedInUsers')
+                .where('etoroCID', '==', Number(etoroCid))
+                .limit(1)
+                .get();
+            
+            if (!signedInUsersSnapshot.empty) {
+                return signedInUsersSnapshot.docs[0].id; // Firebase UID is the document ID
+            }
+            return null;
+        }
+        
+        // Determine target users (as Firebase UIDs)
+        let targetFirebaseUids = [];
         
         if (targetUsers === 'all') {
-            // Get all users from user_notifications collection
-            const notificationsSnapshot = await db.collection('user_notifications').get();
-            targetCids = notificationsSnapshot.docs.map(doc => Number(doc.id));
-            logger.log('INFO', `[sendTestAlert] Sending to all ${targetCids.length} users`);
+            // Get all users from signedInUsers collection (who have etoroCID)
+            const signedInUsersSnapshot = await db.collection('signedInUsers')
+                .where('etoroCID', '!=', null)
+                .get();
+            
+            targetFirebaseUids = signedInUsersSnapshot.docs.map(doc => doc.id);
+            logger.log('INFO', `[sendTestAlert] Sending to all ${targetFirebaseUids.length} users`);
         } else if (targetUsers === 'dev') {
             // Get all developer accounts with dev override enabled
             const devOverridesCollection = config.devOverridesCollection || 'dev_overrides';
             const devOverridesSnapshot = await db.collection(devOverridesCollection).get();
             
+            const devCids = [];
             for (const doc of devOverridesSnapshot.docs) {
                 const data = doc.data();
                 if (data.enabled === true) {
-                    targetCids.push(Number(doc.id));
+                    devCids.push(Number(doc.id));
                 }
             }
             
             // Also include the requesting developer
-            if (!targetCids.includes(Number(userCid))) {
-                targetCids.push(Number(userCid));
+            if (!devCids.includes(Number(userCid))) {
+                devCids.push(Number(userCid));
+            }
+            
+            // Convert eToro CIDs to Firebase UIDs
+            for (const cid of devCids) {
+                const firebaseUid = await getFirebaseUidFromCid(cid);
+                if (firebaseUid) {
+                    targetFirebaseUids.push(firebaseUid);
+                } else {
+                    logger.log('WARN', `[sendTestAlert] Could not find Firebase UID for developer CID ${cid}`);
+                }
             }
             
-            logger.log('INFO', `[sendTestAlert] Sending to ${targetCids.length} developer accounts`);
+            logger.log('INFO', `[sendTestAlert] Sending to ${targetFirebaseUids.length} developer accounts`);
         } else if (Array.isArray(targetUsers)) {
-            // Specific user CIDs
-            targetCids = targetUsers.map(cid => Number(cid)).filter(cid => !isNaN(cid) && cid > 0);
-            logger.log('INFO', `[sendTestAlert] Sending to ${targetCids.length} specific users`);
+            // Specific user CIDs - convert to Firebase UIDs
+            const specificCids = targetUsers.map(cid => Number(cid)).filter(cid => !isNaN(cid) && cid > 0);
+            
+            for (const cid of specificCids) {
+                const firebaseUid = await getFirebaseUidFromCid(cid);
+                if (firebaseUid) {
+                    targetFirebaseUids.push(firebaseUid);
+                } else {
+                    logger.log('WARN', `[sendTestAlert] Could not find Firebase UID for CID ${cid}`);
+                }
+            }
+            
+            logger.log('INFO', `[sendTestAlert] Sending to ${targetFirebaseUids.length} specific users (from ${specificCids.length} CIDs)`);
         } else {
             return res.status(400).json({ 
                 error: "Invalid targetUsers",
@@ -96,7 +133,7 @@ async function sendTestAlert(req, res, dependencies, config) {
             });
         }
         
-        if (targetCids.length === 0) {
+        if (targetFirebaseUids.length === 0) {
             return res.status(400).json({ 
                 error: "No target users",
                 message: "No users found matching the target criteria"
@@ -112,16 +149,16 @@ async function sendTestAlert(req, res, dependencies, config) {
             testSentAt: new Date().toISOString()
         });
         
-        // Create notifications for each target user
+        // Create notifications for each target user (using Firebase UIDs)
         const batch = db.batch();
         const notificationRefs = [];
         const counterUpdates = {};
         const today = new Date().toISOString().split('T')[0];
         
-        for (const targetCid of targetCids) {
-            const notificationId = `test_alert_${Date.now()}_${targetCid}_${piCid}_${Math.random().toString(36).substring(2, 9)}`;
+        for (const firebaseUid of targetFirebaseUids) {
+            const notificationId = `test_alert_${Date.now()}_${firebaseUid}_${piCid}_${Math.random().toString(36).substring(2, 9)}`;
             const notificationRef = db.collection('user_notifications')
-                .doc(String(targetCid))
+                .doc(firebaseUid) // Use Firebase UID, not eToro CID
                 .collection('notifications')
                 .doc(notificationId);
             
@@ -132,6 +169,7 @@ async function sendTestAlert(req, res, dependencies, config) {
                 message: alertMessage,
                 read: false,
                 createdAt: FieldValue.serverTimestamp(),
+                timestamp: FieldValue.serverTimestamp(), // Also include timestamp for ordering
                 metadata: {
                     piCid: Number(piCid),
                     piUsername: piUsername,
@@ -150,25 +188,25 @@ async function sendTestAlert(req, res, dependencies, config) {
             batch.set(notificationRef, notificationData);
             notificationRefs.push(notificationRef);
             
-            // Track counter updates
-            if (!counterUpdates[targetCid]) {
-                counterUpdates[targetCid] = {
+            // Track counter updates (using Firebase UID as key)
+            if (!counterUpdates[firebaseUid]) {
+                counterUpdates[firebaseUid] = {
                     date: today,
                     unreadCount: 0,
                     totalCount: 0,
                     byType: {}
                 };
             }
-            counterUpdates[targetCid].unreadCount += 1;
-            counterUpdates[targetCid].totalCount += 1;
-            counterUpdates[targetCid].byType[alertType.id] = 
-                (counterUpdates[targetCid].byType[alertType.id] || 0) + 1;
+            counterUpdates[firebaseUid].unreadCount += 1;
+            counterUpdates[firebaseUid].totalCount += 1;
+            counterUpdates[firebaseUid].byType[alertType.id] = 
+                (counterUpdates[firebaseUid].byType[alertType.id] || 0) + 1;
         }
         
-        // Update notification counters
-        for (const [targetCid, counter] of Object.entries(counterUpdates)) {
+        // Update notification counters (using Firebase UIDs)
+        for (const [firebaseUid, counter] of Object.entries(counterUpdates)) {
             const counterRef = db.collection('user_notifications')
-                .doc(String(targetCid))
+                .doc(firebaseUid) // Use Firebase UID, not eToro CID
                 .collection('counters')
                 .doc(counter.date);
             
@@ -188,15 +226,15 @@ async function sendTestAlert(req, res, dependencies, config) {
         
         return res.status(200).json({
             success: true,
-            message: `Test alert sent to ${targetCids.length} users`,
+            message: `Test alert sent to ${targetFirebaseUids.length} users`,
             alertType: {
                 id: alertType.id,
                 name: alertType.name,
                 computationName: alertType.computationName
             },
             targetUsers: {
-                count: targetCids.length,
-                cids: targetCids
+                count: targetFirebaseUids.length,
+                firebaseUids: targetFirebaseUids
             },
             piCid: Number(piCid),
             piUsername: piUsername,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.494",
+  "version": "1.0.495",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [