bulltrackers-module 1.0.592 → 1.0.593

package/functions/old-generic-api/user-api/helpers/rootdata/rootdata_aggregation_helpers.js

@@ -0,0 +1,378 @@
+/**
+ * @fileoverview Root Data Aggregation Helpers
+ * Handles writing to global rootdata collections for computation system
+ * These collections aggregate data from user-centric locations into date-based global collections
+ */
+
+const { FieldValue } = require('@google-cloud/firestore');
+
+/**
+ * Update PI Ratings rootdata collection
+ * Aggregates ratings from PopularInvestors/{piCid}/reviews/{reviewId} into PIRatingsData/{date}
+ */
+async function updateRatingsRootData(db, logger, piCid, userCid, rating, date) {
+    try {
+        const ratingsRef = db.collection('PIRatingsData').doc(date);
+        const ratingsDoc = await ratingsRef.get();
+        
+        const existingData = ratingsDoc.exists ? ratingsDoc.data() : {};
+        const piCidStr = String(piCid);
+        const userCidStr = String(userCid);
+        
+        // Get existing ratings for this PI or initialize
+        const piRatings = existingData[piCidStr] || {
+            totalRatings: 0,
+            ratingsByUser: {},
+            lastUpdated: FieldValue.serverTimestamp()
+        };
+        
+        // Update rating for this user
+        const oldRating = piRatings.ratingsByUser[userCidStr];
+        piRatings.ratingsByUser[userCidStr] = rating;
+        
+        // Recalculate average rating
+        const ratings = Object.values(piRatings.ratingsByUser);
+        const totalRatings = ratings.length;
+        const sumRatings = ratings.reduce((sum, r) => sum + r, 0);
+        const averageRating = totalRatings > 0 ? sumRatings / totalRatings : 0;
+        
+        // Update the data
+        const updateData = {
+            [piCidStr]: {
+                averageRating: Number(averageRating.toFixed(2)),
+                totalRatings: totalRatings,
+                ratingsByUser: piRatings.ratingsByUser,
+                lastUpdated: FieldValue.serverTimestamp()
+            },
+            lastUpdated: FieldValue.serverTimestamp()
+        };
+        
+        await ratingsRef.set(updateData, { merge: true });
+        
+        logger.log('INFO', `[updateRatingsRootData] Updated ratings for PI ${piCid} on ${date}`);
+    } catch (error) {
+        logger.log('ERROR', `[updateRatingsRootData] Error updating ratings rootdata for PI ${piCid}:`, error);
+        // Don't throw - this is a non-critical aggregation
+    }
+}
+
+/**
+ * Update PI Page Views rootdata collection
+ * Aggregates page views from PopularInvestors/{piCid}/profileViews/{date} into PIPageViewsData/{date}
+ */
+async function updatePageViewsRootData(db, logger, piCid, userCid, date) {
+    try {
+        const pageViewsRef = db.collection('PIPageViewsData').doc(date);
+        const pageViewsDoc = await pageViewsRef.get();
+        
+        const existingData = pageViewsDoc.exists ? pageViewsDoc.data() : {};
+        const piCidStr = String(piCid);
+        const userCidStr = String(userCid);
+        
+        // Get existing page views for this PI or initialize
+        const piViews = existingData[piCidStr] || {
+            totalViews: 0,
+            uniqueViewers: 0,
+            viewsByUser: {},
+            lastUpdated: FieldValue.serverTimestamp()
+        };
+        
+        // Increment total views
+        piViews.totalViews = (piViews.totalViews || 0) + 1;
+        
+        // Update or add user view
+        if (!piViews.viewsByUser[userCidStr]) {
+            piViews.uniqueViewers = (piViews.uniqueViewers || 0) + 1;
+            piViews.viewsByUser[userCidStr] = {
+                viewCount: 0,
+                lastViewed: FieldValue.serverTimestamp()
+            };
+        }
+        
+        piViews.viewsByUser[userCidStr].viewCount = (piViews.viewsByUser[userCidStr].viewCount || 0) + 1;
+        piViews.viewsByUser[userCidStr].lastViewed = FieldValue.serverTimestamp();
+        
+        // Update the data
+        const updateData = {
+            [piCidStr]: {
+                totalViews: piViews.totalViews,
+                uniqueViewers: piViews.uniqueViewers,
+                viewsByUser: piViews.viewsByUser,
+                lastUpdated: FieldValue.serverTimestamp()
+            },
+            lastUpdated: FieldValue.serverTimestamp()
+        };
+        
+        await pageViewsRef.set(updateData, { merge: true });
+        
+        logger.log('INFO', `[updatePageViewsRootData] Updated page views for PI ${piCid} on ${date}`);
+    } catch (error) {
+        logger.log('ERROR', `[updatePageViewsRootData] Error updating page views rootdata for PI ${piCid}:`, error);
+        // Don't throw - this is a non-critical aggregation
+    }
+}
+
+/**
+ * Update Watchlist Membership rootdata collection
+ * Aggregates watchlist membership from SignedInUsers/{cid}/watchlists into WatchlistMembershipData/{date}
+ * This should be called when a PI is added/removed from a watchlist
+ * This provides a single point of reference for all watchlists made in that day
+ */
+async function updateWatchlistMembershipRootData(db, logger, piCid, userCid, isPublic, date, action = 'add') {
+    try {
+        const membershipRef = db.collection('WatchlistMembershipData').doc(date);
+        const membershipDoc = await membershipRef.get();
+        
+        const existingData = membershipDoc.exists ? membershipDoc.data() : {};
+        const piCidStr = String(piCid);
+        const userCidStr = String(userCid);
+        
+        // Get existing membership for this PI or initialize
+        const piMembership = existingData[piCidStr] || {
+            totalUsers: 0,
+            users: [],
+            publicWatchlistCount: 0,
+            privateWatchlistCount: 0,
+            lastUpdated: FieldValue.serverTimestamp()
+        };
+        
+        if (action === 'add') {
+            // Add user if not already in list
+            if (!piMembership.users.includes(userCidStr)) {
+                piMembership.users.push(userCidStr);
+                piMembership.totalUsers = piMembership.users.length;
+            }
+            
+            // Update counts
+            if (isPublic) {
+                piMembership.publicWatchlistCount = (piMembership.publicWatchlistCount || 0) + 1;
+            } else {
+                piMembership.privateWatchlistCount = (piMembership.privateWatchlistCount || 0) + 1;
+            }
+        } else if (action === 'remove') {
+            // Remove user from list
+            piMembership.users = piMembership.users.filter(u => u !== userCidStr);
+            piMembership.totalUsers = piMembership.users.length;
+            
+            // Update counts (decrement if > 0)
+            if (isPublic && piMembership.publicWatchlistCount > 0) {
+                piMembership.publicWatchlistCount = piMembership.publicWatchlistCount - 1;
+            } else if (!isPublic && piMembership.privateWatchlistCount > 0) {
+                piMembership.privateWatchlistCount = piMembership.privateWatchlistCount - 1;
+            }
+        }
+        
+        // Update the data - ensure date field is set for rootdata indexer
+        const updateData = {
+            date: date, // Ensure date field exists for rootdata indexer
+            [piCidStr]: {
+                totalUsers: piMembership.totalUsers,
+                users: piMembership.users,
+                publicWatchlistCount: piMembership.publicWatchlistCount,
+                privateWatchlistCount: piMembership.privateWatchlistCount,
+                lastUpdated: FieldValue.serverTimestamp()
+            },
+            lastUpdated: FieldValue.serverTimestamp()
+        };
+        
+        await membershipRef.set(updateData, { merge: true });
+        
+        logger.log('INFO', `[updateWatchlistMembershipRootData] Updated watchlist membership for PI ${piCid} on ${date} (action: ${action})`);
+    } catch (error) {
+        logger.log('ERROR', `[updateWatchlistMembershipRootData] Error updating watchlist membership rootdata for PI ${piCid}:`, error);
+        // Don't throw - this is a non-critical aggregation
+    }
+}
+
+/**
+ * Update Popular Investor watchlist data
+ * Tracks watchlist additions per PI in PopularInvestors/{piCid}/watchlistData
+ * This provides a time series of watchlist additions over time per popular investor
+ */
+async function updatePIWatchlistData(db, logger, piCid, userCid, date, action = 'add') {
+    try {
+        const piCidStr = String(piCid);
+        const userCidStr = String(userCid);
+        const piWatchlistRef = db.collection('PopularInvestors').doc(piCidStr).collection('watchlistData').doc('current');
+        
+        const piWatchlistDoc = await piWatchlistRef.get();
+        const existingData = piWatchlistDoc.exists ? piWatchlistDoc.data() : {};
+        
+        // Initialize structure if needed
+        const watchlistData = existingData || {
+            totalUsers: 0,
+            userCids: [],
+            dailyAdditions: {},
+            lastUpdated: FieldValue.serverTimestamp()
+        };
+        
+        if (action === 'add') {
+            // Add user CID if not already present
+            if (!watchlistData.userCids || !Array.isArray(watchlistData.userCids)) {
+                watchlistData.userCids = [];
+            }
+            if (!watchlistData.userCids.includes(userCidStr)) {
+                watchlistData.userCids.push(userCidStr);
+                watchlistData.totalUsers = watchlistData.userCids.length;
+            }
+            
+            // Track daily additions with timestamp
+            if (!watchlistData.dailyAdditions || typeof watchlistData.dailyAdditions !== 'object') {
+                watchlistData.dailyAdditions = {};
+            }
+            
+            // Initialize date entry if needed
+            if (!watchlistData.dailyAdditions[date]) {
+                watchlistData.dailyAdditions[date] = {
+                    count: 0,
+                    userCids: [],
+                    timestamp: FieldValue.serverTimestamp()
+                };
+            }
+            
+            // Add user to this date's additions if not already present
+            const dateEntry = watchlistData.dailyAdditions[date];
+            if (!dateEntry.userCids.includes(userCidStr)) {
+                dateEntry.userCids.push(userCidStr);
+                dateEntry.count = dateEntry.userCids.length;
+                dateEntry.timestamp = FieldValue.serverTimestamp();
+            }
+            
+        } else if (action === 'remove') {
+            // Remove user CID
+            if (watchlistData.userCids && Array.isArray(watchlistData.userCids)) {
+                watchlistData.userCids = watchlistData.userCids.filter(cid => cid !== userCidStr);
+                watchlistData.totalUsers = watchlistData.userCids.length;
+            }
+            
+            // Update daily additions for this date
+            if (watchlistData.dailyAdditions && watchlistData.dailyAdditions[date]) {
+                const dateEntry = watchlistData.dailyAdditions[date];
+                if (dateEntry.userCids && Array.isArray(dateEntry.userCids)) {
+                    dateEntry.userCids = dateEntry.userCids.filter(cid => cid !== userCidStr);
+                    dateEntry.count = dateEntry.userCids.length;
+                    dateEntry.timestamp = FieldValue.serverTimestamp();
+                }
+            }
+        }
+        
+        // Update the document
+        watchlistData.lastUpdated = FieldValue.serverTimestamp();
+        await piWatchlistRef.set(watchlistData, { merge: true });
+        
+        logger.log('INFO', `[updatePIWatchlistData] Updated watchlist data for PI ${piCid} (action: ${action}, user: ${userCid})`);
+    } catch (error) {
+        logger.log('ERROR', `[updatePIWatchlistData] Error updating PI watchlist data for PI ${piCid}:`, error);
+        // Don't throw - this is a non-critical aggregation
+    }
+}
+
+/**
+ * Update PI Alert History rootdata collection
+ * Records alert triggers in PIAlertHistoryData/{date}
+ */
+async function updateAlertHistoryRootData(db, logger, piCid, alertType, computationMetadata, computationDate, triggeredUserCids = []) {
+    try {
+        const alertHistoryRef = db.collection('PIAlertHistoryData').doc(computationDate);
+        const alertHistoryDoc = await alertHistoryRef.get();
+        
+        const existingData = alertHistoryDoc.exists ? alertHistoryDoc.data() : {};
+        const piCidStr = String(piCid);
+        const alertTypeStr = String(alertType.computationName || alertType.id || alertType);
+        
+        // Get existing alert history for this PI or initialize
+        const piAlerts = existingData[piCidStr] || {};
+        
+        // Update or initialize alert type data
+        const alertTypeData = piAlerts[alertTypeStr] || {
+            triggered: false,
+            count: 0,
+            triggeredFor: [],
+            metadata: {},
+            lastTriggered: null
+        };
+        
+        // Update alert data
+        alertTypeData.triggered = true;
+        alertTypeData.count = (alertTypeData.count || 0) + 1;
+        alertTypeData.triggeredFor = [...new Set([...alertTypeData.triggeredFor, ...triggeredUserCids.map(c => String(c))])];
+        alertTypeData.metadata = computationMetadata || {};
+        alertTypeData.lastTriggered = FieldValue.serverTimestamp();
+        
+        // Update the data
+        const updateData = {
+            [piCidStr]: {
+                [alertTypeStr]: alertTypeData,
+                lastUpdated: FieldValue.serverTimestamp()
+            },
+            lastUpdated: FieldValue.serverTimestamp()
+        };
+        
+        await alertHistoryRef.set(updateData, { merge: true });
+        
+        logger.log('INFO', `[updateAlertHistoryRootData] Updated alert history for PI ${piCid}, alert type ${alertTypeStr} on ${computationDate}`);
+    } catch (error) {
+        logger.log('ERROR', `[updateAlertHistoryRootData] Error updating alert history rootdata for PI ${piCid}:`, error);
+        // Don't throw - this is a non-critical aggregation
+    }
+}
+
+/**
+ * Record "all clear" in alert history (when alert computation runs but doesn't trigger)
+ */
+async function updateAllClearAlertHistory(db, logger, piCid, alertType, computationDate) {
+    try {
+        const alertHistoryRef = db.collection('PIAlertHistoryData').doc(computationDate);
+        const alertHistoryDoc = await alertHistoryRef.get();
+        
+        const existingData = alertHistoryDoc.exists ? alertHistoryDoc.data() : {};
+        const piCidStr = String(piCid);
+        const alertTypeStr = String(alertType.computationName || alertType.id || alertType);
+        
+        // Get existing alert history for this PI or initialize
+        const piAlerts = existingData[piCidStr] || {};
+        
+        // Initialize alert type data if it doesn't exist
+        if (!piAlerts[alertTypeStr]) {
+            piAlerts[alertTypeStr] = {
+                triggered: false,
+                count: 0,
+                triggeredFor: [],
+                metadata: {},
+                lastTriggered: null
+            };
+        }
+        
+        // Mark as not triggered (all clear)
+        const alertTypeData = piAlerts[alertTypeStr];
+        alertTypeData.triggered = false;
+        alertTypeData.metadata = { allClear: true };
+        alertTypeData.lastChecked = FieldValue.serverTimestamp();
+        
+        // Update the data
+        const updateData = {
+            [piCidStr]: {
+                [alertTypeStr]: alertTypeData,
+                lastUpdated: FieldValue.serverTimestamp()
+            },
+            lastUpdated: FieldValue.serverTimestamp()
+        };
+        
+        await alertHistoryRef.set(updateData, { merge: true });
+        
+        logger.log('INFO', `[updateAllClearAlertHistory] Recorded all clear for PI ${piCid}, alert type ${alertTypeStr} on ${computationDate}`);
+    } catch (error) {
+        logger.log('ERROR', `[updateAllClearAlertHistory] Error updating all clear alert history for PI ${piCid}:`, error);
+        // Don't throw - this is a non-critical aggregation
+    }
+}
+
+module.exports = {
+    updateRatingsRootData,
+    updatePageViewsRootData,
+    updateWatchlistMembershipRootData,
+    updatePIWatchlistData,
+    updateAlertHistoryRootData,
+    updateAllClearAlertHistory
+};
+

package/functions/old-generic-api/user-api/helpers/search/pi_request_helpers.js

@@ -0,0 +1,295 @@
+/**
+ * @fileoverview Popular Investor Request Helpers
+ * Handles PI addition requests and rankings checks
+ */
+
+const { FieldValue } = require('@google-cloud/firestore');
+const { findLatestRankingsDate } = require('../core/data_lookup_helpers');
+
+/**
+ * POST /user/requests/pi-addition
+ * Request to add a Popular Investor to the database
+ */
+async function requestPiAddition(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid, username, piUsername, piCid } = req.body;
+    
+    if (!userCid || !username || !piUsername) {
+        return res.status(400).json({ error: "Missing required fields: userCid, username, piUsername" });
+    }
+    
+    try {
+        const requestsCollection = config.requestsCollection || 'requests';
+        const requestId = `pi_add_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        
+        const requestData = {
+            id: requestId,
+            type: 'popular_investor_addition',
+            requestedBy: {
+                userCid: Number(userCid),
+                username: username
+            },
+            popularInvestor: {
+                username: piUsername,
+                cid: piCid || null
+            },
+            status: 'pending',
+            requestedAt: FieldValue.serverTimestamp(),
+            processedAt: null,
+            notes: null
+        };
+        
+        const requestRef = db.collection(requestsCollection)
+            .doc('popular_investor_copy_additions')
+            .collection('requests')
+            .doc(requestId);
+        
+        // Write to global collection
+        await requestRef.set(requestData);
+        
+        // Also write to user-centric collection (dual-write)
+        const { writeWithMigration } = require('../core/path_resolution_helpers');
+        try {
+            await writeWithMigration(
+                db,
+                'signedInUsers',
+                'piAdditionRequests',
+                { cid: userCid },
+                requestData,
+                {
+                    isCollection: true,
+                    merge: false,
+                    dataType: 'piAdditionRequests',
+                    config,
+                    documentId: requestId,
+                    dualWrite: false, // Don't dual-write to legacy (new feature)
+                    collectionRegistry: dependencies.collectionRegistry
+                }
+            );
+        } catch (userWriteErr) {
+            // Log but don't fail - global write succeeded
+            logger.log('WARN', `[requestPiAddition] Failed to write to user-centric collection: ${userWriteErr.message}`);
+        }
+        
+        logger.log('SUCCESS', `[requestPiAddition] User ${userCid} requested addition of PI ${piUsername} (CID: ${piCid || 'unknown'})`);
+        
+        return res.status(201).json({
+            success: true,
+            requestId: requestId,
+            message: "Request submitted successfully"
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[requestPiAddition] Error submitting request`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * GET /user/me/watchlists/:id/rankings-check
+ * Check which PIs in a watchlist are in the master list (single source of truth)
+ * UPDATED: Now checks against the master list instead of latest rankings date
+ */
+async function checkPisInRankings(req, res, dependencies, config) {
+    const { db, logger, collectionRegistry } = dependencies;
+    const { userCid } = req.query;
+    const { id } = req.params;
+    
+    if (!userCid || !id) {
+        return res.status(400).json({ error: "Missing userCid or watchlist id" });
+    }
+    
+    try {
+        // Read watchlist from new path with migration
+        const { readWithMigration } = require('../core/path_resolution_helpers');
+        const watchlistResult = await readWithMigration(
+            db,
+            'signedInUsers',
+            'watchlists',
+            { cid: userCid },
+            {
+                isCollection: false,
+                dataType: 'watchlists',
+                config,
+                logger,
+                documentId: id,
+                collectionRegistry: dependencies.collectionRegistry
+            }
+        );
+        
+        let items = [];
+        if (watchlistResult && watchlistResult.data) {
+            items = watchlistResult.data.items || [];
+        } else {
+            // Fallback to legacy path
+            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();
+            items = watchlistData.items || [];
+        }
+        
+        // Get the master list path from collection registry
+        let masterListPath = 'system_state/popular_investor_master_list';
+        
+        if (collectionRegistry && collectionRegistry.getCollectionPath) {
+            try {
+                masterListPath = collectionRegistry.getCollectionPath('system', 'popularInvestorMasterList', {});
+            } catch (err) {
+                logger.log('WARN', `[checkPisInRankings] Failed to get master list path from registry, using default: ${err.message}`);
+            }
+        }
+        
+        // Fetch master list document
+        const masterListRef = db.doc(masterListPath);
+        const masterListDoc = await masterListRef.get();
+        
+        if (!masterListDoc.exists) {
+            // Master list doesn't exist yet - fallback to legacy rankings check
+            logger.log('WARN', `[checkPisInRankings] Master list not found, falling back to legacy rankings check`);
+            const legacyResult = await checkPisInRankingsLegacy(db, items, config, logger);
+            return res.status(200).json(legacyResult);
+        }
+        
+        const masterListData = masterListDoc.data();
+        const investors = masterListData.investors || {};
+        
+        // Create sets for quick lookup: by CID and by username (case-insensitive)
+        const investorsByCid = new Set();
+        const investorsByUsername = new Set();
+        
+        for (const [cid, piData] of Object.entries(investors)) {
+            if (cid) {
+                investorsByCid.add(String(cid));
+            }
+            if (piData.username) {
+                investorsByUsername.add(piData.username.toLowerCase().trim());
+            }
+        }
+        
+        // Check which watchlist PIs are NOT in the master list
+        // Check by both CID and username to be thorough
+        const notInRankings = [];
+        for (const item of items) {
+            const cidStr = String(item.cid);
+            const username = item.username ? item.username.toLowerCase().trim() : null;
+            
+            // Check if PI exists in master list by CID or username
+            const existsByCid = investorsByCid.has(cidStr);
+            const existsByUsername = username && investorsByUsername.has(username);
+            
+            if (!existsByCid && !existsByUsername) {
+                notInRankings.push(item.cid);
+            }
+        }
+        
+        return res.status(200).json({
+            notInRankings,
+            rankingsDate: null, // No longer using rankings date
+            totalChecked: items.length,
+            inRankings: items.length - notInRankings.length,
+            usingMasterList: true
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[checkPisInRankings] Error checking PIs in master list`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * Legacy method: Check against latest rankings date
+ * Used as fallback when master list is not available
+ */
+async function checkPisInRankingsLegacy(db, items, config, logger) {
+    try {
+        // Find latest available rankings date
+        const rankingsCollection = config.popularInvestorRankingsCollection || process.env.FIRESTORE_COLLECTION_PI_RANKINGS || 'popular_investor_rankings';
+        const rankingsDate = await findLatestRankingsDate(db, rankingsCollection, 30);
+        
+        if (!rankingsDate) {
+            const notInRankings = items.map(item => item.cid);
+            return {
+                notInRankings,
+                rankingsDate: null,
+                totalChecked: items.length,
+                inRankings: 0,
+                usingMasterList: false,
+                message: "No rankings data available"
+            };
+        }
+        
+        // Fetch rankings data
+        const rankingsRef = db.collection(rankingsCollection).doc(rankingsDate);
+        const rankingsDoc = await rankingsRef.get();
+        
+        if (!rankingsDoc.exists) {
+            const notInRankings = items.map(item => item.cid);
+            return {
+                notInRankings,
+                rankingsDate: null,
+                totalChecked: items.length,
+                inRankings: 0,
+                usingMasterList: false,
+                message: "Rankings document not found"
+            };
+        }
+        
+        const rawRankingsData = rankingsDoc.data();
+        // Decompress if needed
+        const { tryDecompress } = require('../core/compression_helpers');
+        const rankingsData = tryDecompress(rawRankingsData);
+        const rankingsItems = rankingsData.Items || [];
+        
+        // Create a set of CIDs that exist in rankings
+        const rankingsCIDs = new Set();
+        for (const item of rankingsItems) {
+            if (item.CustomerId) {
+                rankingsCIDs.add(String(item.CustomerId));
+            }
+        }
+        
+        // Check which watchlist PIs are NOT in rankings
+        const notInRankings = [];
+        for (const item of items) {
+            const cidStr = String(item.cid);
+            if (!rankingsCIDs.has(cidStr)) {
+                notInRankings.push(item.cid);
+            }
+        }
+        
+        return {
+            notInRankings,
+            rankingsDate: rankingsDate,
+            totalChecked: items.length,
+            inRankings: items.length - notInRankings.length,
+            usingMasterList: false
+        };
+    } catch (error) {
+        logger.log('ERROR', `[checkPisInRankingsLegacy] Error in legacy rankings check`, error);
+        // Return all as not in rankings on error
+        return {
+            notInRankings: items.map(item => item.cid),
+            rankingsDate: null,
+            totalChecked: items.length,
+            inRankings: 0,
+            usingMasterList: false,
+            message: error.message
+        };
+    }
+}
+
+module.exports = {
+    requestPiAddition,
+    checkPisInRankings
+};
+