Phase 3 Steps 3 & 4: Complete Schedules API & Management UI

Implemented full schedule management system with API endpoints and
user interface for creating, editing, and managing scheduled scans.

API Implementation:
- Implemented all 6 schedules API endpoints (list, get, create, update, delete, trigger)
- Added comprehensive error handling and validation
- Integrated with ScheduleService and SchedulerService
- Added manual trigger endpoint for on-demand execution

Schedule Management UI:
- Created schedules list page with stats cards and enable/disable toggles
- Built schedule creation form with cron expression builder and quick templates
- Implemented schedule edit page with execution history
- Added "Schedules" navigation link to main menu
- Real-time validation and human-readable cron descriptions

Config File Path Resolution:
- Fixed config file path handling to support relative filenames
- Updated validators.py to resolve relative paths to /app/configs/
- Modified schedule_service.py, scan_service.py, and scan_job.py for consistency
- Ensures UI can use simple filenames while backend uses absolute paths

Scheduler Integration:
- Completed scheduled scan execution in scheduler_service.py
- Added cron job management with APScheduler
- Implemented automatic schedule loading on startup
- Updated run times after each execution

Testing:
- Added comprehensive API integration tests (test_schedule_api.py)
- 22+ test cases covering all endpoints and workflows

Progress: Phase 3 Steps 1-4 complete (36% - 5/14 days)
Next: Step 5 - Enhanced Dashboard with Charts

web/services/scan_service.py

@@ -66,9 +66,15 @@ class ScanService:
         if not is_valid:
             raise ValueError(f"Invalid config file: {error_msg}")
 
+        # Convert config_file to full path if it's just a filename
+        if not config_file.startswith('/'):
+            config_path = f'/app/configs/{config_file}'
+        else:
+            config_path = config_file
+
         # Load config to get title
         import yaml
-        with open(config_file, 'r') as f:
+        with open(config_path, 'r') as f:
             config = yaml.safe_load(f)
 
         # Create scan record

web/services/schedule_service.py

@@ -64,7 +64,13 @@ class ScheduleService:
             raise ValueError(f"Invalid cron expression: {error_msg}")
 
         # Validate config file exists
-        if not os.path.isfile(config_file):
+        # If config_file is just a filename, prepend the configs directory
+        if not config_file.startswith('/'):
+            config_file_path = os.path.join('/app/configs', config_file)
+        else:
+            config_file_path = config_file
+
+        if not os.path.isfile(config_file_path):
             raise ValueError(f"Config file not found: {config_file}")
 
         # Calculate next run time
@@ -196,7 +202,14 @@ class ScheduleService:
 
         # Validate config file if being updated
         if 'config_file' in updates:
-            if not os.path.isfile(updates['config_file']):
+            config_file = updates['config_file']
+            # If config_file is just a filename, prepend the configs directory
+            if not config_file.startswith('/'):
+                config_file_path = os.path.join('/app/configs', config_file)
+            else:
+                config_file_path = config_file
+
+            if not os.path.isfile(config_file_path):
                 raise ValueError(f"Config file not found: {updates['config_file']}")
 
         # Handle enabled toggle

web/services/scheduler_service.py

@@ -136,35 +136,27 @@ class SchedulerService:
         Raises:
             RuntimeError: If scheduler not initialized
             ValueError: If cron expression is invalid
-
-        Note:
-            This is a placeholder for Phase 3 scheduled scanning feature.
-            Currently not used, but structure is in place.
         """
         if not self.scheduler:
             raise RuntimeError("Scheduler not initialized. Call init_scheduler() first.")
 
-        # Parse cron expression
-        # Format: "minute hour day month day_of_week"
-        parts = cron_expression.split()
-        if len(parts) != 5:
-            raise ValueError(f"Invalid cron expression: {cron_expression}")
+        from apscheduler.triggers.cron import CronTrigger
 
-        minute, hour, day, month, day_of_week = parts
+        # Create cron trigger from expression
+        try:
+            trigger = CronTrigger.from_crontab(cron_expression)
+        except (ValueError, KeyError) as e:
+            raise ValueError(f"Invalid cron expression '{cron_expression}': {str(e)}")
 
-        # Add cron job (currently placeholder - will be enhanced in Phase 3)
+        # Add cron job
         job = self.scheduler.add_job(
             func=self._trigger_scheduled_scan,
-            args=[schedule_id, config_file],
-            trigger='cron',
-            minute=minute,
-            hour=hour,
-            day=day,
-            month=month,
-            day_of_week=day_of_week,
+            args=[schedule_id],
+            trigger=trigger,
             id=f'schedule_{schedule_id}',
             name=f'Schedule {schedule_id}',
-            replace_existing=True
+            replace_existing=True,
+            max_instances=1  # Only one instance per schedule
         )
 
         logger.info(f"Added scheduled scan {schedule_id} with cron '{cron_expression}' (job_id={job.id})")
@@ -191,7 +183,7 @@ class SchedulerService:
         except Exception as e:
             logger.warning(f"Failed to remove scheduled scan job {job_id}: {str(e)}")
 
-    def _trigger_scheduled_scan(self, schedule_id: int, config_file: str):
+    def _trigger_scheduled_scan(self, schedule_id: int):
         """
         Internal method to trigger a scan from a schedule.
 
@@ -199,17 +191,63 @@ class SchedulerService:
 
         Args:
             schedule_id: Database ID of the schedule
-            config_file: Path to YAML configuration file
-
-        Note:
-            This will be fully implemented in Phase 3 when scheduled
-            scanning is added. Currently a placeholder.
         """
         logger.info(f"Scheduled scan triggered: schedule_id={schedule_id}")
-        # TODO: In Phase 3, this will:
-        # 1. Create a new Scan record with triggered_by='scheduled'
-        # 2. Call queue_scan() with the new scan_id
-        # 3. Update schedule's last_run and next_run timestamps
+
+        # Import here to avoid circular imports
+        from sqlalchemy import create_engine
+        from sqlalchemy.orm import sessionmaker
+        from web.services.schedule_service import ScheduleService
+        from web.services.scan_service import ScanService
+
+        try:
+            # Create database session
+            engine = create_engine(self.db_url)
+            Session = sessionmaker(bind=engine)
+            session = Session()
+
+            try:
+                # Get schedule details
+                schedule_service = ScheduleService(session)
+                schedule = schedule_service.get_schedule(schedule_id)
+
+                if not schedule:
+                    logger.error(f"Schedule {schedule_id} not found")
+                    return
+
+                if not schedule['enabled']:
+                    logger.warning(f"Schedule {schedule_id} is disabled, skipping execution")
+                    return
+
+                # Create and trigger scan
+                scan_service = ScanService(session)
+                scan_id = scan_service.trigger_scan(
+                    config_file=schedule['config_file'],
+                    triggered_by='scheduled',
+                    schedule_id=schedule_id,
+                    scheduler=None  # Don't pass scheduler to avoid recursion
+                )
+
+                # Queue the scan for execution
+                self.queue_scan(scan_id, schedule['config_file'])
+
+                # Update schedule's last_run and next_run
+                from croniter import croniter
+                next_run = croniter(schedule['cron_expression'], datetime.utcnow()).get_next(datetime)
+
+                schedule_service.update_run_times(
+                    schedule_id=schedule_id,
+                    last_run=datetime.utcnow(),
+                    next_run=next_run
+                )
+
+                logger.info(f"Scheduled scan completed: schedule_id={schedule_id}, scan_id={scan_id}")
+
+            finally:
+                session.close()
+
+        except Exception as e:
+            logger.error(f"Error triggering scheduled scan {schedule_id}: {str(e)}", exc_info=True)
 
     def get_job_status(self, job_id: str) -> Optional[dict]:
         """