order and api and more

app/services/scheduler/base_scheduler.py

@@ -2,7 +2,7 @@ from typing import Callable, Dict, Any
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from apscheduler.triggers.interval import IntervalTrigger
 import logging
-from app.services.service_registry import ServiceRegistry
+from apscheduler.schedulers.base import SchedulerNotRunningError
 
 logger = logging.getLogger(__name__)
 
@@ -10,7 +10,7 @@ class BaseScheduler:
     def __init__(self):
         self.scheduler = AsyncIOScheduler()
         self.jobs: Dict[str, Any] = {}
-        ServiceRegistry.register(self.__class__.__name__, self)
+        self._is_running = False
 
     async def schedule_task(
         self,
@@ -46,16 +46,20 @@ class BaseScheduler:
 
     def start(self) -> None:
         """Start the scheduler"""
-        self.scheduler.start()
-        logger.info("Scheduler started")
+        if not self._is_running:
+            self.scheduler.start()
+            self._is_running = True
+            logger.info("Scheduler started")
 
     async def shutdown(self) -> None:
         """Shutdown the scheduler"""
-        try:
-            self.scheduler.shutdown()
-            logger.info("Scheduler stopped")
-        except AttributeError as e:
-            if "'NoneType' object has no attribute 'call_soon_threadsafe'" in str(e):
-                logger.warning("Event loop already closed, skipping scheduler shutdown")
-            else:
+        if self._is_running:
+            try:
+                self.scheduler.shutdown()
+                self._is_running = False
+                logger.info("Scheduler stopped")
+            except SchedulerNotRunningError:
+                logger.warning("Scheduler was already stopped")
+            except Exception as e:
+                logger.error(f"Error shutting down scheduler: {str(e)}")
                 raise 

app/services/scheduler/scheduler_service.py

@@ -1,7 +1,4 @@
-from sqlalchemy.orm import Session
-from app.db.database import SessionLocal, transaction
-from app.services.external_api.tcgplayer.tcgplayer_inventory_service import TCGPlayerInventoryService
-from app.services.file_processing_service import FileProcessingService
+from app.db.database import get_db, transaction
 from app.services.scheduler.base_scheduler import BaseScheduler
 import logging
 
@@ -9,9 +6,16 @@ logger = logging.getLogger(__name__)
 
 class SchedulerService:
     def __init__(self):
-        self.tcgplayer_service = TCGPlayerInventoryService()
-        self.file_processor = FileProcessingService()
         self.scheduler = BaseScheduler()
+        # Service manager will be set during initialization
+        self._service_manager = None
+
+    @property
+    def service_manager(self):
+        if self._service_manager is None:
+            from app.services.service_manager import ServiceManager
+            self._service_manager = ServiceManager()
+        return self._service_manager
 
     async def process_tcgplayer_export(self, export_type: str = "live", use_cache: bool = False):
         """
@@ -20,16 +24,20 @@ class SchedulerService:
         Args:
             export_type: Type of export to process (staged, live, or pricing)
         """
-        db = SessionLocal()
+        db = get_db()
         try:
             logger.info(f"Starting scheduled TCGPlayer export processing for {export_type}")
             
+            # Get services
+            tcgplayer_service = self.service_manager.get_service('tcgplayer_inventory')
+            file_processor = self.service_manager.get_service('file_processing')
+            
             # Download the file
-            file_bytes = await self.tcgplayer_service.get_tcgplayer_export(export_type)
+            file_bytes = await tcgplayer_service.get_tcgplayer_export(export_type)
             
             # Process the file and load into database
             with transaction(db):
-                stats = await self.file_processor.process_tcgplayer_export(db, export_type=export_type, file_bytes=file_bytes, use_cache=use_cache)
+                stats = await file_processor.process_tcgplayer_export(db, export_type=export_type, file_bytes=file_bytes, use_cache=use_cache)
             
             logger.info(f"Completed TCGPlayer export processing: {stats}")
             return stats
@@ -37,9 +45,53 @@ class SchedulerService:
         except Exception as e:
             logger.error(f"Error processing TCGPlayer export: {str(e)}")
             raise
-        finally:
-            db.close()
+    
+    async def update_open_orders_hourly(self):
+        """
+        Hourly update of orders from TCGPlayer API to database
+        """
+        db = get_db()
+        try:
+            logger.info("Starting hourly order update")
+            # Get order management service
+            order_management = self.service_manager.get_service('order_management')
+            
+            # get all open orders from last 7 days
+            orders = await order_management.get_order_ids(open_only=True, search_range="LastWeek")
+            for order_id in orders:
+                order = await order_management.get_order(order_id)
+                with transaction(db):
+                    await order_management.save_order_to_db(order, db)
+            
+            logger.info("Completed hourly order update")
+            
+        except Exception as e:
+            logger.error(f"Error updating open orders: {str(e)}")
+            raise
+            
+    async def update_all_orders_daily(self):
+        """
+        Daily update of all orders from TCGPlayer API to database
+        """
+        db = get_db()
+        try:
+            logger.info("Starting daily order update")
+            # Get order management service
+            order_management = self.service_manager.get_service('order_management')
+            
+            # get all order ids from last 3 months
+            orders = await order_management.get_order_ids(open_only=False, search_range="LastThreeMonths")
+            for order_id in orders:
+                order = await order_management.get_order(order_id)
+                with transaction(db):
+                    await order_management.save_order_to_db(order, db)
+            
+            logger.info("Completed daily order update")
 
+        except Exception as e:
+            logger.error(f"Error updating all orders: {str(e)}")
+            raise
+            
     async def start_scheduled_tasks(self):
         """Start all scheduled tasks"""
         # Schedule TCGPlayer export processing to run daily at 2 AM
@@ -49,6 +101,27 @@ class SchedulerService:
             interval_seconds=24 * 60 * 60,  # 24 hours
             export_type="live"
         )
+        # Schedule open orders update to run hourly at 00 minutes
+        await self.scheduler.schedule_task(
+            task_name="update_open_orders_hourly",
+            func=self.update_open_orders_hourly,
+            interval_seconds=60 * 60,  # 1 hour
+        )
+        # Schedule all orders update to run daily at 1 AM
+        await self.scheduler.schedule_task(
+            task_name="update_all_orders_daily",
+            func=self.update_all_orders_daily,
+            interval_seconds=24 * 60 * 60,  # 24 hours
+        )
         
         self.scheduler.start()
-        logger.info("All scheduled tasks started") 
+        logger.info("All scheduled tasks started")
+
+    async def close(self):
+        """Close all services used by the scheduler"""
+        try:
+            await self.scheduler.shutdown()
+            logger.info("Scheduler services closed")
+        except Exception as e:
+            logger.error(f"Error closing scheduler services: {str(e)}")
+            raise