""" 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.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 fastapi import UploadFile, File import zipfile import hashlib import io from pathlib import Path from backend.database import get_db from backend.models import ( Project, ProjectType, ProjectModule, MonitoringLocation, UnitAssignment, RosterUnit, MonitoringSession, DataFile, UnitHistory, ScheduledAction, ) from backend.templates_config import templates from backend.utils.timezone import local_to_utc router = APIRouter(prefix="/api/projects/{project_id}", tags=["project-locations"]) # ── Audit log helper ────────────────────────────────────────────────────────── # Mirrors record_history() in roster_edit.py. Kept local to avoid cross-router # imports. The four assignment endpoints below use this to write UnitHistory # rows that the unit-detail deployment timeline (Phase 4) renders. def _record_assignment_history( db: Session, unit_id: str, change_type: str, *, old_value: Optional[str] = None, new_value: Optional[str] = None, notes: Optional[str] = None, ) -> None: """Append a UnitHistory row for an assignment-lifecycle event. change_type values used: - assignment_created — unit assigned to a location (new assignment) - assignment_ended — unit unassigned / removed (assigned_until set) - assignment_swapped — unit replaced by another at the same location - assignment_updated — assignment dates / notes edited via PATCH Caller is responsible for db.commit(). """ db.add(UnitHistory( unit_id=unit_id, change_type=change_type, field_name="unit_assignment", old_value=old_value, new_value=new_value, changed_at=datetime.utcnow(), source="manual", notes=notes, )) # ============================================================================ # Shared helpers # ============================================================================ def _require_module(project, module_type: str, db: Session) -> None: """Raise 400 if the project does not have the given module enabled.""" if not project: raise HTTPException(status_code=404, detail="Project not found.") exists = db.query(ProjectModule).filter_by( project_id=project.id, module_type=module_type, enabled=True ).first() if not exists: raise HTTPException( status_code=400, detail=f"This project does not have the {module_type.replace('_', ' ').title()} module enabled.", ) # ============================================================================ # Session period helpers # ============================================================================ def _derive_period_type(dt: datetime) -> str: """ Classify a session start time into one of four period types. Night = 22:00–07:00, Day = 07:00–22:00. Weekend = Saturday (5) or Sunday (6). """ is_weekend = dt.weekday() >= 5 is_night = dt.hour >= 22 or dt.hour < 7 if is_weekend: return "weekend_night" if is_night else "weekend_day" return "weekday_night" if is_night else "weekday_day" def _build_session_label(dt: datetime, location_name: str, period_type: str) -> str: """Build a human-readable session label, e.g. 'NRL-1 — Sun 2/23 — Night'. Uses started_at date as-is; user can correct period_type in the wizard. """ day_abbr = dt.strftime("%a") date_str = f"{dt.month}/{dt.day}" period_str = { "weekday_day": "Day", "weekday_night": "Night", "weekend_day": "Day", "weekend_night": "Night", }.get(period_type, "") parts = [p for p in [location_name, f"{day_abbr} {date_str}", period_str] if p] return " — ".join(parts) # ============================================================================ # 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, split into active + removed. """ 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, splitting active vs removed. active_data: list = [] removed_data: list = [] for location in locations: # Get active assignment (active = assigned_until IS NULL). For # removed locations this will normally be None because the # /remove cascade closes them, but check anyway for resilience # against legacy data. assignment = db.query(UnitAssignment).filter( and_( UnitAssignment.location_id == location.id, UnitAssignment.assigned_until == None, ) ).first() assigned_unit = None if assignment: assigned_unit = db.query(RosterUnit).filter_by(id=assignment.unit_id).first() # Count monitoring sessions session_count = db.query(MonitoringSession).filter_by( location_id=location.id ).count() item = { "location": location, "assignment": assignment, "assigned_unit": assigned_unit, "session_count": session_count, } if location.removed_at is None: active_data.append(item) else: removed_data.append(item) return templates.TemplateResponse("partials/projects/location_list.html", { "request": request, "project": project, "locations": active_data, # back-compat alias "active_locations": active_data, "removed_locations": removed_data, }) @router.get("/locations-json") async def get_project_locations_json( project_id: str, db: Session = Depends(get_db), location_type: Optional[str] = Query(None), include_removed: bool = Query(False), ): """ Get all monitoring locations for a project as JSON. Used by the schedule modal to populate location dropdown. Removed locations are filtered out by default (you can't schedule a new action at a removed location). Pass `include_removed=true` to get them too — useful for historical / reporting views. """ 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) if location_type: query = query.filter_by(location_type=location_type) if not include_removed: query = query.filter(MonitoringLocation.removed_at == None) # noqa: E711 locations = query.order_by(MonitoringLocation.name).all() return [ { "id": loc.id, "name": loc.name, "location_type": loc.location_type, "description": loc.description, "address": loc.address, "coordinates": loc.coordinates, "removed_at": loc.removed_at.isoformat() if loc.removed_at else None, "removal_reason": loc.removal_reason, } for loc in locations ] @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 "location_type" in data: location.location_type = data["location_type"] 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 = assigned_until IS NULL) active_assignments = db.query(UnitAssignment).filter( and_( UnitAssignment.location_id == location_id, UnitAssignment.assigned_until == None, ) ).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"} @router.post("/locations/{location_id}/remove") async def remove_location( project_id: str, location_id: str, request: Request, db: Session = Depends(get_db), ): """ Soft-remove a monitoring location — mark it as no longer actively monitored without destroying it. Use case: a client drops a location from scope mid-project, but the historical events recorded there should remain attributed. Deleting would orphan those events; this preserves them. Cascading side-effects: 1. All active UnitAssignment rows at this location are closed (assigned_until = effective_date, status = "completed"). Units become available for other deployments. 2. All pending ScheduledAction rows at this location are cancelled (execution_status = "cancelled"). 3. Historical events stay attributed (attribution is window-based; events with timestamp < effective_date still match the now-closed assignment windows). Accepts JSON body: - effective_date: ISO datetime (optional, defaults to now) - reason: operator note (optional) """ 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") if location.removed_at is not None: raise HTTPException( status_code=400, detail=f"Location is already removed (as of {location.removed_at.isoformat()}).", ) # Body is optional — POST with no body is fine and means "remove now, # no reason given." try: payload = await request.json() except Exception: payload = {} # Effective date: accept "YYYY-MM-DDTHH:MM" from datetime-local inputs or # full ISO. Defaults to now if absent/empty. raw_eff = payload.get("effective_date") if raw_eff: try: effective_date = datetime.fromisoformat(raw_eff) except (TypeError, ValueError): raise HTTPException( status_code=400, detail=f"Invalid effective_date: {raw_eff!r}", ) else: effective_date = datetime.utcnow() reason = (payload.get("reason") or "").strip() or None # 1. Close active assignments at this location. active_assignments = db.query(UnitAssignment).filter( and_( UnitAssignment.location_id == location_id, UnitAssignment.assigned_until == None, # noqa: E711 — SQL NULL ) ).all() for a in active_assignments: a.status = "completed" a.assigned_until = effective_date _record_assignment_history( db, unit_id=a.unit_id, change_type="assignment_ended", old_value=location.name, new_value="location removed", notes=f"Location '{location.name}' marked as removed" + (f" — {reason}" if reason else ""), ) # 2. Cancel pending scheduled actions at this location. pending_actions = db.query(ScheduledAction).filter( and_( ScheduledAction.location_id == location_id, ScheduledAction.execution_status == "pending", ScheduledAction.scheduled_time >= effective_date, ) ).all() for sa in pending_actions: sa.execution_status = "cancelled" sa.error_message = ( f"Cancelled: location '{location.name}' marked as removed" + (f" — {reason}" if reason else "") ) # 3. Mark the location itself as removed. location.removed_at = effective_date location.removal_reason = reason location.updated_at = datetime.utcnow() db.commit() return { "success": True, "message": f"Location '{location.name}' marked as removed", "effective_date": effective_date.isoformat(), "assignments_closed": len(active_assignments), "actions_cancelled": len(pending_actions), } @router.post("/locations/{location_id}/restore") async def restore_location( project_id: str, location_id: str, db: Session = Depends(get_db), ): """ Restore a previously-removed monitoring location to active. Clears `removed_at` and `removal_reason`. Does NOT automatically re-open the assignments or scheduled actions that were closed when the location was removed — those stay closed and the operator can create new ones if they want to resume monitoring. """ 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") if location.removed_at is None: raise HTTPException( status_code=400, detail="Location is already active.", ) location.removed_at = None location.removal_reason = None location.updated_at = datetime.utcnow() db.commit() return { "success": True, "message": f"Location '{location.name}' restored to active", } # ============================================================================ # 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 = "slm" 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 (active = assigned_until IS NULL) existing_assignment = db.query(UnitAssignment).filter( and_( UnitAssignment.location_id == location_id, UnitAssignment.assigned_until == None, ) ).first() if existing_assignment: raise HTTPException( status_code=400, detail=f"Location already has an active unit assignment ({existing_assignment.unit_id}). Use swap to replace it.", ) # 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) _record_assignment_history( db, unit_id=unit_id, change_type="assignment_created", new_value=f"{location.name} (project: {location.project_id})", notes=form_data.get("notes"), ) 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 monitoring sessions active_sessions = db.query(MonitoringSession).filter( and_( MonitoringSession.location_id == assignment.location_id, MonitoringSession.unit_id == assignment.unit_id, MonitoringSession.status == "recording", ) ).count() if active_sessions > 0: raise HTTPException( status_code=400, detail="Cannot unassign unit with active monitoring sessions. Stop monitoring first.", ) assignment.status = "completed" assignment.assigned_until = datetime.utcnow() location = db.query(MonitoringLocation).filter_by(id=assignment.location_id).first() _record_assignment_history( db, unit_id=assignment.unit_id, change_type="assignment_ended", old_value=location.name if location else assignment.location_id, new_value="unassigned", ) db.commit() return {"success": True, "message": "Unit unassigned successfully"} @router.patch("/assignments/{assignment_id}") async def update_assignment( project_id: str, assignment_id: str, request: Request, db: Session = Depends(get_db), ): """ Update an assignment's date window and/or notes. Common use case: backdate a deployment so events emitted before the operator created the assignment in terra-view (e.g. a unit that was physically deployed in December but only recorded in the system today) get correctly attributed to the location. Accepts JSON body with optional fields: - assigned_at: ISO datetime (or empty string to leave unchanged) - assigned_until: ISO datetime, or null/"" to mark indefinite (active) - notes: string Sets `status` to "active" when assigned_until is cleared, "completed" when it's set in the past. """ 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") try: payload = await request.json() except Exception: raise HTTPException(status_code=400, detail="Invalid JSON body") # Parse new values (None = unchanged, explicit None/"" for assigned_until = clear) new_assigned_at = assignment.assigned_at new_assigned_until = assignment.assigned_until new_notes = assignment.notes if "assigned_at" in payload: raw = payload["assigned_at"] if raw is None or raw == "": raise HTTPException( status_code=400, detail="assigned_at is required; cannot be cleared.", ) try: # Accept "YYYY-MM-DDTHH:MM" from datetime-local inputs or full ISO. new_assigned_at = datetime.fromisoformat(raw) except (TypeError, ValueError): raise HTTPException( status_code=400, detail=f"Invalid assigned_at datetime: {raw!r}", ) if "assigned_until" in payload: raw = payload["assigned_until"] if raw is None or raw == "": new_assigned_until = None else: try: new_assigned_until = datetime.fromisoformat(raw) except (TypeError, ValueError): raise HTTPException( status_code=400, detail=f"Invalid assigned_until datetime: {raw!r}", ) if "notes" in payload: raw = payload["notes"] new_notes = (raw or "").strip() or None # Validation: end must be after start if both set. if new_assigned_until is not None and new_assigned_until <= new_assigned_at: raise HTTPException( status_code=400, detail="assigned_until must be after assigned_at.", ) # Sanity: reject creating an overlap with another assignment of the SAME # unit at the SAME location. Different units at the same location can # legitimately overlap during a swap window (rare but valid). new_end_for_overlap = new_assigned_until or datetime.utcnow() overlapping = ( db.query(UnitAssignment) .filter(UnitAssignment.location_id == assignment.location_id) .filter(UnitAssignment.unit_id == assignment.unit_id) .filter(UnitAssignment.id != assignment.id) .all() ) for other in overlapping: other_start = other.assigned_at other_end = other.assigned_until or datetime.utcnow() if new_assigned_at < other_end and new_end_for_overlap > other_start: raise HTTPException( status_code=400, detail=( f"This window overlaps with another assignment for the " f"same unit ({other.assigned_at:%Y-%m-%d} → " f"{other.assigned_until and other.assigned_until.strftime('%Y-%m-%d') or 'present'})." ), ) # Capture change description for audit log BEFORE mutating. old_start = assignment.assigned_at.isoformat() if assignment.assigned_at else None old_end = assignment.assigned_until.isoformat() if assignment.assigned_until else "active" new_start = new_assigned_at.isoformat() if new_assigned_at else None new_end = new_assigned_until.isoformat() if new_assigned_until else "active" # Apply. assignment.assigned_at = new_assigned_at assignment.assigned_until = new_assigned_until assignment.notes = new_notes assignment.status = "completed" if new_assigned_until is not None else "active" if old_start != new_start or old_end != new_end: _record_assignment_history( db, unit_id=assignment.unit_id, change_type="assignment_updated", old_value=f"{old_start} → {old_end}", new_value=f"{new_start} → {new_end}", notes=new_notes, ) db.commit() db.refresh(assignment) return { "success": True, "assignment": { "id": assignment.id, "unit_id": assignment.unit_id, "location_id": assignment.location_id, "assigned_at": assignment.assigned_at.isoformat() if assignment.assigned_at else None, "assigned_until": assignment.assigned_until.isoformat() if assignment.assigned_until else None, "status": assignment.status, "notes": assignment.notes, }, } @router.delete("/assignments/{assignment_id}") async def delete_assignment( project_id: str, assignment_id: str, db: Session = Depends(get_db), ): """ Hard-delete an assignment record. Use case: operator clicked Assign by mistake (or 8 times in a row) and wants the bogus records gone — not just closed with an `assigned_until` timestamp. The standard close-via-unassign path is for legitimate deployments that ended; this is for mis-clicks that never actually happened. Safety: - Refuses if any MonitoringSession exists for the same (unit, location) within this assignment's window — that suggests the deployment was real, and the operator should use unassign instead. - Refuses if the assignment is the ONLY active assignment for a unit currently shown as deployed AND a recording session is in progress. Audit: - Records UnitHistory `assignment_deleted` so the unit's deployment timeline shows the deletion happened (even though the row itself is gone). """ 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") # Safety: is there a real recording history for this (unit, location) # within the assignment's time window? If so, this isn't a mis-click — # the operator should close it via unassign, not delete it. window_start = assignment.assigned_at window_end = assignment.assigned_until or datetime.utcnow() real_sessions = db.query(MonitoringSession).filter( and_( MonitoringSession.location_id == assignment.location_id, MonitoringSession.unit_id == assignment.unit_id, MonitoringSession.started_at >= window_start, MonitoringSession.started_at <= window_end, ) ).count() if real_sessions > 0: raise HTTPException( status_code=400, detail=( f"Cannot delete this assignment — {real_sessions} monitoring " f"session(s) were recorded under it. Use Unassign to close " f"the window instead, which preserves the audit trail." ), ) # Resolve location name for audit log before deletion. location = db.query(MonitoringLocation).filter_by( id=assignment.location_id ).first() location_label = location.name if location else assignment.location_id _record_assignment_history( db, unit_id=assignment.unit_id, change_type="assignment_deleted", old_value=f"{location_label} ({assignment.assigned_at:%Y-%m-%d} → " f"{assignment.assigned_until and assignment.assigned_until.strftime('%Y-%m-%d') or 'active'})", new_value="deleted", notes=( "Assignment row removed — created in error or accidental duplicate." ), ) db.delete(assignment) db.commit() return { "success": True, "message": "Assignment deleted.", } @router.post("/assignments/merge") async def merge_assignments( project_id: str, request: Request, db: Session = Depends(get_db), ): """ Merge multiple consecutive UnitAssignment rows for the same (unit, location) into a single record spanning their combined window. Use case: a unit's deployment timeline shows 3 stacked rows for the same location because the assignment was closed-and-reopened (e.g. via location remove + restore) or because metadata-backfill auto-created a retroactive window adjacent to a manual one. Operator sees three rows but they represent one continuous deployment. Body JSON: { "assignment_ids": ["", "", ...] } Validation: - All assignments must belong to project_id - All must share the same unit_id AND location_id - At least 2 ids must be provided Merge rules: - Keeps the EARLIEST-starting assignment as the surviving row - assigned_at = min(assigned_at across all) - assigned_until = max(assigned_until), or NULL if any input was active - status = "active" if any input was active, else "completed" - source = source of the earliest record (preserves original ingest provenance) - notes = earliest's notes + "Merged N records ()" - Other records are DELETED - One UnitHistory `assignment_merged` row is written for audit No tolerance check — the operator is asking for the merge, so we trust the intent. The UI can pre-filter to only offer "consecutive" merges if it wants. """ try: payload = await request.json() except Exception: raise HTTPException(status_code=400, detail="Invalid JSON body") ids = payload.get("assignment_ids") or [] if not isinstance(ids, list) or len(ids) < 2: raise HTTPException( status_code=400, detail="Need at least 2 assignment_ids to merge.", ) assignments = ( db.query(UnitAssignment) .filter(UnitAssignment.project_id == project_id) .filter(UnitAssignment.id.in_(ids)) .all() ) if len(assignments) != len(set(ids)): raise HTTPException( status_code=404, detail=f"Some assignments not found (got {len(assignments)} of {len(set(ids))}).", ) unit_ids = {a.unit_id for a in assignments} loc_ids = {a.location_id for a in assignments} if len(unit_ids) > 1 or len(loc_ids) > 1: raise HTTPException( status_code=400, detail="Can only merge assignments that share the same unit and location.", ) # Order chronologically. assignments.sort(key=lambda a: a.assigned_at) earliest = assignments[0] others = assignments[1:] # Compute merged window. any_active = any(a.assigned_until is None for a in assignments) if any_active: merged_until = None else: merged_until = max(a.assigned_until for a in assignments) # Build a brief audit-style note describing what got merged. bits = [] for a in assignments: win = ( f"{a.assigned_at:%Y-%m-%d}" f"→{(a.assigned_until and a.assigned_until.strftime('%Y-%m-%d')) or 'active'}" ) bits.append(f"{win} [{a.source}]") merge_note_suffix = f"Merged {len(assignments)} records: " + " + ".join(bits) new_notes = (earliest.notes + " • " + merge_note_suffix) if earliest.notes else merge_note_suffix # Resolve names for the audit log before mutating. location = db.query(MonitoringLocation).filter_by(id=earliest.location_id).first() location_label = location.name if location else earliest.location_id # Mutate the survivor. earliest.assigned_at = min(a.assigned_at for a in assignments) earliest.assigned_until = merged_until earliest.status = "active" if any_active else "completed" earliest.notes = new_notes # Delete the rest. deleted_ids = [a.id for a in others] for a in others: db.delete(a) _record_assignment_history( db, unit_id=earliest.unit_id, change_type="assignment_merged", old_value=f"{len(assignments)} rows at {location_label}", new_value=( f"1 row {earliest.assigned_at:%Y-%m-%d}" f"→{(merged_until and merged_until.strftime('%Y-%m-%d')) or 'active'}" ), notes=merge_note_suffix, ) db.commit() db.refresh(earliest) return { "success": True, "message": f"Merged {len(assignments)} assignments into one.", "kept_id": earliest.id, "deleted_ids": deleted_ids, "merged_window": { "assigned_at": earliest.assigned_at.isoformat(), "assigned_until": earliest.assigned_until.isoformat() if earliest.assigned_until else None, }, } @router.post("/locations/{location_id}/swap") async def swap_unit_on_location( project_id: str, location_id: str, request: Request, db: Session = Depends(get_db), ): """ Swap the unit assigned to a vibration monitoring location. Ends the current active assignment (if any), creates a new one, and optionally updates modem pairing on the seismograph. Works for first-time assignments too (no current assignment = just create). """ 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") modem_id = form_data.get("modem_id") or None notes = form_data.get("notes") or None if not unit_id: raise HTTPException(status_code=400, detail="unit_id is required") # Validate new unit unit = db.query(RosterUnit).filter_by(id=unit_id).first() if not unit: raise HTTPException(status_code=404, detail="Unit not found") expected_device_type = "slm" 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}'", ) # End current active assignment if one exists (active = assigned_until IS NULL) current = db.query(UnitAssignment).filter( and_( UnitAssignment.location_id == location_id, UnitAssignment.assigned_until == None, ) ).first() if current: current.assigned_until = datetime.utcnow() current.status = "completed" # If the swap is replacing a different unit, that unit's deployment ended. if current.unit_id != unit_id: _record_assignment_history( db, unit_id=current.unit_id, change_type="assignment_swapped", old_value=location.name, new_value=f"swapped out → {unit_id}", notes=notes, ) # Create new assignment new_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=None, status="active", notes=notes, ) db.add(new_assignment) _record_assignment_history( db, unit_id=unit_id, change_type="assignment_swapped" if (current and current.unit_id != unit_id) else "assignment_created", new_value=f"{location.name} (project: {location.project_id})", notes=notes, ) # Update modem pairing on the seismograph if modem provided if modem_id: modem = db.query(RosterUnit).filter_by(id=modem_id, device_type="modem").first() if not modem: raise HTTPException(status_code=404, detail=f"Modem '{modem_id}' not found") unit.deployed_with_modem_id = modem_id modem.deployed_with_unit_id = unit_id else: # Clear modem pairing if not provided unit.deployed_with_modem_id = None db.commit() return JSONResponse({ "success": True, "assignment_id": new_assignment.id, "message": f"Unit '{unit_id}' assigned to '{location.name}'" + (f" with modem '{modem_id}'" if modem_id else ""), }) # ============================================================================ # Available Units for Assignment # ============================================================================ @router.get("/available-modems", response_class=JSONResponse) async def get_available_modems( project_id: str, db: Session = Depends(get_db), ): """ Get all deployed, non-retired modems for the modem assignment dropdown. """ modems = db.query(RosterUnit).filter( and_( RosterUnit.device_type == "modem", RosterUnit.deployed == True, RosterUnit.retired == False, ) ).order_by(RosterUnit.id).all() return [ { "id": m.id, "hardware_model": m.hardware_model, "ip_address": m.ip_address, } for m in modems ] @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 = "slm" 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 (active = assigned_until IS NULL) assigned_unit_ids = db.query(UnitAssignment.unit_id).filter( UnitAssignment.assigned_until == None ).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 == "slm" else unit.unit_type, } for unit in all_units if unit.id not in assigned_unit_ids ] return available_units # ============================================================================ # NRL-specific endpoints for detail page # ============================================================================ @router.get("/nrl/{location_id}/sessions", response_class=HTMLResponse) async def get_nrl_sessions( project_id: str, location_id: str, request: Request, db: Session = Depends(get_db), ): """ Get monitoring sessions for a specific NRL. Returns HTML partial with session list. """ sessions = db.query(MonitoringSession).filter_by( location_id=location_id ).order_by(MonitoringSession.started_at.desc()).all() # Enrich with unit details sessions_data = [] for session in sessions: unit = None if session.unit_id: unit = db.query(RosterUnit).filter_by(id=session.unit_id).first() sessions_data.append({ "session": session, "unit": unit, }) return templates.TemplateResponse("partials/projects/session_list.html", { "request": request, "project_id": project_id, "location_id": location_id, "sessions": sessions_data, }) @router.get("/vibration_summary", response_class=HTMLResponse) async def get_project_vibration_summary( project_id: str, request: Request, from_dt: Optional[datetime] = Query(None), to_dt: Optional[datetime] = Query(None), db: Session = Depends(get_db), ): """ Render a small HTML partial summarising vibration-event activity across every vibration MonitoringLocation in the project. Returned to the Vibration tab of the project detail page via HTMX. Fans out concurrently across all locations (which in turn fan out across each location's UnitAssignment windows). Total queries to SFM = sum of assignments across the project. 404 if the project doesn't exist. Empty-state partial if the project has no vibration locations. """ project = db.query(Project).filter_by(id=project_id).first() if not project: raise HTTPException(status_code=404, detail="Project not found.") from backend.services.sfm_events import vibration_summary_for_project summary = await vibration_summary_for_project( db, project_id, from_dt=from_dt, to_dt=to_dt ) return templates.TemplateResponse( "partials/projects/vibration_summary.html", { "request": request, "project_id": project_id, "summary": summary, }, ) @router.get("/locations/{location_id}/events", response_class=JSONResponse) async def get_location_events( project_id: str, location_id: str, from_dt: Optional[datetime] = Query(None), to_dt: Optional[datetime] = Query(None), false_trigger: Optional[bool] = Query(None), limit: int = Query(500, ge=1, le=5000), db: Session = Depends(get_db), ): """ Return SFM events recorded at this monitoring location. Fans out the location's UnitAssignment rows (every seismograph ever assigned to this location, active + closed), queries SFM /db/events for each (serial, time-window) pair concurrently, and unions the results. Sound (SLM) locations return an empty payload — SFM events are seismograph-only. """ location = db.query(MonitoringLocation).filter_by(id=location_id).first() if not location: raise HTTPException(status_code=404, detail="Location not found.") if location.project_id != project_id: raise HTTPException( status_code=404, detail="Location does not belong to this project.", ) # SLM locations don't have SFM events — return an empty payload rather # than 404 so the frontend can render an empty state gracefully. if location.location_type != "vibration": return { "events": [], "count": 0, "stats": { "event_count": 0, "peak_pvs": None, "peak_pvs_at": None, "peak_pvs_serial": None, "last_event": None, "false_trigger_count": 0, }, "assignments_used": [], "location_type": location.location_type, } from backend.services.sfm_events import events_for_location result = await events_for_location( db, location_id, from_dt=from_dt, to_dt=to_dt, false_trigger=false_trigger, limit=limit, ) result["location_type"] = location.location_type return result @router.get("/nrl/{location_id}/files", response_class=HTMLResponse) async def get_nrl_files( project_id: str, location_id: str, request: Request, db: Session = Depends(get_db), ): """ Get data files for a specific NRL. Returns HTML partial with file list. """ # Join DataFile with MonitoringSession to filter by location_id files = db.query(DataFile).join( MonitoringSession, DataFile.session_id == MonitoringSession.id ).filter( MonitoringSession.location_id == location_id ).order_by(DataFile.created_at.desc()).all() # Enrich with session details files_data = [] for file in files: session = None if file.session_id: session = db.query(MonitoringSession).filter_by(id=file.session_id).first() files_data.append({ "file": file, "session": session, }) return templates.TemplateResponse("partials/projects/file_list.html", { "request": request, "project_id": project_id, "location_id": location_id, "files": files_data, }) # ============================================================================ # Manual SD Card Data Upload # ============================================================================ def _parse_rnh(content: bytes) -> dict: """ Parse a Rion .rnh metadata file (INI-style with [Section] headers). Returns a dict of key metadata fields. """ result = {} try: text = content.decode("utf-8", errors="replace") for line in text.splitlines(): line = line.strip() if not line or line.startswith("["): continue if "," in line: key, _, value = line.partition(",") key = key.strip() value = value.strip() if key == "Serial Number": result["serial_number"] = value elif key == "Store Name": result["store_name"] = value elif key == "Index Number": result["index_number"] = value elif key == "Measurement Start Time": result["start_time_str"] = value elif key == "Measurement Stop Time": result["stop_time_str"] = value elif key == "Total Measurement Time": result["total_time_str"] = value except Exception: pass return result def _parse_rnh_datetime(s: str): """Parse RNH datetime string: '2026/02/17 19:00:19' -> datetime""" from datetime import datetime if not s: return None try: return datetime.strptime(s.strip(), "%Y/%m/%d %H:%M:%S") except Exception: return None def _classify_file(filename: str) -> str: """Classify a file by name into a DataFile file_type.""" name = filename.lower() if name.endswith(".rnh"): return "log" if name.endswith(".rnd"): return "measurement" if name.endswith(".zip"): return "archive" return "data" @router.post("/nrl/{location_id}/upload-data") async def upload_nrl_data( project_id: str, location_id: str, db: Session = Depends(get_db), files: list[UploadFile] = File(...), ): """ Manually upload SD card data for an offline NRL. Accepts either: - A single .zip file (the Auto_#### folder zipped) — auto-extracted - Multiple .rnd / .rnh files selected directly from the SD card folder Creates a MonitoringSession from .rnh metadata and DataFile records for each measurement file. No unit assignment required. """ from datetime import datetime # Verify project and location exist project = db.query(Project).filter_by(id=project_id).first() _require_module(project, "sound_monitoring", db) 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") # --- Step 1: Normalize to (filename, bytes) list --- file_entries: list[tuple[str, bytes]] = [] if len(files) == 1 and files[0].filename.lower().endswith(".zip"): raw = await files[0].read() try: with zipfile.ZipFile(io.BytesIO(raw)) as zf: for info in zf.infolist(): if info.is_dir(): continue name = Path(info.filename).name # strip folder path if not name: continue file_entries.append((name, zf.read(info))) except zipfile.BadZipFile: raise HTTPException(status_code=400, detail="Uploaded file is not a valid ZIP archive.") else: for uf in files: data = await uf.read() file_entries.append((uf.filename, data)) if not file_entries: raise HTTPException(status_code=400, detail="No usable files found in upload.") # --- Step 1b: Filter to only relevant files --- # Keep: .rnh (metadata) and measurement .rnd files # NL-43 generates two .rnd types: _Leq_ (15-min averages, wanted) and _Lp_ (1-sec granular, skip) # AU2 (NL-23/older Rion) generates a single Au2_####.rnd per session — always keep those # Drop: _Lp_ .rnd, .xlsx, .mp3, and anything else def _is_wanted(fname: str) -> bool: n = fname.lower() if n.endswith(".rnh"): return True if n.endswith(".rnd"): if "_leq_" in n: # NL-43 Leq file return True if n.startswith("au2_"): # AU2 format (NL-23) — always Leq equivalent return True if "_lp" not in n and "_leq_" not in n: # Unknown .rnd format — include it so we don't silently drop data return True return False file_entries = [(fname, fbytes) for fname, fbytes in file_entries if _is_wanted(fname)] if not file_entries: raise HTTPException(status_code=400, detail="No usable .rnd or .rnh files found. Expected NL-43 _Leq_ files or AU2 format .rnd files.") # --- Step 2: Find and parse .rnh metadata --- rnh_meta = {} for fname, fbytes in file_entries: if fname.lower().endswith(".rnh"): rnh_meta = _parse_rnh(fbytes) break # RNH files store local time (no UTC offset). Use local values for period # classification / label generation, then convert to UTC for DB storage so # the local_datetime Jinja filter displays the correct time. started_at_local = _parse_rnh_datetime(rnh_meta.get("start_time_str")) or datetime.utcnow() stopped_at_local = _parse_rnh_datetime(rnh_meta.get("stop_time_str")) started_at = local_to_utc(started_at_local) stopped_at = local_to_utc(stopped_at_local) if stopped_at_local else None duration_seconds = None if started_at and stopped_at: duration_seconds = int((stopped_at - started_at).total_seconds()) store_name = rnh_meta.get("store_name", "") serial_number = rnh_meta.get("serial_number", "") index_number = rnh_meta.get("index_number", "") # --- Step 3: Create MonitoringSession --- # Use local times for period/label so classification reflects the clock at the site. period_type = _derive_period_type(started_at_local) if started_at_local else None session_label = _build_session_label(started_at_local, location.name, period_type) if started_at_local else None session_id = str(uuid.uuid4()) monitoring_session = MonitoringSession( id=session_id, project_id=project_id, location_id=location_id, unit_id=None, session_type="sound", started_at=started_at, stopped_at=stopped_at, duration_seconds=duration_seconds, status="completed", session_label=session_label, period_type=period_type, session_metadata=json.dumps({ "source": "manual_upload", "store_name": store_name, "serial_number": serial_number, "index_number": index_number, }), ) db.add(monitoring_session) db.commit() db.refresh(monitoring_session) # --- Step 4: Write files to disk and create DataFile records --- output_dir = Path("data/Projects") / project_id / session_id output_dir.mkdir(parents=True, exist_ok=True) leq_count = 0 lp_count = 0 metadata_count = 0 files_imported = 0 for fname, fbytes in file_entries: file_type = _classify_file(fname) fname_lower = fname.lower() # Track counts for summary if fname_lower.endswith(".rnd"): if "_leq_" in fname_lower: leq_count += 1 elif "_lp" in fname_lower: lp_count += 1 elif fname_lower.endswith(".rnh"): metadata_count += 1 # Write to disk dest = output_dir / fname dest.write_bytes(fbytes) # Compute checksum checksum = hashlib.sha256(fbytes).hexdigest() # Store relative path from data/ dir rel_path = str(dest.relative_to("data")) data_file = DataFile( id=str(uuid.uuid4()), session_id=session_id, file_path=rel_path, file_type=file_type, file_size_bytes=len(fbytes), downloaded_at=datetime.utcnow(), checksum=checksum, file_metadata=json.dumps({ "source": "manual_upload", "original_filename": fname, "store_name": store_name, }), ) db.add(data_file) files_imported += 1 db.commit() return { "success": True, "session_id": session_id, "files_imported": files_imported, "leq_files": leq_count, "lp_files": lp_count, "metadata_files": metadata_count, "store_name": store_name, "started_at": started_at.isoformat() if started_at else None, "stopped_at": stopped_at.isoformat() if stopped_at else None, } # ============================================================================ # NRL Live Status (connected NRLs only) # ============================================================================ @router.get("/nrl/{location_id}/live-status", response_class=HTMLResponse) async def get_nrl_live_status( project_id: str, location_id: str, request: Request, db: Session = Depends(get_db), ): """ Fetch cached status from SLMM for the unit assigned to this NRL and return a compact HTML status card. Used in the NRL overview tab for connected NRLs. Gracefully shows an offline message if SLMM is unreachable. Sound Monitoring projects only. """ import os import httpx _require_module(db.query(Project).filter_by(id=project_id).first(), "sound_monitoring", db) # Find the assigned unit (active = assigned_until IS NULL) assignment = db.query(UnitAssignment).filter( and_( UnitAssignment.location_id == location_id, UnitAssignment.assigned_until == None, ) ).first() if not assignment: return templates.TemplateResponse("partials/projects/nrl_live_status.html", { "request": request, "status": None, "error": "No unit assigned", }) unit = db.query(RosterUnit).filter_by(id=assignment.unit_id).first() if not unit: return templates.TemplateResponse("partials/projects/nrl_live_status.html", { "request": request, "status": None, "error": "Assigned unit not found", }) slmm_base = os.getenv("SLMM_BASE_URL", "http://localhost:8100") status_data = None error_msg = None try: async with httpx.AsyncClient(timeout=5.0) as client: resp = await client.get(f"{slmm_base}/api/nl43/{unit.id}/status") if resp.status_code == 200: status_data = resp.json() else: error_msg = f"SLMM returned {resp.status_code}" except Exception as e: error_msg = "SLMM unreachable" return templates.TemplateResponse("partials/projects/nrl_live_status.html", { "request": request, "unit": unit, "status": status_data, "error": error_msg, })