"""Background scheduler for domain checks, TLD price scraping, and notifications.""" import asyncio import logging from datetime import datetime from apscheduler.schedulers.asyncio import AsyncIOScheduler from apscheduler.triggers.cron import CronTrigger from sqlalchemy import select from app.config import get_settings from app.database import AsyncSessionLocal from app.models.domain import Domain, DomainCheck from app.models.user import User from app.services.domain_checker import domain_checker from app.services.email_service import email_service from app.services.price_tracker import price_tracker logger = logging.getLogger(__name__) settings = get_settings() # Global scheduler instance scheduler = AsyncIOScheduler() async def scrape_tld_prices(): """Scheduled task to scrape TLD prices from public sources.""" from app.services.tld_scraper.aggregator import tld_aggregator logger.info("Starting scheduled TLD price scrape...") try: async with AsyncSessionLocal() as db: result = await tld_aggregator.run_scrape(db) logger.info( f"TLD scrape completed: {result.status}, " f"{result.tlds_scraped} TLDs, {result.prices_saved} prices saved" ) if result.errors: logger.warning(f"Scrape errors: {result.errors}") except Exception as e: logger.exception(f"TLD price scrape failed: {e}") async def check_all_domains(): """Check availability of all monitored domains.""" logger.info("Starting daily domain check...") start_time = datetime.utcnow() async with AsyncSessionLocal() as db: # Get all domains result = await db.execute(select(Domain)) domains = result.scalars().all() logger.info(f"Checking {len(domains)} domains...") checked = 0 errors = 0 newly_available = [] for domain in domains: try: # Check domain availability check_result = await domain_checker.check_domain(domain.name) # Track if domain became available was_taken = not domain.is_available is_now_available = check_result.is_available if was_taken and is_now_available and domain.notify_on_available: newly_available.append(domain) # Update domain domain.status = check_result.status domain.is_available = check_result.is_available domain.registrar = check_result.registrar domain.expiration_date = check_result.expiration_date domain.last_checked = datetime.utcnow() # Create check record check = DomainCheck( domain_id=domain.id, status=check_result.status, is_available=check_result.is_available, response_data=str(check_result.to_dict()), checked_at=datetime.utcnow(), ) db.add(check) checked += 1 # Small delay to avoid rate limiting await asyncio.sleep(0.5) except Exception as e: logger.error(f"Error checking domain {domain.name}: {e}") errors += 1 await db.commit() elapsed = (datetime.utcnow() - start_time).total_seconds() logger.info( f"Domain check complete. Checked: {checked}, Errors: {errors}, " f"Newly available: {len(newly_available)}, Time: {elapsed:.2f}s" ) # Send notifications for newly available domains if newly_available: logger.info(f"Domains that became available: {[d.name for d in newly_available]}") await send_domain_availability_alerts(db, newly_available) def setup_scheduler(): """Configure and start the scheduler.""" # Daily domain check at configured hour scheduler.add_job( check_all_domains, CronTrigger(hour=settings.check_hour, minute=settings.check_minute), id="daily_domain_check", name="Daily Domain Availability Check", replace_existing=True, ) # Daily TLD price scrape at 03:00 UTC scheduler.add_job( scrape_tld_prices, CronTrigger(hour=3, minute=0), id="daily_tld_scrape", name="Daily TLD Price Scrape", replace_existing=True, ) # Price change check at 04:00 UTC (after scrape completes) scheduler.add_job( check_price_changes, CronTrigger(hour=4, minute=0), id="daily_price_check", name="Daily Price Change Check", replace_existing=True, ) # Auction scrape every hour (at :30 to avoid conflict with other jobs) scheduler.add_job( scrape_auctions, CronTrigger(minute=30), # Every hour at :30 id="hourly_auction_scrape", name="Hourly Auction Scrape", replace_existing=True, ) logger.info( f"Scheduler configured:" f"\n - Domain check at {settings.check_hour:02d}:{settings.check_minute:02d}" f"\n - TLD price scrape at 03:00 UTC" f"\n - Price change alerts at 04:00 UTC" f"\n - Auction scrape every hour at :30" ) def start_scheduler(): """Start the scheduler if not already running.""" if not scheduler.running: setup_scheduler() scheduler.start() logger.info("Scheduler started") def stop_scheduler(): """Stop the scheduler.""" if scheduler.running: scheduler.shutdown() logger.info("Scheduler stopped") async def run_manual_check(): """Run domain check manually (for testing or on-demand).""" await check_all_domains() async def run_manual_tld_scrape(): """Run TLD price scrape manually (for testing or on-demand).""" await scrape_tld_prices() async def send_domain_availability_alerts(db, domains: list[Domain]): """Send email alerts for newly available domains.""" if not email_service.is_enabled: logger.info("Email service not configured, skipping domain alerts") return alerts_sent = 0 for domain in domains: try: # Get domain owner result = await db.execute( select(User).where(User.id == domain.user_id) ) user = result.scalar_one_or_none() if user and user.email: success = await email_service.send_domain_available_alert( to_email=user.email, domain=domain.name, user_name=user.name, ) if success: alerts_sent += 1 except Exception as e: logger.error(f"Failed to send alert for {domain.name}: {e}") logger.info(f"Sent {alerts_sent} domain availability alerts") async def check_price_changes(): """Check for TLD price changes and send alerts.""" logger.info("Checking for TLD price changes...") try: async with AsyncSessionLocal() as db: # Detect changes in last 24 hours changes = await price_tracker.detect_price_changes(db, hours=24) if changes: logger.info(f"Found {len(changes)} significant price changes") # Send alerts (if email is configured) alerts_sent = await price_tracker.send_price_alerts(db, changes) logger.info(f"Sent {alerts_sent} price change alerts") else: logger.info("No significant price changes detected") except Exception as e: logger.exception(f"Price change check failed: {e}") async def scrape_auctions(): """Scheduled task to scrape domain auctions from public sources.""" from app.services.auction_scraper import auction_scraper logger.info("Starting scheduled auction scrape...") try: async with AsyncSessionLocal() as db: result = await auction_scraper.scrape_all_platforms(db) logger.info( f"Auction scrape completed: " f"{result['total_found']} found, {result['total_new']} new, " f"{result['total_updated']} updated" ) if result.get('errors'): logger.warning(f"Scrape errors: {result['errors']}") except Exception as e: logger.exception(f"Auction scrape failed: {e}")