bulltrackers-module 1.0.523 → 1.0.525

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

@@ -6,11 +6,12 @@
 const { FieldValue } = require('@google-cloud/firestore');
 const zlib = require('zlib');
 const { getAlertTypeByComputation, generateAlertMessage } = require('./alert_type_registry');
+const { writeWithMigration } = require('../../generic-api/user-api/helpers/core/path_resolution_helpers');
 
 /**
  * Process alerts for a specific PI from computation results
  */
-async function processAlertForPI(db, logger, piCid, alertType, computationMetadata, computationDate) {
+async function processAlertForPI(db, logger, piCid, alertType, computationMetadata, computationDate, dependencies = {}) {
   try {
     // 1. Get PI username from rankings or subscriptions
     const piUsername = await getPIUsername(db, piCid);
@@ -29,52 +30,24 @@ 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
+    // 4. Create notifications for each subscribed user (using CID and collection registry)
+    const { collectionRegistry } = dependencies;
+    const config = dependencies.config || {};
+    const notificationPromises = [];
     
     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(firebaseUid) // Use Firebase UID, not eToro CID
-        .collection('notifications')
-        .doc(notificationId);
+      const userCid = subscription.userCid;
+      const notificationId = `alert_${Date.now()}_${userCid}_${piCid}_${Math.random().toString(36).substring(2, 9)}`;
       
       const notificationData = {
         id: notificationId,
-        type: 'alert',
+        type: 'watchlistAlerts', // Use watchlistAlerts type for watchlist-based alerts
+        subType: 'alert',
         title: alertType.name,
         message: alertMessage,
         read: false,
+        timestamp: FieldValue.serverTimestamp(),
         createdAt: FieldValue.serverTimestamp(),
-        timestamp: FieldValue.serverTimestamp(), // Also include timestamp for ordering
         metadata: {
           piCid: Number(piCid),
           piUsername: piUsername,
@@ -85,54 +58,46 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
           severity: alertType.severity,
           watchlistId: subscription.watchlistId,
           watchlistName: subscription.watchlistName,
+          notificationType: 'watchlistAlerts',
+          userCid: Number(userCid),
           ...(computationMetadata || {})
         }
       };
       
-      batch.set(notificationRef, notificationData);
-      notificationRefs.push(notificationRef);
-      
-      // Track counter updates (using Firebase UID as key)
-      const dateKey = computationDate || new Date().toISOString().split('T')[0];
-      if (!counterUpdates[firebaseUid]) {
-        counterUpdates[firebaseUid] = {
-          date: dateKey,
-          unreadCount: 0,
-          totalCount: 0,
-          byType: {}
-        };
-      }
-      counterUpdates[firebaseUid].unreadCount += 1;
-      counterUpdates[firebaseUid].totalCount += 1;
-      counterUpdates[firebaseUid].byType[alertType.id] = 
-        (counterUpdates[firebaseUid].byType[alertType.id] || 0) + 1;
-    }
-    
-    // 5. Update notification counters (using Firebase UIDs)
-    for (const [firebaseUid, counter] of Object.entries(counterUpdates)) {
-      const counterRef = db.collection('user_notifications')
-        .doc(firebaseUid) // Use Firebase UID, not eToro CID
-        .collection('counters')
-        .doc(counter.date);
+      // Use writeWithMigration to write to new path (with legacy fallback)
+      // notifications is a subcollection, so we need isCollection: true and documentId
+      const writePromise = writeWithMigration(
+        db,
+        'signedInUsers',
+        'notifications',
+        { cid: String(userCid) },
+        notificationData,
+        {
+          isCollection: true,
+          merge: false,
+          dataType: 'notifications',
+          documentId: notificationId,
+          dualWrite: false, // Disable dual write - we're fully migrated to new path
+          config,
+          collectionRegistry
+        }
+      ).catch(err => {
+        logger.log('ERROR', `[processAlertForPI] Failed to write notification for CID ${userCid}: ${err.message}`, err);
+        throw err; // Re-throw so we know if writes are failing
+      });
       
-      batch.set(counterRef, {
-        date: counter.date,
-        unreadCount: FieldValue.increment(counter.unreadCount),
-        totalCount: FieldValue.increment(counter.totalCount),
-        [`byType.${alertType.id}`]: FieldValue.increment(counter.byType[alertType.id] || 0),
-        lastUpdated: FieldValue.serverTimestamp()
-      }, { merge: true });
+      notificationPromises.push(writePromise);
     }
     
-    // 6. Commit batch
-    await batch.commit();
+    // Wait for all notifications to be written
+    await Promise.all(notificationPromises);
     
     // 7. Update global rootdata collection for computation system
     const { updateAlertHistoryRootData } = require('../../generic-api/user-api/helpers/rootdata/rootdata_aggregation_helpers');
     const triggeredUserCids = subscriptions.map(s => s.userCid);
     await updateAlertHistoryRootData(db, logger, piCid, alertType, computationMetadata, computationDate, triggeredUserCids);
     
-    logger.log('SUCCESS', `[processAlertForPI] Created ${notificationRefs.length} notifications for PI ${piCid}, alert type ${alertType.id}`);
+    logger.log('SUCCESS', `[processAlertForPI] Created ${notificationPromises.length} notifications for PI ${piCid}, alert type ${alertType.id}`);
     
   } catch (error) {
     logger.log('ERROR', `[processAlertForPI] Error processing alert for PI ${piCid}`, error);

package/functions/alert-system/index.js

@@ -100,7 +100,8 @@ async function handleAlertTrigger(message, context, config, dependencies) {
           piCid,
           alertType,
           piMetadata,
-          date
+          date,
+          dependencies
         );
         processedCount++;
       } catch (error) {
@@ -116,7 +117,7 @@ async function handleAlertTrigger(message, context, config, dependencies) {
     // This runs after all alert computations are processed
     if (processedCount > 0 || results.cids.length > 0) {
       // Check if any PIs were processed but didn't trigger alerts
-      await checkAndSendAllClearNotifications(db, logger, results.cids, date, config);
+      await checkAndSendAllClearNotifications(db, logger, results.cids, date, config, dependencies);
     }
     
   } catch (error) {
@@ -179,7 +180,7 @@ async function handleComputationResultWrite(change, context, config, dependencie
       const docData = change.after.data();
       const results = await readComputationResultsWithShards(db, docData, change.after.ref);
       if (results.cids && results.cids.length > 0) {
-        await checkAndSendAllClearNotifications(db, logger, results.cids, date, config);
+        await checkAndSendAllClearNotifications(db, logger, results.cids, date, config, dependencies);
       }
       return; // Don't process as alert computation
     }
@@ -221,7 +222,8 @@ async function handleComputationResultWrite(change, context, config, dependencie
           piCid,
           alertType,
           piMetadata,
-          date
+          date,
+          dependencies
         );
         processedCount++;
       } catch (error) {
@@ -244,7 +246,7 @@ async function handleComputationResultWrite(change, context, config, dependencie
  * Send "all clear" notifications to users who have these PIs in their static watchlists
  * This should be called after PopularInvestorProfileMetrics is computed (not just alert computations)
  */
-async function checkAndSendAllClearNotifications(db, logger, processedPICids, computationDate, config) {
+async function checkAndSendAllClearNotifications(db, logger, processedPICids, computationDate, config, dependencies = {}) {
   try {
     const today = computationDate || new Date().toISOString().split('T')[0];
     
@@ -275,7 +277,7 @@ async function checkAndSendAllClearNotifications(db, logger, processedPICids, co
           const piCid = Number(item.cid);
           if (processedPICids.includes(piCid)) {
             // Check if this PI triggered any alerts today for this user
-            const hasAlerts = await checkIfPIHasAlertsToday(db, logger, userCid, piCid, today);
+            const hasAlerts = await checkIfPIHasAlertsToday(db, logger, userCid, piCid, today, dependencies);
             
             if (!hasAlerts) {
               // No alerts triggered - send "all clear" notification
@@ -296,7 +298,7 @@ async function checkAndSendAllClearNotifications(db, logger, processedPICids, co
     let totalNotifications = 0;
     for (const [userCid, pisMap] of usersToNotify.entries()) {
       for (const [piCid, pi] of pisMap.entries()) {
-        await sendAllClearNotification(db, logger, userCid, pi.cid, pi.username, today);
+        await sendAllClearNotification(db, logger, userCid, pi.cid, pi.username, today, dependencies);
         totalNotifications++;
       }
     }
@@ -313,17 +315,27 @@ async function checkAndSendAllClearNotifications(db, logger, processedPICids, co
 
 /**
  * Check if a PI has any alerts for a user today
- * Checks user_notifications collection for alert-type notifications
+ * Checks SignedInUsers/{cid}/notifications collection for alert-type notifications
  */
-async function checkIfPIHasAlertsToday(db, logger, userCid, piCid, date) {
+async function checkIfPIHasAlertsToday(db, logger, userCid, piCid, date, dependencies = {}) {
   try {
-    const notificationsRef = db.collection('user_notifications')
-      .doc(String(userCid))
-      .collection('notifications');
+    const { collectionRegistry } = dependencies;
+    const config = dependencies.config || {};
+    
+    // Use collection registry to get notifications path
+    let notificationsPath;
+    if (collectionRegistry && collectionRegistry.getCollectionPath) {
+      notificationsPath = collectionRegistry.getCollectionPath('signedInUsers', 'notifications', { cid: String(userCid) });
+    } else {
+      // Fallback to legacy path
+      notificationsPath = `user_notifications/${userCid}/notifications`;
+    }
+    
+    const notificationsRef = db.collection(notificationsPath);
     
     // Check if there are any alert notifications for this PI today
     const snapshot = await notificationsRef
-      .where('type', '==', 'alert')
+      .where('type', '==', 'watchlistAlerts')
       .where('metadata.piCid', '==', Number(piCid))
       .where('metadata.computationDate', '==', date)
       .limit(1)
@@ -342,59 +354,76 @@ async function checkIfPIHasAlertsToday(db, logger, userCid, piCid, date) {
 /**
  * Send an "all clear" notification to a user
  */
-async function sendAllClearNotification(db, logger, userCid, piCid, piUsername, date) {
+async function sendAllClearNotification(db, logger, userCid, piCid, piUsername, date, dependencies = {}) {
   try {
     const { FieldValue } = require('@google-cloud/firestore');
+    const { collectionRegistry } = dependencies;
+    const config = dependencies.config || {};
+    
+    // Use collection registry to get notifications path
+    let notificationsPath;
+    if (collectionRegistry && collectionRegistry.getCollectionPath) {
+      notificationsPath = collectionRegistry.getCollectionPath('signedInUsers', 'notifications', { cid: String(userCid) });
+    } else {
+      // Fallback to legacy path
+      notificationsPath = `user_notifications/${userCid}/notifications`;
+    }
     
     // Check if we already sent an all-clear notification for this PI today
-    const existingRef = db.collection('user_alerts')
-      .doc(String(userCid))
-      .collection('alerts')
-      .where('piCid', '==', Number(piCid))
-      .where('alertType', '==', 'all_clear')
-      .where('computationDate', '==', date)
-      .limit(1);
-    
-    const existingSnapshot = await existingRef.get();
+    const existingSnapshot = await db.collection(notificationsPath)
+      .where('type', '==', 'watchlistAlerts')
+      .where('subType', '==', 'all_clear')
+      .where('metadata.piCid', '==', Number(piCid))
+      .where('metadata.computationDate', '==', date)
+      .limit(1)
+      .get();
+    
     if (!existingSnapshot.empty) {
       // Already sent notification for this PI today
       return;
     }
     
-    // Create the notification using the notification system
-    const notificationRef = db.collection('user_notifications')
-      .doc(String(userCid))
-      .collection('notifications')
-      .doc();
-    
-    await notificationRef.set({
-      id: notificationRef.id,
-      type: 'alert',
+    // Create the notification using writeWithMigration
+    const notificationId = `all_clear_${Date.now()}_${userCid}_${piCid}_${Math.random().toString(36).substring(2, 9)}`;
+    const notificationData = {
+      id: notificationId,
+      type: 'watchlistAlerts',
+      subType: 'all_clear',
       title: 'All Clear',
       message: `${piUsername} was processed, all clear today!`,
-      piCid: Number(piCid),
-      piUsername: piUsername,
-      alertType: 'all_clear',
-      computationDate: date,
       read: false,
+      timestamp: FieldValue.serverTimestamp(),
       createdAt: FieldValue.serverTimestamp(),
       metadata: {
+        piCid: Number(piCid),
+        piUsername: piUsername,
+        alertType: 'all_clear',
+        computationDate: date,
+        notificationType: 'watchlistAlerts',
+        userCid: Number(userCid),
         message: 'User was processed, all clear today!'
       }
-    });
-    
-    // Update notification counter
-    const counterRef = db.collection('user_notifications')
-      .doc(String(userCid))
-      .collection('counters')
-      .doc(date);
-    
-    await counterRef.set({
-      date: date,
-      unreadCount: FieldValue.increment(1),
-      totalCount: FieldValue.increment(1),
-      lastUpdated: FieldValue.serverTimestamp()
-    }, { merge: true });
+    };
+    
+    // Use writeWithMigration to write to new path (with legacy fallback)
+    // notifications is a subcollection, so we need isCollection: true and documentId
+    const { writeWithMigration } = require('../generic-api/user-api/helpers/core/path_resolution_helpers');
+    await writeWithMigration(
+      db,
+      'signedInUsers',
+      'notifications',
+      { cid: String(userCid) },
+      notificationData,
+      {
+        isCollection: true,
+        merge: false,
+        dataType: 'notifications',
+        documentId: notificationId,
+        dualWrite: false, // Disable dual write - we're fully migrated to new path
+        config,
+        collectionRegistry
+      }
+    );
     
     logger.log('INFO', `[sendAllClearNotification] Sent all-clear notification to user ${userCid} for PI ${piCid}`);
     

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

@@ -6,6 +6,8 @@
 const { FieldValue } = require('@google-cloud/firestore');
 const { getAllAlertTypes, getAlertTypeByComputation } = require('../../../../alert-system/helpers/alert_type_registry');
 const { isDeveloperAccount, getDevOverride } = require('../dev/dev_helpers');
+const { getCidFromFirebaseUid } = require('../core/path_resolution_helpers');
+const { writeWithMigration } = require('../core/path_resolution_helpers');
 
 /**
  * POST /user/dev/test-alert
@@ -22,7 +24,7 @@ const { isDeveloperAccount, getDevOverride } = require('../dev/dev_helpers');
  * }
  */
 async function sendTestAlert(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
+    const { db, logger, collectionRegistry } = dependencies;
     const { userCid, alertTypeId, targetUsers = 'dev', piCid = 1, piUsername = 'TestPI', metadata = {} } = req.body;
     
     if (!userCid) {
@@ -59,21 +61,8 @@ async function sendTestAlert(req, res, dependencies, config) {
             logger.log('INFO', `[sendTestAlert] Using default alert type: ${alertType.id}`);
         }
         
-        // 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 = [];
+        // Determine target users (as eToro CIDs)
+        let targetCids = [];
         
         if (targetUsers === 'all') {
             // Get all users from signedInUsers collection (who have etoroCID)
@@ -81,8 +70,10 @@ async function sendTestAlert(req, res, dependencies, config) {
                 .where('etoroCID', '!=', null)
                 .get();
             
-            targetFirebaseUids = signedInUsersSnapshot.docs.map(doc => doc.id);
-            logger.log('INFO', `[sendTestAlert] Sending to all ${targetFirebaseUids.length} users`);
+            targetCids = signedInUsersSnapshot.docs
+                .map(doc => doc.data().etoroCID)
+                .filter(cid => cid != null);
+            logger.log('INFO', `[sendTestAlert] Sending to all ${targetCids.length} users`);
         } else if (targetUsers === 'dev') {
             // Get all developer accounts with dev override enabled
             const devOverridesCollection = config.devOverridesCollection || 'dev_overrides';
@@ -101,31 +92,12 @@ async function sendTestAlert(req, res, dependencies, config) {
                 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 ${targetFirebaseUids.length} developer accounts`);
+            targetCids = devCids;
+            logger.log('INFO', `[sendTestAlert] Sending to ${targetCids.length} developer accounts`);
         } else if (Array.isArray(targetUsers)) {
-            // 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)`);
+            // 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`);
         } else {
             return res.status(400).json({ 
                 error: "Invalid targetUsers",
@@ -133,7 +105,7 @@ async function sendTestAlert(req, res, dependencies, config) {
             });
         }
         
-        if (targetFirebaseUids.length === 0) {
+        if (targetCids.length === 0) {
             return res.status(400).json({ 
                 error: "No target users",
                 message: "No users found matching the target criteria"
@@ -149,27 +121,22 @@ async function sendTestAlert(req, res, dependencies, config) {
             testSentAt: new Date().toISOString()
         });
         
-        // Create notifications for each target user (using Firebase UIDs)
-        const batch = db.batch();
-        const notificationRefs = [];
-        const counterUpdates = {};
+        // Create notifications for each target user (using eToro CIDs and collection registry)
+        const notificationPromises = [];
         const today = new Date().toISOString().split('T')[0];
         
-        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(firebaseUid) // Use Firebase UID, not eToro CID
-                .collection('notifications')
-                .doc(notificationId);
+        for (const targetCid of targetCids) {
+            const notificationId = `test_alert_${Date.now()}_${targetCid}_${piCid}_${Math.random().toString(36).substring(2, 9)}`;
             
             const notificationData = {
                 id: notificationId,
-                type: 'alert',
+                type: 'testAlerts', // Use testAlerts type for test notifications
+                subType: 'alert',
                 title: `[TEST] ${alertType.name}`,
                 message: alertMessage,
                 read: false,
+                timestamp: FieldValue.serverTimestamp(),
                 createdAt: FieldValue.serverTimestamp(),
-                timestamp: FieldValue.serverTimestamp(), // Also include timestamp for ordering
                 metadata: {
                     piCid: Number(piCid),
                     piUsername: piUsername,
@@ -181,64 +148,58 @@ async function sendTestAlert(req, res, dependencies, config) {
                     isTest: true,
                     testSentBy: Number(userCid),
                     testSentAt: new Date().toISOString(),
+                    notificationType: 'testAlerts',
+                    userCid: Number(targetCid),
                     ...metadata
                 }
             };
             
-            batch.set(notificationRef, notificationData);
-            notificationRefs.push(notificationRef);
-            
-            // Track counter updates (using Firebase UID as key)
-            if (!counterUpdates[firebaseUid]) {
-                counterUpdates[firebaseUid] = {
-                    date: today,
-                    unreadCount: 0,
-                    totalCount: 0,
-                    byType: {}
-                };
-            }
-            counterUpdates[firebaseUid].unreadCount += 1;
-            counterUpdates[firebaseUid].totalCount += 1;
-            counterUpdates[firebaseUid].byType[alertType.id] = 
-                (counterUpdates[firebaseUid].byType[alertType.id] || 0) + 1;
-        }
-        
-        // Update notification counters (using Firebase UIDs)
-        for (const [firebaseUid, counter] of Object.entries(counterUpdates)) {
-            const counterRef = db.collection('user_notifications')
-                .doc(firebaseUid) // Use Firebase UID, not eToro CID
-                .collection('counters')
-                .doc(counter.date);
+            // Use writeWithMigration to write to new path (with legacy fallback)
+            // notifications is a subcollection, so we need isCollection: true and documentId
+            const writePromise = writeWithMigration(
+                db,
+                'signedInUsers',
+                'notifications',
+                { cid: String(targetCid) },
+                notificationData,
+                {
+                    isCollection: true,
+                    merge: false,
+                    dataType: 'notifications',
+                    documentId: notificationId,
+                    dualWrite: false, // Disable dual write - we're fully migrated to new path
+                    config,
+                    collectionRegistry
+                }
+            ).catch(err => {
+                logger.log('ERROR', `[sendTestAlert] Failed to write notification for CID ${targetCid}: ${err.message}`, err);
+                throw err; // Re-throw so we know if writes are failing
+            });
             
-            batch.set(counterRef, {
-                date: counter.date,
-                unreadCount: FieldValue.increment(counter.unreadCount),
-                totalCount: FieldValue.increment(counter.totalCount),
-                [`byType.${alertType.id}`]: FieldValue.increment(counter.byType[alertType.id] || 0),
-                lastUpdated: FieldValue.serverTimestamp()
-            }, { merge: true });
+            notificationPromises.push(writePromise);
         }
         
-        // Commit batch
-        await batch.commit();
+        // Wait for all notifications to be written
+        await Promise.all(notificationPromises);
         
-        logger.log('SUCCESS', `[sendTestAlert] Created ${notificationRefs.length} test notifications for alert type ${alertType.id}`);
+        const successCount = notificationPromises.length;
+        logger.log('SUCCESS', `[sendTestAlert] Created ${successCount} test notifications for alert type ${alertType.id}`);
         
         return res.status(200).json({
             success: true,
-            message: `Test alert sent to ${targetFirebaseUids.length} users`,
+            message: `Test alert sent to ${targetCids.length} users`,
             alertType: {
                 id: alertType.id,
                 name: alertType.name,
                 computationName: alertType.computationName
             },
             targetUsers: {
-                count: targetFirebaseUids.length,
-                firebaseUids: targetFirebaseUids
+                count: targetCids.length,
+                cids: targetCids
             },
             piCid: Number(piCid),
             piUsername: piUsername,
-            notificationsCreated: notificationRefs.length
+            notificationsCreated: successCount
         });
         
     } catch (error) {

package/functions/generic-api/user-api/helpers/core/path_resolution_helpers.js

@@ -469,10 +469,21 @@ async function writeWithMigration(db, category, subcategory, params, data, optio
     // Get legacy path if dual write is enabled
     let legacyPath = null;
     if (dualWrite && dataType && userCid) {
-        const { resolvePath: resolve } = getRegistryFunctions(registryOptions);
-        legacyPath = getLegacyPath(dataType, userCid, config, params, null, null, registryOptions);
-        if (legacyPath) {
-            legacyPath = resolve(legacyPath, params);
+        try {
+            const registryFuncs = getRegistryFunctions(registryOptions);
+            const resolve = registryFuncs?.resolvePath;
+            legacyPath = getLegacyPath(dataType, userCid, config, params, null, null, registryOptions);
+            if (legacyPath && resolve && typeof resolve === 'function') {
+                legacyPath = resolve(legacyPath, params);
+            } else if (legacyPath) {
+                // If resolve is not available, manually replace placeholders
+                for (const [key, value] of Object.entries(params)) {
+                    legacyPath = legacyPath.replace(`{${key}}`, String(value));
+                }
+            }
+        } catch (error) {
+            console.warn('[writeWithMigration] Could not resolve legacy path, skipping dual write:', error.message);
+            legacyPath = null; // Skip dual write if we can't resolve legacy path
         }
     }
     

package/functions/generic-api/user-api/helpers/notifications/notification_helpers.js

@@ -127,17 +127,20 @@ async function sendOnDemandNotification(db, logger, userCid, type, title, messag
         };
         
         // Write using collection registry
+        // notifications is a subcollection, so we need isCollection: true and documentId
         if (collectionRegistry) {
             await writeWithMigration(
                 db,
                 'signedInUsers',
                 'notifications',
-                { cid: String(userCid), notificationId },
+                { cid: String(userCid) },
                 notificationData,
                 {
-                    isCollection: false,
+                    isCollection: true,
                     merge: false,
                     dataType: 'notifications',
+                    documentId: notificationId,
+                    dualWrite: false, // Disable dual write - we're fully migrated to new path
                     config,
                     collectionRegistry
                 }
@@ -406,6 +409,7 @@ async function getNotificationHistory(req, res, dependencies, config) {
             notificationsPath = `user_notifications/${userCid}/notifications`;
         }
         
+        // Try to query from new path first
         let query = db.collection(notificationsPath)
             .orderBy('timestamp', 'desc')
             .limit(parseInt(limit));
@@ -418,29 +422,57 @@ async function getNotificationHistory(req, res, dependencies, config) {
             query = query.where('read', '==', read === 'true');
         }
         
-        const snapshot = await query.get();
+        let snapshot;
+        try {
+            snapshot = await query.get();
+        } catch (queryError) {
+            // If query fails (e.g., missing index), try without filters
+            logger.log('WARN', `[getNotificationHistory] Query failed, trying without filters: ${queryError.message}`);
+            query = db.collection(notificationsPath)
+                .orderBy('timestamp', 'desc')
+                .limit(parseInt(limit));
+            snapshot = await query.get();
+        }
+        
         const notifications = [];
         
         snapshot.forEach(doc => {
             const data = doc.data();
-            notifications.push({
-                id: doc.id,
-                type: data.type || 'other',
-                subType: data.subType,
-                title: data.title || '',
-                message: data.message || '',
-                read: data.read || false,
-                timestamp: data.timestamp?.toDate?.()?.toISOString() || data.createdAt?.toDate?.()?.toISOString() || new Date().toISOString(),
-                metadata: data.metadata || {}
-            });
+            
+            // Apply filters in memory if query filters failed
+            let include = true;
+            if (type && data.type !== type) {
+                include = false;
+            }
+            if (read !== undefined && data.read !== (read === 'true')) {
+                include = false;
+            }
+            
+            if (include) {
+                notifications.push({
+                    id: doc.id,
+                    type: data.type || 'other',
+                    subType: data.subType,
+                    title: data.title || '',
+                    message: data.message || '',
+                    read: data.read || false,
+                    timestamp: data.timestamp?.toDate?.()?.toISOString() || data.createdAt?.toDate?.()?.toISOString() || new Date().toISOString(),
+                    metadata: data.metadata || {}
+                });
+            }
         });
         
+        // Apply offset in memory
+        const offsetNum = parseInt(offset);
+        const paginatedNotifications = notifications.slice(offsetNum, offsetNum + parseInt(limit));
+        
         return res.status(200).json({
             success: true,
-            notifications,
-            count: notifications.length,
+            notifications: paginatedNotifications,
+            count: paginatedNotifications.length,
+            total: notifications.length,
             limit: parseInt(limit),
-            offset: parseInt(offset)
+            offset: offsetNum
         });
     } catch (error) {
         logger.log('ERROR', `[getNotificationHistory] Error fetching notifications for ${userCid}`, error);

package/package.json

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