Move SLM control center groundwork onto dev

backend/routers/project_locations.py

@@ -0,0 +1,404 @@
+"""
+Project Locations Router
+
+Handles monitoring locations (NRLs for sound, monitoring points for vibration)
+and unit assignments within projects.
+"""
+
+from fastapi import APIRouter, Request, Depends, HTTPException, Query
+from fastapi.templating import Jinja2Templates
+from fastapi.responses import HTMLResponse, JSONResponse
+from sqlalchemy.orm import Session
+from sqlalchemy import and_, or_
+from datetime import datetime
+from typing import Optional
+import uuid
+import json
+
+from backend.database import get_db
+from backend.models import (
+    Project,
+    ProjectType,
+    MonitoringLocation,
+    UnitAssignment,
+    RosterUnit,
+    RecordingSession,
+)
+
+router = APIRouter(prefix="/api/projects/{project_id}", tags=["project-locations"])
+templates = Jinja2Templates(directory="templates")
+
+
+# ============================================================================
+# Monitoring Locations CRUD
+# ============================================================================
+
+@router.get("/locations", response_class=HTMLResponse)
+async def get_project_locations(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+    location_type: Optional[str] = Query(None),
+):
+    """
+    Get all monitoring locations for a project.
+    Returns HTML partial with location list.
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    query = db.query(MonitoringLocation).filter_by(project_id=project_id)
+
+    # Filter by type if provided
+    if location_type:
+        query = query.filter_by(location_type=location_type)
+
+    locations = query.order_by(MonitoringLocation.name).all()
+
+    # Enrich with assignment info
+    locations_data = []
+    for location in locations:
+        # Get active assignment
+        assignment = db.query(UnitAssignment).filter(
+            and_(
+                UnitAssignment.location_id == location.id,
+                UnitAssignment.status == "active",
+            )
+        ).first()
+
+        assigned_unit = None
+        if assignment:
+            assigned_unit = db.query(RosterUnit).filter_by(id=assignment.unit_id).first()
+
+        # Count recording sessions
+        session_count = db.query(RecordingSession).filter_by(
+            location_id=location.id
+        ).count()
+
+        locations_data.append({
+            "location": location,
+            "assignment": assignment,
+            "assigned_unit": assigned_unit,
+            "session_count": session_count,
+        })
+
+    return templates.TemplateResponse("partials/projects/location_list.html", {
+        "request": request,
+        "project": project,
+        "locations": locations_data,
+    })
+
+
+@router.post("/locations/create")
+async def create_location(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Create a new monitoring location within a project.
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    form_data = await request.form()
+
+    location = MonitoringLocation(
+        id=str(uuid.uuid4()),
+        project_id=project_id,
+        location_type=form_data.get("location_type"),
+        name=form_data.get("name"),
+        description=form_data.get("description"),
+        coordinates=form_data.get("coordinates"),
+        address=form_data.get("address"),
+        location_metadata=form_data.get("location_metadata"),  # JSON string
+    )
+
+    db.add(location)
+    db.commit()
+    db.refresh(location)
+
+    return JSONResponse({
+        "success": True,
+        "location_id": location.id,
+        "message": f"Location '{location.name}' created successfully",
+    })
+
+
+@router.put("/locations/{location_id}")
+async def update_location(
+    project_id: str,
+    location_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Update a monitoring location.
+    """
+    location = db.query(MonitoringLocation).filter_by(
+        id=location_id,
+        project_id=project_id,
+    ).first()
+
+    if not location:
+        raise HTTPException(status_code=404, detail="Location not found")
+
+    data = await request.json()
+
+    # Update fields if provided
+    if "name" in data:
+        location.name = data["name"]
+    if "description" in data:
+        location.description = data["description"]
+    if "coordinates" in data:
+        location.coordinates = data["coordinates"]
+    if "address" in data:
+        location.address = data["address"]
+    if "location_metadata" in data:
+        location.location_metadata = data["location_metadata"]
+
+    location.updated_at = datetime.utcnow()
+
+    db.commit()
+
+    return {"success": True, "message": "Location updated successfully"}
+
+
+@router.delete("/locations/{location_id}")
+async def delete_location(
+    project_id: str,
+    location_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Delete a monitoring location.
+    """
+    location = db.query(MonitoringLocation).filter_by(
+        id=location_id,
+        project_id=project_id,
+    ).first()
+
+    if not location:
+        raise HTTPException(status_code=404, detail="Location not found")
+
+    # Check if location has active assignments
+    active_assignments = db.query(UnitAssignment).filter(
+        and_(
+            UnitAssignment.location_id == location_id,
+            UnitAssignment.status == "active",
+        )
+    ).count()
+
+    if active_assignments > 0:
+        raise HTTPException(
+            status_code=400,
+            detail="Cannot delete location with active unit assignments. Unassign units first.",
+        )
+
+    db.delete(location)
+    db.commit()
+
+    return {"success": True, "message": "Location deleted successfully"}
+
+
+# ============================================================================
+# Unit Assignments
+# ============================================================================
+
+@router.get("/assignments", response_class=HTMLResponse)
+async def get_project_assignments(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+    status: Optional[str] = Query("active"),
+):
+    """
+    Get all unit assignments for a project.
+    Returns HTML partial with assignment list.
+    """
+    query = db.query(UnitAssignment).filter_by(project_id=project_id)
+
+    if status:
+        query = query.filter_by(status=status)
+
+    assignments = query.order_by(UnitAssignment.assigned_at.desc()).all()
+
+    # Enrich with unit and location details
+    assignments_data = []
+    for assignment in assignments:
+        unit = db.query(RosterUnit).filter_by(id=assignment.unit_id).first()
+        location = db.query(MonitoringLocation).filter_by(id=assignment.location_id).first()
+
+        assignments_data.append({
+            "assignment": assignment,
+            "unit": unit,
+            "location": location,
+        })
+
+    return templates.TemplateResponse("partials/projects/assignment_list.html", {
+        "request": request,
+        "project_id": project_id,
+        "assignments": assignments_data,
+    })
+
+
+@router.post("/locations/{location_id}/assign")
+async def assign_unit_to_location(
+    project_id: str,
+    location_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Assign a unit to a monitoring location.
+    """
+    location = db.query(MonitoringLocation).filter_by(
+        id=location_id,
+        project_id=project_id,
+    ).first()
+
+    if not location:
+        raise HTTPException(status_code=404, detail="Location not found")
+
+    form_data = await request.form()
+    unit_id = form_data.get("unit_id")
+
+    # Verify unit exists and matches location type
+    unit = db.query(RosterUnit).filter_by(id=unit_id).first()
+    if not unit:
+        raise HTTPException(status_code=404, detail="Unit not found")
+
+    # Check device type matches location type
+    expected_device_type = "sound_level_meter" if location.location_type == "sound" else "seismograph"
+    if unit.device_type != expected_device_type:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unit type '{unit.device_type}' does not match location type '{location.location_type}'",
+        )
+
+    # Check if location already has an active assignment
+    existing_assignment = db.query(UnitAssignment).filter(
+        and_(
+            UnitAssignment.location_id == location_id,
+            UnitAssignment.status == "active",
+        )
+    ).first()
+
+    if existing_assignment:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Location already has an active unit assignment ({existing_assignment.unit_id}). Unassign first.",
+        )
+
+    # Create new assignment
+    assigned_until_str = form_data.get("assigned_until")
+    assigned_until = datetime.fromisoformat(assigned_until_str) if assigned_until_str else None
+
+    assignment = UnitAssignment(
+        id=str(uuid.uuid4()),
+        unit_id=unit_id,
+        location_id=location_id,
+        project_id=project_id,
+        device_type=unit.device_type,
+        assigned_until=assigned_until,
+        status="active",
+        notes=form_data.get("notes"),
+    )
+
+    db.add(assignment)
+    db.commit()
+    db.refresh(assignment)
+
+    return JSONResponse({
+        "success": True,
+        "assignment_id": assignment.id,
+        "message": f"Unit '{unit_id}' assigned to '{location.name}'",
+    })
+
+
+@router.post("/assignments/{assignment_id}/unassign")
+async def unassign_unit(
+    project_id: str,
+    assignment_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Unassign a unit from a location.
+    """
+    assignment = db.query(UnitAssignment).filter_by(
+        id=assignment_id,
+        project_id=project_id,
+    ).first()
+
+    if not assignment:
+        raise HTTPException(status_code=404, detail="Assignment not found")
+
+    # Check if there are active recording sessions
+    active_sessions = db.query(RecordingSession).filter(
+        and_(
+            RecordingSession.location_id == assignment.location_id,
+            RecordingSession.unit_id == assignment.unit_id,
+            RecordingSession.status == "recording",
+        )
+    ).count()
+
+    if active_sessions > 0:
+        raise HTTPException(
+            status_code=400,
+            detail="Cannot unassign unit with active recording sessions. Stop recording first.",
+        )
+
+    assignment.status = "completed"
+    assignment.assigned_until = datetime.utcnow()
+
+    db.commit()
+
+    return {"success": True, "message": "Unit unassigned successfully"}
+
+
+# ============================================================================
+# Available Units for Assignment
+# ============================================================================
+
+@router.get("/available-units", response_class=JSONResponse)
+async def get_available_units(
+    project_id: str,
+    location_type: str = Query(...),
+    db: Session = Depends(get_db),
+):
+    """
+    Get list of available units for assignment to a location.
+    Filters by device type matching the location type.
+    """
+    # Determine required device type
+    required_device_type = "sound_level_meter" if location_type == "sound" else "seismograph"
+
+    # Get all units of the required type that are deployed and not retired
+    all_units = db.query(RosterUnit).filter(
+        and_(
+            RosterUnit.device_type == required_device_type,
+            RosterUnit.deployed == True,
+            RosterUnit.retired == False,
+        )
+    ).all()
+
+    # Filter out units that already have active assignments
+    assigned_unit_ids = db.query(UnitAssignment.unit_id).filter(
+        UnitAssignment.status == "active"
+    ).distinct().all()
+    assigned_unit_ids = [uid[0] for uid in assigned_unit_ids]
+
+    available_units = [
+        {
+            "id": unit.id,
+            "device_type": unit.device_type,
+            "location": unit.address or unit.location,
+            "model": unit.slm_model if unit.device_type == "sound_level_meter" else unit.unit_type,
+        }
+        for unit in all_units
+        if unit.id not in assigned_unit_ids
+    ]
+
+    return available_units

backend/routers/projects.py

@@ -0,0 +1,359 @@
+"""
+Projects Router
+
+Provides API endpoints for the Projects system:
+- Project CRUD operations
+- Project dashboards
+- Project statistics
+- Type-aware features
+"""
+
+from fastapi import APIRouter, Request, Depends, HTTPException, Query
+from fastapi.templating import Jinja2Templates
+from fastapi.responses import HTMLResponse, JSONResponse
+from sqlalchemy.orm import Session
+from sqlalchemy import func, and_
+from datetime import datetime, timedelta
+from typing import Optional
+import uuid
+import json
+
+from backend.database import get_db
+from backend.models import (
+    Project,
+    ProjectType,
+    MonitoringLocation,
+    UnitAssignment,
+    RecordingSession,
+    ScheduledAction,
+    RosterUnit,
+)
+
+router = APIRouter(prefix="/api/projects", tags=["projects"])
+templates = Jinja2Templates(directory="templates")
+
+
+# ============================================================================
+# Project List & Overview
+# ============================================================================
+
+@router.get("/list", response_class=HTMLResponse)
+async def get_projects_list(
+    request: Request,
+    db: Session = Depends(get_db),
+    status: Optional[str] = Query(None),
+    project_type_id: Optional[str] = Query(None),
+    view: Optional[str] = Query(None),
+):
+    """
+    Get list of all projects.
+    Returns HTML partial with project cards.
+    """
+    query = db.query(Project)
+
+    # Filter by status if provided
+    if status:
+        query = query.filter(Project.status == status)
+
+    # Filter by project type if provided
+    if project_type_id:
+        query = query.filter(Project.project_type_id == project_type_id)
+
+    projects = query.order_by(Project.created_at.desc()).all()
+
+    # Enrich each project with stats
+    projects_data = []
+    for project in projects:
+        # Get project type
+        project_type = db.query(ProjectType).filter_by(id=project.project_type_id).first()
+
+        # Count locations
+        location_count = db.query(func.count(MonitoringLocation.id)).filter_by(
+            project_id=project.id
+        ).scalar()
+
+        # Count assigned units
+        unit_count = db.query(func.count(UnitAssignment.id)).filter(
+            and_(
+                UnitAssignment.project_id == project.id,
+                UnitAssignment.status == "active",
+            )
+        ).scalar()
+
+        # Count active sessions
+        active_session_count = db.query(func.count(RecordingSession.id)).filter(
+            and_(
+                RecordingSession.project_id == project.id,
+                RecordingSession.status == "recording",
+            )
+        ).scalar()
+
+        projects_data.append({
+            "project": project,
+            "project_type": project_type,
+            "location_count": location_count,
+            "unit_count": unit_count,
+            "active_session_count": active_session_count,
+        })
+
+    template_name = "partials/projects/project_list.html"
+    if view == "compact":
+        template_name = "partials/projects/project_list_compact.html"
+
+    return templates.TemplateResponse(template_name, {
+        "request": request,
+        "projects": projects_data,
+    })
+
+
+@router.get("/stats", response_class=HTMLResponse)
+async def get_projects_stats(request: Request, db: Session = Depends(get_db)):
+    """
+    Get summary statistics for projects overview.
+    Returns HTML partial with stat cards.
+    """
+    # Count projects by status
+    total_projects = db.query(func.count(Project.id)).scalar()
+    active_projects = db.query(func.count(Project.id)).filter_by(status="active").scalar()
+    completed_projects = db.query(func.count(Project.id)).filter_by(status="completed").scalar()
+
+    # Count total locations across all projects
+    total_locations = db.query(func.count(MonitoringLocation.id)).scalar()
+
+    # Count assigned units
+    assigned_units = db.query(func.count(UnitAssignment.id)).filter_by(
+        status="active"
+    ).scalar()
+
+    # Count active recording sessions
+    active_sessions = db.query(func.count(RecordingSession.id)).filter_by(
+        status="recording"
+    ).scalar()
+
+    return templates.TemplateResponse("partials/projects/project_stats.html", {
+        "request": request,
+        "total_projects": total_projects,
+        "active_projects": active_projects,
+        "completed_projects": completed_projects,
+        "total_locations": total_locations,
+        "assigned_units": assigned_units,
+        "active_sessions": active_sessions,
+    })
+
+
+# ============================================================================
+# Project CRUD
+# ============================================================================
+
+@router.post("/create")
+async def create_project(request: Request, db: Session = Depends(get_db)):
+    """
+    Create a new project.
+    Expects form data with project details.
+    """
+    form_data = await request.form()
+
+    project = Project(
+        id=str(uuid.uuid4()),
+        name=form_data.get("name"),
+        description=form_data.get("description"),
+        project_type_id=form_data.get("project_type_id"),
+        status="active",
+        client_name=form_data.get("client_name"),
+        site_address=form_data.get("site_address"),
+        site_coordinates=form_data.get("site_coordinates"),
+        start_date=datetime.fromisoformat(form_data.get("start_date")) if form_data.get("start_date") else None,
+        end_date=datetime.fromisoformat(form_data.get("end_date")) if form_data.get("end_date") else None,
+    )
+
+    db.add(project)
+    db.commit()
+    db.refresh(project)
+
+    return JSONResponse({
+        "success": True,
+        "project_id": project.id,
+        "message": f"Project '{project.name}' created successfully",
+    })
+
+
+@router.get("/{project_id}")
+async def get_project(project_id: str, db: Session = Depends(get_db)):
+    """
+    Get project details by ID.
+    Returns JSON with full project data.
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    project_type = db.query(ProjectType).filter_by(id=project.project_type_id).first()
+
+    return {
+        "id": project.id,
+        "name": project.name,
+        "description": project.description,
+        "project_type_id": project.project_type_id,
+        "project_type_name": project_type.name if project_type else None,
+        "status": project.status,
+        "client_name": project.client_name,
+        "site_address": project.site_address,
+        "site_coordinates": project.site_coordinates,
+        "start_date": project.start_date.isoformat() if project.start_date else None,
+        "end_date": project.end_date.isoformat() if project.end_date else None,
+        "created_at": project.created_at.isoformat(),
+        "updated_at": project.updated_at.isoformat(),
+    }
+
+
+@router.put("/{project_id}")
+async def update_project(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Update project details.
+    Expects JSON body with fields to update.
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    data = await request.json()
+
+    # Update fields if provided
+    if "name" in data:
+        project.name = data["name"]
+    if "description" in data:
+        project.description = data["description"]
+    if "status" in data:
+        project.status = data["status"]
+    if "client_name" in data:
+        project.client_name = data["client_name"]
+    if "site_address" in data:
+        project.site_address = data["site_address"]
+    if "site_coordinates" in data:
+        project.site_coordinates = data["site_coordinates"]
+    if "start_date" in data:
+        project.start_date = datetime.fromisoformat(data["start_date"]) if data["start_date"] else None
+    if "end_date" in data:
+        project.end_date = datetime.fromisoformat(data["end_date"]) if data["end_date"] else None
+
+    project.updated_at = datetime.utcnow()
+
+    db.commit()
+
+    return {"success": True, "message": "Project updated successfully"}
+
+
+@router.delete("/{project_id}")
+async def delete_project(project_id: str, db: Session = Depends(get_db)):
+    """
+    Delete a project (soft delete by archiving).
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    project.status = "archived"
+    project.updated_at = datetime.utcnow()
+
+    db.commit()
+
+    return {"success": True, "message": "Project archived successfully"}
+
+
+# ============================================================================
+# Project Dashboard Data
+# ============================================================================
+
+@router.get("/{project_id}/dashboard", response_class=HTMLResponse)
+async def get_project_dashboard(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Get project dashboard data.
+    Returns HTML partial with project summary.
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    project_type = db.query(ProjectType).filter_by(id=project.project_type_id).first()
+
+    # Get locations
+    locations = db.query(MonitoringLocation).filter_by(project_id=project_id).all()
+
+    # Get assigned units with details
+    assignments = db.query(UnitAssignment).filter(
+        and_(
+            UnitAssignment.project_id == project_id,
+            UnitAssignment.status == "active",
+        )
+    ).all()
+
+    assigned_units = []
+    for assignment in assignments:
+        unit = db.query(RosterUnit).filter_by(id=assignment.unit_id).first()
+        if unit:
+            assigned_units.append({
+                "assignment": assignment,
+                "unit": unit,
+            })
+
+    # Get active recording sessions
+    active_sessions = db.query(RecordingSession).filter(
+        and_(
+            RecordingSession.project_id == project_id,
+            RecordingSession.status == "recording",
+        )
+    ).all()
+
+    # Get completed sessions count
+    completed_sessions_count = db.query(func.count(RecordingSession.id)).filter(
+        and_(
+            RecordingSession.project_id == project_id,
+            RecordingSession.status == "completed",
+        )
+    ).scalar()
+
+    # Get upcoming scheduled actions
+    upcoming_actions = db.query(ScheduledAction).filter(
+        and_(
+            ScheduledAction.project_id == project_id,
+            ScheduledAction.execution_status == "pending",
+            ScheduledAction.scheduled_time > datetime.utcnow(),
+        )
+    ).order_by(ScheduledAction.scheduled_time).limit(5).all()
+
+    return templates.TemplateResponse("partials/projects/project_dashboard.html", {
+        "request": request,
+        "project": project,
+        "project_type": project_type,
+        "locations": locations,
+        "assigned_units": assigned_units,
+        "active_sessions": active_sessions,
+        "completed_sessions_count": completed_sessions_count,
+        "upcoming_actions": upcoming_actions,
+    })
+
+
+# ============================================================================
+# Project Types
+# ============================================================================
+
+@router.get("/types/list", response_class=HTMLResponse)
+async def get_project_types(request: Request, db: Session = Depends(get_db)):
+    """
+    Get all available project types.
+    Returns HTML partial with project type cards.
+    """
+    project_types = db.query(ProjectType).all()
+
+    return templates.TemplateResponse("partials/projects/project_type_cards.html", {
+        "request": request,
+        "project_types": project_types,
+    })

backend/routers/scheduler.py

@@ -0,0 +1,409 @@
+"""
+Scheduler Router
+
+Handles scheduled actions for automated recording control.
+"""
+
+from fastapi import APIRouter, Request, Depends, HTTPException, Query
+from fastapi.templating import Jinja2Templates
+from fastapi.responses import HTMLResponse, JSONResponse
+from sqlalchemy.orm import Session
+from sqlalchemy import and_, or_
+from datetime import datetime, timedelta
+from typing import Optional
+import uuid
+import json
+
+from backend.database import get_db
+from backend.models import (
+    Project,
+    ScheduledAction,
+    MonitoringLocation,
+    UnitAssignment,
+    RosterUnit,
+)
+from backend.services.scheduler import get_scheduler
+
+router = APIRouter(prefix="/api/projects/{project_id}/scheduler", tags=["scheduler"])
+templates = Jinja2Templates(directory="templates")
+
+
+# ============================================================================
+# Scheduled Actions List
+# ============================================================================
+
+@router.get("/actions", response_class=HTMLResponse)
+async def get_scheduled_actions(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+    status: Optional[str] = Query(None),
+    start_date: Optional[str] = Query(None),
+    end_date: Optional[str] = Query(None),
+):
+    """
+    Get scheduled actions for a project.
+    Returns HTML partial with agenda/calendar view.
+    """
+    query = db.query(ScheduledAction).filter_by(project_id=project_id)
+
+    # Filter by status
+    if status:
+        query = query.filter_by(execution_status=status)
+    else:
+        # By default, show pending and upcoming completed/failed
+        query = query.filter(
+            or_(
+                ScheduledAction.execution_status == "pending",
+                and_(
+                    ScheduledAction.execution_status.in_(["completed", "failed"]),
+                    ScheduledAction.scheduled_time >= datetime.utcnow() - timedelta(days=7),
+                ),
+            )
+        )
+
+    # Filter by date range
+    if start_date:
+        query = query.filter(ScheduledAction.scheduled_time >= datetime.fromisoformat(start_date))
+    if end_date:
+        query = query.filter(ScheduledAction.scheduled_time <= datetime.fromisoformat(end_date))
+
+    actions = query.order_by(ScheduledAction.scheduled_time).all()
+
+    # Enrich with location and unit details
+    actions_data = []
+    for action in actions:
+        location = db.query(MonitoringLocation).filter_by(id=action.location_id).first()
+
+        unit = None
+        if action.unit_id:
+            unit = db.query(RosterUnit).filter_by(id=action.unit_id).first()
+        else:
+            # Get from assignment
+            assignment = db.query(UnitAssignment).filter(
+                and_(
+                    UnitAssignment.location_id == action.location_id,
+                    UnitAssignment.status == "active",
+                )
+            ).first()
+            if assignment:
+                unit = db.query(RosterUnit).filter_by(id=assignment.unit_id).first()
+
+        actions_data.append({
+            "action": action,
+            "location": location,
+            "unit": unit,
+        })
+
+    return templates.TemplateResponse("partials/projects/scheduler_agenda.html", {
+        "request": request,
+        "project_id": project_id,
+        "actions": actions_data,
+    })
+
+
+# ============================================================================
+# Create Scheduled Action
+# ============================================================================
+
+@router.post("/actions/create")
+async def create_scheduled_action(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Create a new scheduled action.
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    form_data = await request.form()
+
+    location_id = form_data.get("location_id")
+    location = db.query(MonitoringLocation).filter_by(
+        id=location_id,
+        project_id=project_id,
+    ).first()
+
+    if not location:
+        raise HTTPException(status_code=404, detail="Location not found")
+
+    # Determine device type from location
+    device_type = "sound_level_meter" if location.location_type == "sound" else "seismograph"
+
+    # Get unit_id (optional - can be determined from assignment at execution time)
+    unit_id = form_data.get("unit_id")
+
+    action = ScheduledAction(
+        id=str(uuid.uuid4()),
+        project_id=project_id,
+        location_id=location_id,
+        unit_id=unit_id,
+        action_type=form_data.get("action_type"),
+        device_type=device_type,
+        scheduled_time=datetime.fromisoformat(form_data.get("scheduled_time")),
+        execution_status="pending",
+        notes=form_data.get("notes"),
+    )
+
+    db.add(action)
+    db.commit()
+    db.refresh(action)
+
+    return JSONResponse({
+        "success": True,
+        "action_id": action.id,
+        "message": f"Scheduled action '{action.action_type}' created for {action.scheduled_time}",
+    })
+
+
+# ============================================================================
+# Schedule Recording Session
+# ============================================================================
+
+@router.post("/schedule-session")
+async def schedule_recording_session(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Schedule a complete recording session (start + stop).
+    Creates two scheduled actions: start and stop.
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    form_data = await request.form()
+
+    location_id = form_data.get("location_id")
+    location = db.query(MonitoringLocation).filter_by(
+        id=location_id,
+        project_id=project_id,
+    ).first()
+
+    if not location:
+        raise HTTPException(status_code=404, detail="Location not found")
+
+    device_type = "sound_level_meter" if location.location_type == "sound" else "seismograph"
+    unit_id = form_data.get("unit_id")
+
+    start_time = datetime.fromisoformat(form_data.get("start_time"))
+    duration_minutes = int(form_data.get("duration_minutes", 60))
+    stop_time = start_time + timedelta(minutes=duration_minutes)
+
+    # Create START action
+    start_action = ScheduledAction(
+        id=str(uuid.uuid4()),
+        project_id=project_id,
+        location_id=location_id,
+        unit_id=unit_id,
+        action_type="start",
+        device_type=device_type,
+        scheduled_time=start_time,
+        execution_status="pending",
+        notes=form_data.get("notes"),
+    )
+
+    # Create STOP action
+    stop_action = ScheduledAction(
+        id=str(uuid.uuid4()),
+        project_id=project_id,
+        location_id=location_id,
+        unit_id=unit_id,
+        action_type="stop",
+        device_type=device_type,
+        scheduled_time=stop_time,
+        execution_status="pending",
+        notes=f"Auto-stop after {duration_minutes} minutes",
+    )
+
+    db.add(start_action)
+    db.add(stop_action)
+    db.commit()
+
+    return JSONResponse({
+        "success": True,
+        "start_action_id": start_action.id,
+        "stop_action_id": stop_action.id,
+        "message": f"Recording session scheduled from {start_time} to {stop_time}",
+    })
+
+
+# ============================================================================
+# Update/Cancel Scheduled Action
+# ============================================================================
+
+@router.put("/actions/{action_id}")
+async def update_scheduled_action(
+    project_id: str,
+    action_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Update a scheduled action (only if not yet executed).
+    """
+    action = db.query(ScheduledAction).filter_by(
+        id=action_id,
+        project_id=project_id,
+    ).first()
+
+    if not action:
+        raise HTTPException(status_code=404, detail="Action not found")
+
+    if action.execution_status != "pending":
+        raise HTTPException(
+            status_code=400,
+            detail="Cannot update action that has already been executed",
+        )
+
+    data = await request.json()
+
+    if "scheduled_time" in data:
+        action.scheduled_time = datetime.fromisoformat(data["scheduled_time"])
+    if "notes" in data:
+        action.notes = data["notes"]
+
+    db.commit()
+
+    return {"success": True, "message": "Action updated successfully"}
+
+
+@router.post("/actions/{action_id}/cancel")
+async def cancel_scheduled_action(
+    project_id: str,
+    action_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Cancel a pending scheduled action.
+    """
+    action = db.query(ScheduledAction).filter_by(
+        id=action_id,
+        project_id=project_id,
+    ).first()
+
+    if not action:
+        raise HTTPException(status_code=404, detail="Action not found")
+
+    if action.execution_status != "pending":
+        raise HTTPException(
+            status_code=400,
+            detail="Can only cancel pending actions",
+        )
+
+    action.execution_status = "cancelled"
+    db.commit()
+
+    return {"success": True, "message": "Action cancelled successfully"}
+
+
+@router.delete("/actions/{action_id}")
+async def delete_scheduled_action(
+    project_id: str,
+    action_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Delete a scheduled action (only if pending or cancelled).
+    """
+    action = db.query(ScheduledAction).filter_by(
+        id=action_id,
+        project_id=project_id,
+    ).first()
+
+    if not action:
+        raise HTTPException(status_code=404, detail="Action not found")
+
+    if action.execution_status not in ["pending", "cancelled"]:
+        raise HTTPException(
+            status_code=400,
+            detail="Cannot delete action that has been executed",
+        )
+
+    db.delete(action)
+    db.commit()
+
+    return {"success": True, "message": "Action deleted successfully"}
+
+
+# ============================================================================
+# Manual Execution
+# ============================================================================
+
+@router.post("/actions/{action_id}/execute")
+async def execute_action_now(
+    project_id: str,
+    action_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Manually trigger execution of a scheduled action (for testing/debugging).
+    """
+    action = db.query(ScheduledAction).filter_by(
+        id=action_id,
+        project_id=project_id,
+    ).first()
+
+    if not action:
+        raise HTTPException(status_code=404, detail="Action not found")
+
+    if action.execution_status != "pending":
+        raise HTTPException(
+            status_code=400,
+            detail="Action is not pending",
+        )
+
+    # Execute via scheduler service
+    scheduler = get_scheduler()
+    result = await scheduler.execute_action_by_id(action_id)
+
+    # Refresh from DB to get updated status
+    db.refresh(action)
+
+    return JSONResponse({
+        "success": result.get("success", False),
+        "result": result,
+        "action": {
+            "id": action.id,
+            "execution_status": action.execution_status,
+            "executed_at": action.executed_at.isoformat() if action.executed_at else None,
+            "error_message": action.error_message,
+        },
+    })
+
+
+# ============================================================================
+# Scheduler Status
+# ============================================================================
+
+@router.get("/status")
+async def get_scheduler_status():
+    """
+    Get scheduler service status.
+    """
+    scheduler = get_scheduler()
+
+    return {
+        "running": scheduler.running,
+        "check_interval": scheduler.check_interval,
+    }
+
+
+@router.post("/execute-pending")
+async def trigger_pending_execution():
+    """
+    Manually trigger execution of all pending actions (for testing).
+    """
+    scheduler = get_scheduler()
+    results = await scheduler.execute_pending_actions()
+
+    return {
+        "success": True,
+        "executed_count": len(results),
+        "results": results,
+    }

backend/routers/slm_dashboard.py

@@ -10,6 +10,7 @@ from fastapi.responses import HTMLResponse
 from sqlalchemy.orm import Session
 from sqlalchemy import func
 from datetime import datetime, timedelta
+import asyncio
 import httpx
 import logging
 import os
@@ -60,7 +61,13 @@ async def get_slm_stats(request: Request, db: Session = Depends(get_db)):
 async def get_slm_units(
     request: Request,
     db: Session = Depends(get_db),
+<<<<<<< Updated upstream
     search: str = Query(None)
+=======
+    search: str = Query(None),
+    project: str = Query(None),
+    include_measurement: bool = Query(False),
+>>>>>>> Stashed changes
 ):
     """
     Get list of SLM units for the sidebar.
@@ -77,10 +84,39 @@ async def get_slm_units(
             (RosterUnit.address.like(search_term))
         )
 
-    # Only show deployed units by default
-    units = query.filter_by(deployed=True, retired=False).order_by(RosterUnit.id).all()
+    units = query.order_by(
+        RosterUnit.retired.asc(),
+        RosterUnit.deployed.desc(),
+        RosterUnit.id.asc()
+    ).all()
 
-    return templates.TemplateResponse("partials/slm_unit_list.html", {
+    one_hour_ago = datetime.utcnow() - timedelta(hours=1)
+    for unit in units:
+        unit.is_recent = bool(unit.slm_last_check and unit.slm_last_check > one_hour_ago)
+
+    if include_measurement:
+        async def fetch_measurement_state(client: httpx.AsyncClient, unit_id: str) -> str | None:
+            try:
+                response = await client.get(f"{SLMM_BASE_URL}/api/nl43/{unit_id}/measurement-state")
+                if response.status_code == 200:
+                    return response.json().get("measurement_state")
+            except Exception:
+                return None
+            return None
+
+        deployed_units = [unit for unit in units if unit.deployed and not unit.retired]
+        if deployed_units:
+            async with httpx.AsyncClient(timeout=3.0) as client:
+                tasks = [fetch_measurement_state(client, unit.id) for unit in deployed_units]
+                results = await asyncio.gather(*tasks, return_exceptions=True)
+
+            for unit, state in zip(deployed_units, results):
+                if isinstance(state, Exception):
+                    unit.measurement_state = None
+                else:
+                    unit.measurement_state = state
+
+    return templates.TemplateResponse("partials/slm_device_list.html", {
         "request": request,
         "units": units
     })