Recovered state: integrated TrendSurferAgent, restored frontend/backend files, and cleaned up recovery scripts

backend/services/scheduler/utils/advertools_task_loader.py

@@ -0,0 +1,32 @@
+"""
+Advertools Task Loader Utility
+Utility functions for loading due Advertools tasks from the database.
+"""
+
+from typing import List, Optional
+from datetime import datetime
+from sqlalchemy.orm import Session
+from models.advertools_monitoring_models import AdvertoolsTask
+
+def load_due_advertools_tasks(db: Session, user_id: Optional[str] = None) -> List[AdvertoolsTask]:
+    """
+    Load Advertools tasks that are due for execution.
+    
+    Args:
+        db: Database session
+        user_id: Optional user ID to filter tasks (for multi-tenant support)
+        
+    Returns:
+        List of due AdvertoolsTask objects
+    """
+    now = datetime.utcnow()
+    
+    query = db.query(AdvertoolsTask).filter(
+        AdvertoolsTask.status == 'active',
+        AdvertoolsTask.next_execution <= now
+    )
+    
+    if user_id:
+        query = query.filter(AdvertoolsTask.user_id == user_id)
+        
+    return query.all()

backend/services/scheduler/utils/deep_competitor_analysis_task_loader.py

@@ -0,0 +1,30 @@
+from datetime import datetime
+from typing import List, Optional, Union
+
+from sqlalchemy import and_, or_
+from sqlalchemy.orm import Session
+
+from models.website_analysis_monitoring_models import DeepCompetitorAnalysisTask
+
+
+def load_due_deep_competitor_analysis_tasks(
+    db: Session,
+    user_id: Optional[Union[str, int]] = None
+) -> List[DeepCompetitorAnalysisTask]:
+    now = datetime.utcnow()
+
+    query = db.query(DeepCompetitorAnalysisTask).filter(
+        and_(
+            DeepCompetitorAnalysisTask.status == 'active',
+            or_(
+                DeepCompetitorAnalysisTask.next_execution <= now,
+                DeepCompetitorAnalysisTask.next_execution.is_(None)
+            )
+        )
+    )
+
+    if user_id is not None:
+        query = query.filter(DeepCompetitorAnalysisTask.user_id == str(user_id))
+
+    return query.all()
+

backend/services/scheduler/utils/deep_website_crawl_task_loader.py

@@ -0,0 +1,33 @@
+from typing import List
+from datetime import datetime
+from sqlalchemy.orm import Session
+from sqlalchemy import or_
+
+from models.website_analysis_monitoring_models import DeepWebsiteCrawlTask
+
+def load_due_deep_website_crawl_tasks(db: Session, user_id: str = None) -> List[DeepWebsiteCrawlTask]:
+    """
+    Load due deep website crawl tasks.
+    
+    Args:
+        db: Database session
+        user_id: Optional user_id to filter tasks
+        
+    Returns:
+        List of due tasks
+    """
+    query = db.query(DeepWebsiteCrawlTask).filter(
+        or_(
+            DeepWebsiteCrawlTask.status == 'active',
+            DeepWebsiteCrawlTask.status == 'retry'
+        ),
+        or_(
+            DeepWebsiteCrawlTask.next_execution <= datetime.utcnow(),
+            DeepWebsiteCrawlTask.next_execution == None
+        )
+    )
+    
+    if user_id:
+        query = query.filter(DeepWebsiteCrawlTask.user_id == user_id)
+        
+    return query.all()

backend/services/scheduler/utils/market_trends_task_loader.py

@@ -0,0 +1,37 @@
+"""
+Market Trends Task Loader
+Loads due market trends tasks from the database.
+"""
+
+from datetime import datetime
+from typing import List, Optional
+
+from sqlalchemy import or_
+from sqlalchemy.orm import Session
+
+from models.website_analysis_monitoring_models import MarketTrendsTask
+from utils.logger_utils import get_service_logger
+
+logger = get_service_logger("market_trends_task_loader")
+
+
+def load_due_market_trends_tasks(db: Session, user_id: Optional[str] = None) -> List[MarketTrendsTask]:
+    try:
+        now = datetime.utcnow()
+
+        query = db.query(MarketTrendsTask).filter(
+            MarketTrendsTask.status == "active",
+            or_(MarketTrendsTask.next_execution <= now, MarketTrendsTask.next_execution == None),
+        )
+
+        if user_id:
+            query = query.filter(MarketTrendsTask.user_id == user_id)
+
+        tasks = query.all()
+        if tasks:
+            logger.info(f"Loaded {len(tasks)} due market trends tasks")
+        return tasks
+    except Exception as e:
+        logger.error(f"Error loading market trends tasks: {e}")
+        return []
+

backend/services/scheduler/utils/onboarding_full_website_analysis_task_loader.py

@@ -0,0 +1,35 @@
+"""
+Onboarding Full Website Analysis Task Loader
+Functions to load due onboarding full-site SEO audit tasks from database.
+"""
+
+from datetime import datetime
+from typing import List, Optional, Union
+
+from sqlalchemy import and_, or_
+from sqlalchemy.orm import Session
+
+from models.website_analysis_monitoring_models import OnboardingFullWebsiteAnalysisTask
+
+
+def load_due_onboarding_full_website_analysis_tasks(
+    db: Session,
+    user_id: Optional[Union[str, int]] = None
+) -> List[OnboardingFullWebsiteAnalysisTask]:
+    now = datetime.utcnow()
+
+    query = db.query(OnboardingFullWebsiteAnalysisTask).filter(
+        and_(
+            OnboardingFullWebsiteAnalysisTask.status == 'active',
+            or_(
+                OnboardingFullWebsiteAnalysisTask.next_execution <= now,
+                OnboardingFullWebsiteAnalysisTask.next_execution.is_(None)
+            )
+        )
+    )
+
+    if user_id is not None:
+        query = query.filter(OnboardingFullWebsiteAnalysisTask.user_id == str(user_id))
+
+    return query.all()
+

backend/services/scheduler/utils/sif_indexing_task_loader.py

@@ -0,0 +1,45 @@
+"""
+SIF Indexing Task Loader
+Loads due SIF indexing tasks from the database.
+"""
+
+from datetime import datetime
+from typing import List
+from sqlalchemy.orm import Session
+from sqlalchemy import or_
+
+from models.website_analysis_monitoring_models import SIFIndexingTask
+from utils.logger_utils import get_service_logger
+
+logger = get_service_logger("sif_indexing_task_loader")
+
+
+def load_due_sif_indexing_tasks(db: Session, user_id: str = None) -> List[SIFIndexingTask]:
+    """
+    Load SIF indexing tasks that are due for execution.
+    
+    Args:
+        db: Database session
+        user_id: Optional user_id to filter by
+        
+    Returns:
+        List of SIFIndexingTask objects
+    """
+    try:
+        query = db.query(SIFIndexingTask).filter(
+            or_(
+                SIFIndexingTask.status == "pending",
+                SIFIndexingTask.status == "failed"  # Retry failed tasks
+            ),
+            SIFIndexingTask.next_run_at <= datetime.utcnow()
+        )
+        
+        if user_id:
+            query = query.filter(SIFIndexingTask.user_id == user_id)
+            
+        tasks = query.all()
+        return tasks
+        
+    except Exception as e:
+        logger.error(f"Error loading SIF indexing tasks: {str(e)}")
+        return []

backend/services/scheduler/utils/user_job_store.py

@@ -8,7 +8,7 @@ from urllib.parse import urlparse
 from loguru import logger
 from sqlalchemy.orm import Session as SQLSession
 
-from services.database import get_db_session
+from services.database import get_session_for_user
 from models.onboarding import OnboardingSession, WebsiteAnalysis
 
 
@@ -79,7 +79,7 @@ def get_user_job_store_name(user_id: str, db: SQLSession = None) -> str:
     
     try:
         if not db_session:
-            db_session = get_db_session()
+            db_session = get_session_for_user(user_id)
             close_db = True
         
         if not db_session: