removed old working on ceo handler

apps/data-ingestion/src/handlers/ceo/ceo.handler.ts

@@ -1,6 +1,7 @@
 import {
   BaseHandler,
   Handler,
+  Operation,
   ScheduledOperation,
   type IServiceContainer
 } from '@stock-bot/handlers';
@@ -81,4 +82,135 @@ export class CeoHandler extends BaseHandler {
     this.logger.info(`Fetched CEO channels for page ${page}/${totalPages}`);
     return { page, totalPages };
   }
+
+  @Operation('process-unique-symbols')
+  @ScheduledOperation('process-unique-symbols', '0 */30 * * *', { 
+    priority: 5, 
+    immediately: false, 
+    description: 'Process unique CEO symbols and schedule individual jobs' 
+  })
+  async processUniqueSymbols(_payload: unknown, _context: any): Promise<unknown> {
+    this.logger.info('Starting process to get unique CEO symbols by ceoId');
+    
+    try {
+      // Get unique ceoId values from the ceoSymbols collection
+      const uniqueCeoIds = await this.mongodb.collection('ceoSymbols').distinct('ceoId');
+      
+      this.logger.info(`Found ${uniqueCeoIds.length} unique CEO IDs`);
+      
+      // Get detailed records for each unique ceoId (latest/first record)
+      const uniqueSymbols = [];
+      for (const ceoId of uniqueCeoIds) {
+        const symbol = await this.mongodb.collection('ceoSymbols')
+          .findOne({ ceoId }, { sort: { _id: -1 } }); // Get latest record
+        
+        if (symbol) {
+          uniqueSymbols.push(symbol);
+        }
+      }
+      
+      this.logger.info(`Retrieved ${uniqueSymbols.length} unique symbol records`);
+      
+      // Schedule individual jobs for each unique symbol
+      let scheduledJobs = 0;
+      for (const symbol of uniqueSymbols) {
+        // Schedule a job to process this individual symbol
+        await this.scheduleOperation('process-individual-symbol', {
+          ceoId: symbol.ceoId,
+          symbol: symbol.symbol,
+          exchange: symbol.exchange,
+          name: symbol.name
+        });
+        scheduledJobs++;
+        
+        // Add small delay to avoid overwhelming the queue
+        if (scheduledJobs % 10 === 0) {
+          this.logger.debug(`Scheduled ${scheduledJobs} jobs so far`);
+        }
+      }
+      
+      this.logger.info(`Successfully scheduled ${scheduledJobs} individual symbol processing jobs`);
+      
+      // Cache the results for monitoring
+      await this.cacheSet('unique-symbols-last-run', {
+        timestamp: new Date().toISOString(),
+        totalUniqueIds: uniqueCeoIds.length,
+        totalRecords: uniqueSymbols.length,
+        scheduledJobs
+      }, 1800); // Cache for 30 minutes
+      
+      return {
+        success: true,
+        uniqueCeoIds: uniqueCeoIds.length,
+        uniqueRecords: uniqueSymbols.length,
+        scheduledJobs,
+        timestamp: new Date().toISOString()
+      };
+      
+    } catch (error) {
+      this.logger.error('Failed to process unique CEO symbols', { error });
+      throw error;
+    }
+  }
+
+  @Operation('process-individual-symbol')
+  async processIndividualSymbol(payload: any, _context: any): Promise<unknown> {
+    const { ceoId, symbol, exchange, name } = payload;
+    
+    this.logger.debug('Processing individual CEO symbol', { 
+      ceoId, 
+      symbol, 
+      exchange, 
+      name 
+    });
+    
+    try {
+      // Here you can add specific processing logic for each symbol
+      // For now, just log and potentially fetch additional data
+      
+      // Example: Get all historical records for this ceoId
+      const allRecords = await this.mongodb.collection('ceoSymbols')
+        .find({ ceoId })
+        .sort({ _id: -1 })
+        .toArray();
+      
+      this.logger.debug(`Found ${allRecords.length} records for CEO ID ${ceoId}`);
+      
+      // Example: Update processing status
+      await this.mongodb.collection('ceoSymbols').updateMany(
+        { ceoId },
+        { 
+          $set: { 
+            lastProcessed: new Date(),
+            processedBy: 'individual-symbol-processor'
+          }
+        }
+      );
+      
+      // Cache individual symbol data
+      await this.cacheSet(`symbol-${ceoId}`, {
+        symbol,
+        exchange,
+        name,
+        recordCount: allRecords.length,
+        lastProcessed: new Date().toISOString()
+      }, 3600); // Cache for 1 hour
+      
+      return {
+        success: true,
+        ceoId,
+        symbol,
+        recordsProcessed: allRecords.length,
+        timestamp: new Date().toISOString()
+      };
+      
+    } catch (error) {
+      this.logger.error('Failed to process individual symbol', { 
+        error, 
+        ceoId, 
+        symbol 
+      });
+      throw error;
+    }
+  }
 }

apps/data-ingestion/src/handlers/index.ts

@@ -10,6 +10,7 @@ import { getLogger } from '@stock-bot/logger';
 // Import handlers for bundling (ensures they're included in the build)
 import './qm/qm.handler';
 import './webshare/webshare.handler';
+import './ceo/ceo.handler';
 // Add more handler imports as needed
 
 const logger = getLogger('handler-init');

apps/data-ingestion/test-ceo-operations.ts

@@ -0,0 +1,101 @@
+#!/usr/bin/env bun
+
+/**
+ * Test script for CEO handler operations
+ */
+
+import { initializeServiceConfig } from '@stock-bot/config';
+import { createServiceContainer, initializeServices } from '@stock-bot/di';
+import { getLogger } from '@stock-bot/logger';
+
+const logger = getLogger('test-ceo-operations');
+
+async function testCeoOperations() {
+  logger.info('Testing CEO handler operations...');
+  
+  try {
+    // Initialize config
+    const config = initializeServiceConfig();
+    
+    // Create Awilix container
+    const awilixConfig = {
+      redis: {
+        host: config.database.dragonfly.host,
+        port: config.database.dragonfly.port,
+        db: config.database.dragonfly.db,
+      },
+      mongodb: {
+        uri: config.database.mongodb.uri,
+        database: config.database.mongodb.database,
+      },
+      postgres: {
+        host: config.database.postgres.host,
+        port: config.database.postgres.port,
+        database: config.database.postgres.database,
+        user: config.database.postgres.user,
+        password: config.database.postgres.password,
+      },
+      questdb: {
+        enabled: false,
+        host: config.database.questdb.host,
+        httpPort: config.database.questdb.httpPort,
+        pgPort: config.database.questdb.pgPort,
+        influxPort: config.database.questdb.ilpPort,
+        database: config.database.questdb.database,
+      },
+    };
+    
+    const container = createServiceContainer(awilixConfig);
+    await initializeServices(container);
+    
+    const serviceContainer = container.resolve('serviceContainer');
+    
+    // Import and create CEO handler
+    const { CeoHandler } = await import('./src/handlers/ceo/ceo.handler');
+    const ceoHandler = new CeoHandler(serviceContainer);
+    
+    // Test 1: Check if there are any CEO symbols in the database
+    logger.info('Checking for existing CEO symbols...');
+    const collection = serviceContainer.mongodb.collection('ceoSymbols');
+    const count = await collection.countDocuments();
+    logger.info(`Found ${count} CEO symbols in database`);
+    
+    if (count > 0) {
+      // Test 2: Run process-unique-symbols operation
+      logger.info('Testing process-unique-symbols operation...');
+      const result = await ceoHandler.processUniqueSymbols(undefined, {});
+      logger.info('Process unique symbols result:', result);
+      
+      // Test 3: Test individual symbol processing
+      logger.info('Testing process-individual-symbol operation...');
+      const sampleSymbol = await collection.findOne({});
+      if (sampleSymbol) {
+        const individualResult = await ceoHandler.processIndividualSymbol({
+          ceoId: sampleSymbol.ceoId,
+          symbol: sampleSymbol.symbol,
+          exchange: sampleSymbol.exchange,
+          name: sampleSymbol.name,
+        }, {});
+        logger.info('Process individual symbol result:', individualResult);
+      }
+    } else {
+      logger.warn('No CEO symbols found. Run the service to populate data first.');
+    }
+    
+    // Clean up
+    await serviceContainer.mongodb.disconnect();
+    await serviceContainer.postgres.disconnect();
+    if (serviceContainer.cache) {
+      await serviceContainer.cache.disconnect();
+    }
+    
+    logger.info('Test completed successfully!');
+    process.exit(0);
+  } catch (error) {
+    logger.error('Test failed:', error);
+    process.exit(1);
+  }
+}
+
+// Run the test
+testCeoOperations();