Update main.py

main.py

@@ -12,6 +12,9 @@ from firebase_admin import credentials, db, auth as firebase_auth
 from resend import Emails
 import logging
 from logging.handlers import RotatingFileHandler
+import time # <-- ADDED IMPORT
+import random # <-- ADDED IMPORT
+from datetime import datetime # <-- ADDED IMPORT FOR CONVENIENCE
 
 # === Logging Configuration ===
 # Configure logging
@@ -38,7 +41,6 @@ logger.addHandler(file_handler)
 logger.addHandler(console_handler)
 
 # Also configure the root logger for Flask's default messages
-# (This might duplicate some logs, but ensures Flask's internal messages are captured)
 root_logger = logging.getLogger()
 root_logger.setLevel(logging.INFO)
 root_logger.addHandler(file_handler)
@@ -51,7 +53,7 @@ FIREBASE_DB_URL = os.getenv("Firebase_DB")
 ADMIN_EMAILS = ["rairorr@gmail.com", "nharingosheperd@gmail.com"]
 
 logger.info("Environment variables loaded.")
-logger.debug(f"FIREBASE_DB_URL: {FIREBASE_DB_URL}") # Be careful logging sensitive data
+logger.debug(f"FIREBASE_DB_URL: {FIREBASE_DB_URL}")
 
 # === Firebase Init ===
 try:
@@ -108,14 +110,19 @@ def send_email(to, subject, html):
             "subject": subject,
             "html": html
         })
-        logger.info(f"Email sent successfully to {to}")
+        # Check for None response, which might indicate an issue not raising an exception
+        if response is None:
+            logger.warning(f"Email API returned None for recipient {to}. Check Resend dashboard for suppression or other issues.")
+            return None
+        logger.info(f"Email sent successfully to {to}. Response: {response}")
         return response
     except Exception as e:
         logger.error(f"Email error to {to}: {e}")
         return None
 
+# === REFACTORED FUNCTION (send_rotation_notification) ===
 def send_rotation_notification(job_id, shift_record):
-    """Send email notification for rotation to all admins"""
+    """Send email notification for rotation to all admins with rate-limiting prevention"""
     try:
         job_ref = db.reference(f"jobs/{job_id}")
         job_data = job_ref.get()
@@ -127,20 +134,29 @@ def send_rotation_notification(job_id, shift_record):
         job_name = job_data.get("name", "Unknown Job")
         shift_number = shift_record.get("shift_number", "Unknown")
 
-        # Create HTML email content
+        # --- DATE/TIME FORMATTING REFACTOR ---
+        try:
+            # Parse ISO string and format into a human-readable string
+            assigned_time_iso = shift_record.get('assigned_at', '')
+            dt_object = datetime.fromisoformat(assigned_time_iso)
+            human_readable_time = dt_object.strftime("%B %d, %Y at %I:%M %p UTC")
+        except (ValueError, TypeError):
+            human_readable_time = shift_record.get('assigned_at', 'Unknown')
+
+        # --- EMAIL CONTENT REFACTOR ---
         html_content = f"""
         <h2>Guard Rotation Notification</h2>
         <p><strong>Job:</strong> {job_name}</p>
         <p><strong>Job ID:</strong> {job_id}</p>
         <p><strong>Shift Number:</strong> {shift_number}</p>
-        <p><strong>Rotation Time:</strong> {shift_record.get('assigned_at', 'Unknown')}</p>
+        <p><strong>Rotation Time:</strong> {human_readable_time}</p>
 
         <h3>Assignments:</h3>
         <table border="1" style="border-collapse: collapse; width: 100%;">
             <thead>
                 <tr>
                     <th>Guarding Point</th>
-                    <th>Assigned Member</th>
+                    <th>Assigned Members</th>
                     <th>Special Case</th>
                 </tr>
             </thead>
@@ -149,19 +165,18 @@ def send_rotation_notification(job_id, shift_record):
 
         for assignment in shift_record.get("assignments", []):
             point_name = assignment.get("point", {}).get("name", "Unknown Point")
-            member_name = assignment.get("member", {}).get("name", "Unknown Member")
-            is_special = "Yes" if assignment.get("is_special_case", False) else "No"
-            special_reason = assignment.get("special_case_reason", "") if assignment.get("is_special_case", False) else ""
-
-            if special_reason:
-                member_info = f"{member_name} ({special_reason})"
-            else:
-                member_info = member_name
+            
+            # Create a list of member names for the point
+            assigned_members = assignment.get("members", [])
+            member_names = [member.get("name", "Unknown Member") for member in assigned_members]
+            members_html = "<br>".join(member_names) if member_names else "None"
 
+            is_special = "Yes" if assignment.get("is_special_case", False) else "No"
+            
             html_content += f"""
                 <tr>
                     <td>{point_name}</td>
-                    <td>{member_info}</td>
+                    <td>{members_html}</td>
                     <td>{is_special}</td>
                 </tr>
             """
@@ -176,27 +191,24 @@ def send_rotation_notification(job_id, shift_record):
         subject = f"Guard Rotation - {job_name} (Shift {shift_number})"
 
         for admin_email in ADMIN_EMAILS:
+            logger.info(f"Sending rotation notification to {admin_email}...")
             send_email(admin_email, subject, html_content)
+            # --- RATE LIMIT PREVENTION ---
+            time.sleep(1) # Add a 1-second delay between sending emails
 
     except Exception as e:
         logger.error(f"Error sending rotation notification for job {job_id}: {e}")
 
+
 # === Auth Middleware ===
 def verify_token(req):
-    """
-    Verify Firebase ID token and check if user's email is in ADMIN_EMAILS.
-    Email is expected in the 'X-User-Email' header, sent by the client.
-    Returns decoded token dict if valid admin, None otherwise.
-    """
     auth_header = req.headers.get("Authorization")
-    # NEW: Get email from custom header sent by client
     user_email = req.headers.get("X-User-Email")
 
     if not auth_header:
         print("Authorization header missing.")
         return None
 
-    # NEW: Check if email header is present and valid
     if not user_email:
         logging.info("X-User-Email header missing from request.")
         return None
@@ -206,35 +218,17 @@ def verify_token(req):
          return None
 
     try:
-        # Extract token
         if auth_header.startswith("Bearer "):
             token = auth_header[7:].strip()
         else:
             token = auth_header.strip()
 
-        # Verify the token (ensures token is genuine and user is authenticated)
         decoded = firebase_auth.verify_id_token(token)
-        # Note: We are not checking the UID against the database anymore.
-        # We are trusting the email provided by the client, verified against ADMIN_EMAILS.
-        # The token verification ensures the request is from a logged-in user.
-
         logging.info(f"User with email {user_email} (UID: {decoded.get('uid')}) is authorized as admin (email in ADMIN_EMAILS).")
-        return decoded # Return decoded token if needed by other parts of the app
+        return decoded
 
-    except firebase_auth.InvalidIdTokenError as e:
-        print(f"Invalid Firebase ID token provided: {e}")
-        return None
-    except firebase_auth.ExpiredIdTokenError as e:
-        print(f"Firebase ID token has expired: {e}")
-        return None
-    except firebase_auth.RevokedIdTokenError as e:
-        print(f"Firebase ID token has been revoked: {e}")
-        return None
     except Exception as e:
         print(f"Unexpected error during token verification: {e}")
-        # Consider logging the full traceback in production
-        # import traceback
-        # print(traceback.format_exc())
         return None
 
 # === Admin Setup (Legacy - kept for compatibility) ===
@@ -246,11 +240,12 @@ def setup_admins():
 setup_admins()
 
 # === Core Functions ===
+
+# === REFACTORED FUNCTION (assign_roster) ===
 def assign_roster(job_id):
-    """Assign roster for a job - implements the rotation algorithm"""
+    """Assign roster for a job - implements the multi-guard rotation algorithm"""
     try:
         logger.info(f"Starting roster assignment for job {job_id}")
-        # Get job details
         job_ref = db.reference(f"jobs/{job_id}")
         job_data = job_ref.get()
 
@@ -258,181 +253,82 @@ def assign_roster(job_id):
             logger.error(f"Job {job_id} not found")
             return
 
-        # Check if job is paused
-        if job_data.get("status") == "paused":
-            logger.info(f"Job {job_id} is paused, skipping assignment")
+        if job_data.get("status") != "active":
+            logger.info(f"Job {job_id} is not active (status: {job_data.get('status')}), skipping assignment.")
             return
 
-        # Get guarding points and assigned members
         guarding_points = job_data.get("guarding_points", [])
         assigned_members = job_data.get("assigned_members", [])
-        special_cases = job_data.get("special_cases", [])
-
+        
         if not guarding_points:
             logger.warning(f"No guarding points defined for job {job_id}")
             return
-
         if not assigned_members:
             logger.warning(f"No members assigned to job {job_id}")
             return
 
-        # CRITICAL FIX: Ensure all guarding points have IDs
-        points_updated = False
-        for i, point in enumerate(guarding_points):
-            if "id" not in point or not point["id"]:
-                point["id"] = f"point_{i+1}"
-                points_updated = True
-                logger.warning(f"Point missing ID in job {job_id}, assigned: point_{i+1}")
-
-        # Update database if points were missing IDs
-        if points_updated:
-            job_ref.update({"guarding_points": guarding_points})
-            logger.info(f"Updated guarding points with missing IDs for job {job_id}")
-
-        # CRITICAL FIX: Ensure all assigned members have IDs
-        members_updated = False
-        for i, member in enumerate(assigned_members):
-            if "id" not in member or not member["id"]:
-                member["id"] = f"member_{i+1}_{uuid.uuid4().hex[:6]}"
-                members_updated = True
-                logger.warning(f"Member missing ID in job {job_id}, assigned: {member['id']}")
-
-        # Update database if members were missing IDs
-        if members_updated:
-            job_ref.update({"assigned_members": assigned_members})
-            logger.info(f"Updated assigned members with missing IDs for job {job_id}")
-
-        # Get current assignments and rotation history
-        current_assignments = job_data.get("assignments", [])
-        rotation_history = job_data.get("rotation_history", {})
-
-        # Determine next shift
-        shift_number = len(current_assignments) + 1
-        logger.debug(f"Determined shift number: {shift_number} for job {job_id}")
-
-        # Apply special cases if any match current shift
-        special_assignment = None
-        for case in special_cases:
-            if case.get("shift_number") == shift_number or case.get("active", False):
-                special_assignment = case
-                logger.debug(f"Found matching special case for shift {shift_number}: {case}")
-                break
-
-        # Generate assignments for this shift
+        # --- ALGORITHM REFACTOR ---
+        
+        # 1. Prepare for the new shift
+        shift_number = len(job_data.get("assignments", [])) + 1
         shift_assignments = []
+        
+        # Create a shuffled, available list of members for this specific shift.
+        # This ensures fairness and prevents a guard from being assigned to multiple points in one shift.
+        available_for_shift_members = random.sample(assigned_members, len(assigned_members))
+        
+        total_guards_required = sum(point.get('guards', 1) for point in guarding_points)
+        if len(available_for_shift_members) < total_guards_required:
+            logger.error(f"Not enough members ({len(available_for_shift_members)}) to fill all points ({total_guards_required}) for job {job_id}. Aborting shift creation.")
+            # OPTIONAL: Send an alert email to admins here about guard shortage.
+            return
+
+        logger.info(f"Applying standard rotation for job {job_id}, shift {shift_number}")
 
-        if special_assignment:
-            logger.info(f"Applying special case assignment for job {job_id}, shift {shift_number}")
-            # Apply special case assignment
-            assigned_point = next((p for p in guarding_points if p.get("id") == special_assignment.get("point_id")), None)
-            assigned_member = next((m for m in assigned_members if m.get("id") == special_assignment.get("member_id")), None)
+        # 2. Loop through each point and assign the required number of unique guards
+        for point in guarding_points:
+            guards_for_point = []
+            num_guards_required = point.get('guards', 1) # Get required guards from point data, default to 1
 
-            if assigned_point and assigned_member:
+            # Assign the required number of guards to this point
+            for _ in range(num_guards_required):
+                if not available_for_shift_members:
+                    logger.warning(f"Ran out of available members while assigning to point {point.get('name')}")
+                    break
+                
+                selected_member = available_for_shift_members.pop(0)
+                guards_for_point.append(selected_member)
+
+            if guards_for_point:
                 shift_assignments.append({
-                    "point": assigned_point,
-                    "member": assigned_member,
-                    "is_special_case": True,
-                    "special_case_reason": special_assignment.get("reason", "Special Assignment")
+                    "point": point,
+                    "members": guards_for_point, # Key changed from "member" to "members"
+                    "is_special_case": False
                 })
-            else:
-                logger.warning(f"Special case assignment failed: Point or Member not found for job {job_id}")
-                logger.debug(f"Looking for point_id: {special_assignment.get('point_id')}, member_id: {special_assignment.get('member_id')}")
-        else:
-            logger.info(f"Applying standard rotation algorithm for job {job_id}, shift {shift_number}")
-            # Standard rotation algorithm
-            for point in guarding_points:
-                point_id = point.get("id")
-                if not point_id:
-                    logger.error(f"Point still missing ID after fix attempt: {point}")
-                    continue
-
-                point_history = rotation_history.get(point_id, [])
-
-                # Find member who hasn't been assigned to this point recently
-                available_members = assigned_members.copy()
-
-                # Remove recently assigned members (no immediate repetition)
-                recently_assigned_member_ids = set()
-                lookback_window = min(len(guarding_points), len(assigned_members))
-                for recent_assignment in point_history[-lookback_window:]:
-                    recently_assigned_member_ids.add(recent_assignment.get("member_id"))
-
-                # Filter available members
-                available_members = [m for m in available_members if m.get("id") not in recently_assigned_member_ids]
-
-                # If all members have been recently assigned, use all members
-                if not available_members:
-                    logger.debug(f"All members recently assigned to point {point_id}. Using full member list.")
-                    available_members = assigned_members
-
-                # Select next member (simple round-robin from available)
-                selected_member = None
-                if point_history and available_members:
-                    last_assigned_member_id = point_history[-1].get("member_id")
-                    last_member_index = next((i for i, m in enumerate(available_members) if m.get("id") == last_assigned_member_id), -1)
-                    if last_member_index != -1:
-                        next_member_index = (last_member_index + 1) % len(available_members)
-                    else:
-                        # Last assigned member is not in available list, pick first available
-                        next_member_index = 0
-                    selected_member = available_members[next_member_index]
-                elif available_members:
-                    # No history or last member not in available list, pick first
-                    selected_member = available_members[0]
-                else:
-                    # This shouldn't happen due to the fallback, but log if it does
-                    logger.error(f"No available members for point {point_id} in job {job_id}")
-                    continue
-
-                if selected_member:
-                    # Record assignment
-                    shift_assignments.append({
-                        "point": point,
-                        "member": selected_member,
-                        "is_special_case": False
-                    })
-
-                    # Update rotation history
-                    point_history.append({
-                        "member_id": selected_member.get("id"),
-                        "member_name": selected_member.get("name", "Unknown"),
-                        "assigned_at": datetime.datetime.now().isoformat(),
-                        "shift_number": shift_number
-                    })
-                    rotation_history[point_id] = point_history
-                else:
-                    logger.warning(f"Could not select a member for point {point_id} in job {job_id}")
-
-        # Update rotation history in database only if we have assignments
+        
+        # 3. Update database and send notification
         if shift_assignments:
-            job_ref.update({"rotation_history": rotation_history})
-
-            # Create shift record
             shift_record = {
                 "shift_number": shift_number,
-                "assigned_at": datetime.datetime.now().isoformat(),
+                "assigned_at": datetime.now().isoformat(),
                 "assignments": shift_assignments,
                 "shift_id": str(uuid.uuid4())
             }
 
-            # Add to current assignments
+            current_assignments = job_data.get("assignments", [])
             current_assignments.append(shift_record)
 
-            # Update job with new assignment
             job_ref.update({
                 "assignments": current_assignments,
-                "last_updated": datetime.datetime.now().isoformat()
+                "last_updated": datetime.now().isoformat()
             })
 
-            logger.info(f"Shift {shift_number} assigned for job {job_id} with {len(shift_assignments)} assignments")
-
-            # Send email notification to admins
+            logger.info(f"Shift {shift_number} assigned for job {job_id} with {len(shift_assignments)} point assignments.")
             send_rotation_notification(job_id, shift_record)
 
-            # Schedule next rotation based on job's rotation period
-            rotation_period = job_data.get("rotation_period", 28800)  # Default 8 hours
-            next_run_time = datetime.datetime.now() + datetime.timedelta(seconds=rotation_period)
-
+            rotation_period = job_data.get("rotation_period", 28800)
+            next_run_time = datetime.now() + datetime.timedelta(seconds=rotation_period)
+            
             scheduler.add_job(
                 func=assign_roster,
                 trigger="date",
@@ -440,19 +336,18 @@ def assign_roster(job_id):
                 args=[job_id],
                 id=f"rotate_{job_id}_{uuid.uuid4().hex[:8]}"
             )
-
-            logger.info(f"Scheduled next rotation for job {job_id} in {rotation_period} seconds")
+            logger.info(f"Scheduled next rotation for job {job_id} in {rotation_period} seconds.")
         else:
-            logger.error(f"No assignments created for job {job_id}, shift {shift_number}")
+            logger.error(f"No assignments were created for job {job_id}, shift {shift_number}.")
 
     except Exception as e:
         logger.error(f"Error in assign_roster for job {job_id}: {e}", exc_info=True)
 
+
 def check_and_rotate_guards():
     """Periodic function to check jobs and rotate guards"""
     try:
         logger.debug("🔍 Checking for guard rotations...")
-        # Get all jobs
         jobs_ref = db.reference("jobs")
         jobs = jobs_ref.get()
 
@@ -460,49 +355,36 @@ def check_and_rotate_guards():
             logger.debug("No jobs found")
             return
 
-        # Check each job for rotation needs (for jobs that don't have scheduled rotations)
         for job_id, job_data in jobs.items():
             logger.debug(f"Evaluating job {job_id} for rotation...")
-            # Skip paused jobs
-            if job_data.get("status") == "paused":
-                logger.debug(f"Job {job_id} is paused, skipping.")
+            if job_data.get("status") != "active":
+                logger.debug(f"Job {job_id} is not active, skipping.")
                 continue
 
-            # Skip jobs that have scheduled rotations handled by APScheduler
-            # Note: This logic might need refinement based on how you track scheduled jobs.
-            # if job_data.get("has_scheduled_rotation", False):
-            #     logger.debug(f"Job {job_id} has scheduled rotation, skipping manual check.")
-            #     continue
-
-            # For jobs without scheduled rotations, check manually
             assignments = job_data.get("assignments", [])
-
             if not assignments:
-                # If no assignments yet, this job hasn't started manually
                 logger.debug(f"Job {job_id} has no assignments yet, not started.")
                 continue
-            else:
-                # Check if current assignment is expired
-                last_assignment = assignments[-1]
-                try:
-                    assigned_at = datetime.datetime.fromisoformat(last_assignment["assigned_at"].replace("Z", "+00:00"))
-                except ValueError:
-                    logger.warning(f"Could not parse assigned_at time for job {job_id}: {last_assignment['assigned_at']}")
-                    continue # Skip if time format is unexpected
 
-                now = datetime.datetime.now(assigned_at.tzinfo)
-
-                # Get rotation period from job or default to 8 hours
-                rotation_period = job_data.get("rotation_period", 28800)
+            last_assignment = assignments[-1]
+            try:
+                assigned_at_str = last_assignment.get("assigned_at", "")
+                assigned_at = datetime.fromisoformat(assigned_at_str.replace("Z", "+00:00"))
+            except (ValueError, TypeError):
+                logger.warning(f"Could not parse assigned_at time for job {job_id}: {last_assignment.get('assigned_at')}")
+                continue
 
-                time_since_last_assignment = (now - assigned_at).total_seconds()
-                logger.debug(f"Job {job_id}: Last assignment was {time_since_last_assignment}s ago. Period is {rotation_period}s.")
+            now = datetime.now(assigned_at.tzinfo)
+            rotation_period = job_data.get("rotation_period", 28800)
+            time_since_last_assignment = (now - assigned_at).total_seconds()
+            
+            logger.debug(f"Job {job_id}: Last assignment was {time_since_last_assignment:.0f}s ago. Period is {rotation_period}s.")
 
-                if time_since_last_assignment > rotation_period:
-                    logger.info(f"Rotating guard for job {job_id}")
-                    assign_roster(job_id)
-                else:
-                    logger.debug(f"Job {job_id} not due for rotation yet.")
+            if time_since_last_assignment > rotation_period:
+                logger.info(f"Rotating guards for job {job_id} based on interval check.")
+                assign_roster(job_id)
+            else:
+                logger.debug(f"Job {job_id} not due for rotation yet.")
 
     except Exception as e:
         logger.error(f"Error in check_and_rotate_guards: {e}", exc_info=True)
@@ -513,8 +395,6 @@ def log_request_info():
     """Log incoming request details."""
     logger.info(f"Incoming request: {request.method} {request.url}")
     logger.debug(f"Headers: {dict(request.headers)}")
-    # Be very careful logging request.data or request.json as they might contain sensitive info
-    # logger.debug(f"Body: {request.get_data()}") # Uncomment only for debugging, then remove!
 
 @app.route("/", methods=["GET"])
 def home():
@@ -590,7 +470,6 @@ def update_member(member_id):
     logger.debug(f"Updating member {member_id} with data: {data}")
     member_ref = db.reference(f"members/{member_id}")
 
-    # Check if member exists before updating
     if not member_ref.get():
         logger.warning(f"Attempted to update non-existent member {member_id}")
         return jsonify({"error": "Member not found"}), 404
@@ -614,7 +493,6 @@ def delete_member(member_id):
 
     member_ref = db.reference(f"members/{member_id}")
 
-    # Check if member exists before deleting
     if not member_ref.get():
         logger.warning(f"Attempted to delete non-existent member {member_id}")
         return jsonify({"error": "Member not found"}), 404
@@ -639,27 +517,24 @@ def create_job():
     logger.debug(f"Creating job with data: {data}")
     job_id = str(uuid.uuid4())
 
-    # Validate guarding points (5-15 points)
     guarding_points = data.get("guarding_points", [])
     if len(guarding_points) < 5 or len(guarding_points) > 15:
         logger.warning(f"Invalid number of guarding points ({len(guarding_points)}) for job creation.")
         return jsonify({"error": "Guarding points must be between 5 and 15"}), 400
 
-    # Add IDs to guarding points if not present
     for i, point in enumerate(guarding_points):
         if "id" not in point:
             point["id"] = f"point_{i+1}"
 
-    # Add default fields
     job_data = {
         **data,
         "guarding_points": guarding_points,
-        "created_at": datetime.datetime.now().isoformat(),
-        "status": "created",  # New status: created, active, paused
+        "created_at": datetime.now().isoformat(),
+        "status": "created",
         "assignments": [],
         "rotation_history": {},
-        "rotation_period": data.get("rotation_period", 28800),  # Default 8 hours (28800 seconds)
-        "scheduled_start_time": data.get("scheduled_start_time"),  # ISO format datetime string
+        "rotation_period": data.get("rotation_period", 28800),
+        "scheduled_start_time": data.get("scheduled_start_time"),
         "has_scheduled_rotation": False,
         "special_cases": data.get("special_cases", [])
     }
@@ -687,13 +562,11 @@ def update_job(job_id):
     logger.debug(f"Updating job {job_id} with data: {data}")
     job_ref = db.reference(f"jobs/{job_id}")
 
-    # Check if job exists
     if not job_ref.get():
         logger.warning(f"Attempted to update non-existent job {job_id}")
         return jsonify({"error": "Job not found"}), 404
 
     try:
-        # Prevent overwriting critical, managed fields from a general update endpoint
         data.pop('assignments', None)
         data.pop('rotation_history', None)
         data.pop('status', None)
@@ -707,7 +580,6 @@ def update_job(job_id):
 
 @app.route("/schedule_job/<job_id>", methods=["POST"])
 def schedule_job(job_id):
-    """Schedule a job to start at a specific time"""
     logger.info(f"Handling /schedule_job/{job_id} request")
     user = verify_token(request)
     if not user:
@@ -715,7 +587,7 @@ def schedule_job(job_id):
         return jsonify({"error": "Unauthorized"}), 401
 
     data = request.json
-    start_time_iso = data.get("start_time")  # ISO format datetime string
+    start_time_iso = data.get("start_time")
     logger.debug(f"Scheduling job {job_id} with data: {data}")
 
     if not start_time_iso:
@@ -723,21 +595,17 @@ def schedule_job(job_id):
         return jsonify({"error": "start_time is required (ISO format)"}), 400
 
     job_ref = db.reference(f"jobs/{job_id}")
-    job_data = job_ref.get()
-
-    if not job_data: # Fixed condition
+    if not job_ref.get():
         logger.warning(f"Job {job_id} not found for scheduling.")
         return jsonify({"error": "Job not found"}), 404
 
-    # Parse the start time
     try:
-        start_time = datetime.datetime.fromisoformat(start_time_iso.replace("Z", "+00:00"))
+        start_time = datetime.fromisoformat(start_time_iso.replace("Z", "+00:00"))
         logger.debug(f"Parsed start time: {start_time}")
     except ValueError:
         logger.error(f"Invalid start_time format provided: {start_time_iso}")
-        return jsonify({"error": "Invalid start_time format. Use ISO format (e.g., 2023-12-01T10:00:00)"}), 400
+        return jsonify({"error": "Invalid start_time format."}), 400
 
-    # Update job with scheduled start time
     try:
         job_ref.update({
             "scheduled_start_time": start_time_iso,
@@ -748,7 +616,6 @@ def schedule_job(job_id):
         logger.error(f"Error updating job {job_id} for scheduling: {e}", exc_info=True)
         return jsonify({"error": "Internal server error"}), 500
 
-    # Schedule the job to start at the specified time
     try:
         scheduler.add_job(
             func=start_scheduled_job,
@@ -761,7 +628,6 @@ def schedule_job(job_id):
         return jsonify({"message": f"Job {job_id} scheduled to start at {start_time_iso}"}), 200
     except Exception as e:
         logger.error(f"Error scheduling start job for {job_id}: {e}", exc_info=True)
-        # Consider rolling back the status update if scheduling fails
         return jsonify({"error": "Failed to schedule job start"}), 500
 
 def start_scheduled_job(job_id):
@@ -769,20 +635,16 @@ def start_scheduled_job(job_id):
     try:
         logger.info(f"Executing scheduled start for job {job_id}")
         job_ref = db.reference(f"jobs/{job_id}")
-        job_data = job_ref.get()
-
-        if not job_data: # Fixed condition
+        if not job_ref.get():
             logger.error(f"Job {job_id} not found for scheduled start")
             return
 
-        # Update job status to active
         job_ref.update({
             "status": "active",
-            "started_at": datetime.datetime.now().isoformat()
+            "started_at": datetime.now().isoformat()
         })
         logger.info(f"Job {job_id} status updated to active.")
 
-        # Start first assignment
         assign_roster(job_id)
         logger.info(f"Job {job_id} started via schedule")
 
@@ -798,29 +660,25 @@ def start_job(job_id):
         return jsonify({"error": "Unauthorized"}), 401
 
     job_ref = db.reference(f"jobs/{job_id}")
-    job_data = job_ref.get()
-
-    if not job_data: # Fixed condition
+    if not job_ref.get():
         logger.warning(f"Job {job_id} not found for starting.")
         return jsonify({"error": "Job not found"}), 404
 
-    # Update job status to active
     try:
         job_ref.update({
             "status": "active",
-            "started_at": datetime.datetime.now().isoformat()
+            "started_at": datetime.now().isoformat()
         })
         logger.info(f"Job {job_id} status updated to active.")
     except Exception as e:
         logger.error(f"Error updating job {job_id} to active: {e}", exc_info=True)
         return jsonify({"error": "Internal server error"}), 500
 
-    # Schedule the first assignment immediately
     try:
         scheduler.add_job(
             func=assign_roster,
             trigger="date",
-            run_date=datetime.datetime.now() + datetime.timedelta(seconds=5),
+            run_date=datetime.now() + datetime.timedelta(seconds=5),
             args=[job_id],
             id=f"start_{job_id}_{uuid.uuid4().hex[:8]}"
         )
@@ -828,7 +686,6 @@ def start_job(job_id):
         return jsonify({"message": f"Job {job_id} started"}), 202
     except Exception as e:
         logger.error(f"Error scheduling first assignment for job {job_id}: {e}", exc_info=True)
-        # Consider rolling back the status update if scheduling fails
         return jsonify({"error": "Failed to start job assignments"}), 500
 
 @app.route("/pause_job/<job_id>", methods=["POST"])
@@ -840,9 +697,7 @@ def pause_job(job_id):
         return jsonify({"error": "Unauthorized"}), 401
 
     job_ref = db.reference(f"jobs/{job_id}")
-    job_data = job_ref.get()
-
-    if not job_data: # Fixed condition
+    if not job_ref.get():
         logger.warning(f"Job {job_id} not found for pausing.")
         return jsonify({"error": "Job not found"}), 404
 
@@ -863,9 +718,7 @@ def delete_job(job_id):
         return jsonify({"error": "Unauthorized"}), 401
 
     job_ref = db.reference(f"jobs/{job_id}")
-    job_data = job_ref.get()
-
-    if not job_data: # Fixed condition
+    if not job_ref.get():
         logger.warning(f"Job {job_id} not found for deletion.")
         return jsonify({"error": "Job not found"}), 404
 
@@ -893,7 +746,6 @@ def get_jobs():
             logger.debug("No jobs found in database.")
             return jsonify({"jobs": []}), 200
 
-        # Convert to list format
         jobs_list = []
         for job_id, job_data in jobs.items():
             job_data["id"] = job_id
@@ -917,7 +769,7 @@ def get_job(job_id):
         job_ref = db.reference(f"jobs/{job_id}")
         job_data = job_ref.get()
 
-        if not job_data: # Fixed condition
+        if not job_data:
             logger.warning(f"Job {job_id} not found.")
             return jsonify({"error": "Job not found"}), 404
 
@@ -944,7 +796,6 @@ def get_members():
             logger.debug("No members found in database.")
             return jsonify({"members": []}), 200
 
-        # Convert to list format
         members_list = []
         for member_id, member_data in members.items():
             member_data["id"] = member_id
@@ -958,7 +809,6 @@ def get_members():
 
 @app.route("/assign_members_to_job", methods=["POST"])
 def assign_members_to_job():
-    """Bulk assign members to a job"""
     logger.info("Handling /assign_members_to_job request")
     user = verify_token(request)
     if not user:
@@ -975,13 +825,10 @@ def assign_members_to_job():
         return jsonify({"error": "job_id and member_ids are required"}), 400
 
     job_ref = db.reference(f"jobs/{job_id}")
-    job_data = job_ref.get()
-
-    if not job_data: # Fixed condition
+    if not job_ref.get():
         logger.warning(f"Job {job_id} not found for member assignment.")
         return jsonify({"error": "Job not found"}), 404
 
-    # Get members
     try:
         members_ref = db.reference("members")
         all_members = members_ref.get()
@@ -993,7 +840,6 @@ def assign_members_to_job():
         logger.warning("No members found in database for assignment.")
         return jsonify({"error": "No members found"}), 404
 
-    # Filter requested members (ensure at least 25)
     selected_members = []
     for member_id in member_ids:
         if member_id in all_members:
@@ -1005,7 +851,6 @@ def assign_members_to_job():
         logger.warning(f"Insufficient members ({len(selected_members)}) assigned to job {job_id}. Minimum is 25.")
         return jsonify({"error": "At least 25 members must be assigned to the job"}), 400
 
-    # Update job with assigned members
     try:
         job_ref.update({"assigned_members": selected_members})
         logger.info(f"{len(selected_members)} members assigned to job {job_id}.")
@@ -1019,7 +864,6 @@ def assign_members_to_job():
 
 @app.route("/update_job_settings/<job_id>", methods=["POST"])
 def update_job_settings(job_id):
-    """Update job settings including rotation period"""
     logger.info(f"Handling /update_job_settings/{job_id} request")
     user = verify_token(request)
     if not user:
@@ -1027,7 +871,7 @@ def update_job_settings(job_id):
         return jsonify({"error": "Unauthorized"}), 401
 
     data = request.json
-    rotation_period = data.get("rotation_period")  # In seconds
+    rotation_period = data.get("rotation_period")
     logger.debug(f"Updating settings for job {job_id} with data: {data}")
 
     if rotation_period is None:
@@ -1035,13 +879,10 @@ def update_job_settings(job_id):
         return jsonify({"error": "rotation_period is required (in seconds)"}), 400
 
     job_ref = db.reference(f"jobs/{job_id}")
-    job_data = job_ref.get()
-
-    if not job_data: # Fixed condition
+    if not job_ref.get():
         logger.warning(f"Job {job_id} not found for settings update.")
         return jsonify({"error": "Job not found"}), 404
 
-    # Update rotation period
     try:
         job_ref.update({"rotation_period": rotation_period})
         logger.info(f"Job {job_id} rotation period updated to {rotation_period} seconds.")
@@ -1055,7 +896,6 @@ def update_job_settings(job_id):
 
 @app.route("/add_special_case/<job_id>", methods=["POST"])
 def add_special_case(job_id):
-    """Add a special case assignment for a job"""
     logger.info(f"Handling /add_special_case/{job_id} request")
     user = verify_token(request)
     if not user:
@@ -1077,11 +917,10 @@ def add_special_case(job_id):
     job_ref = db.reference(f"jobs/{job_id}")
     job_data = job_ref.get()
 
-    if not job_data: # Fixed condition
+    if not job_data:
         logger.warning(f"Job {job_id} not found for special case addition.")
         return jsonify({"error": "Job not found"}), 404
 
-    # Verify point and member exist
     guarding_points = job_data.get("guarding_points", [])
     assigned_members = job_data.get("assigned_members", [])
 
@@ -1095,7 +934,6 @@ def add_special_case(job_id):
         logger.warning(f"Member {member_id} not assigned to job {job_id}.")
         return jsonify({"error": "Member not assigned to job"}), 404
 
-    # Add special case
     special_case = {
         "id": str(uuid.uuid4()),
         "point_id": point_id,
@@ -1103,7 +941,7 @@ def add_special_case(job_id):
         "reason": reason,
         "shift_number": shift_number,
         "active": active,
-        "created_at": datetime.datetime.now().isoformat()
+        "created_at": datetime.now().isoformat()
     }
 
     special_cases = job_data.get("special_cases", [])
@@ -1122,7 +960,6 @@ def add_special_case(job_id):
 
 @app.route("/get_roster/<job_id>", methods=["GET"])
 def get_roster(job_id):
-    """Get formatted roster for a job"""
     logger.info(f"Handling /get_roster/{job_id} request")
     user = verify_token(request)
     if not user:
@@ -1133,26 +970,24 @@ def get_roster(job_id):
         job_ref = db.reference(f"jobs/{job_id}")
         job_data = job_ref.get()
 
-        if not job_data: # Fixed condition
+        if not job_data:
             logger.warning(f"Job {job_id} not found for roster retrieval.")
             return jsonify({"error": "Job not found"}), 404
 
         assignments = job_data.get("assignments", [])
-
-        # Format roster as table data
         roster_data = []
         for shift in assignments:
             shift_number = shift["shift_number"]
             assigned_at = shift["assigned_at"]
 
-            for assignment in shift["assignments"]:
+            for assignment in shift.get("assignments", []):
+                member_names = [m.get("name", "Unknown") for m in assignment.get("members", [])]
                 roster_data.append({
                     "shift_number": shift_number,
                     "assigned_at": assigned_at,
-                    "point_name": assignment["point"]["name"],
-                    "member_name": assignment["member"].get("name", "Unknown"),
+                    "point_name": assignment.get("point", {}).get("name", "Unknown"),
+                    "member_names": ", ".join(member_names), # Join names for display
                     "is_special_case": assignment.get("is_special_case", False),
-                    "special_case_reason": assignment.get("special_case_reason", "")
                 })
 
         logger.debug(f"Retrieved roster for job {job_id} with {len(roster_data)} entries.")
@@ -1166,13 +1001,14 @@ def get_roster(job_id):
         return jsonify({"error": "Internal server error"}), 500
 
 # === Schedule periodic guard rotation ===
-# Run every 5 minutes to check for rotations
 try:
+    # This job checks for any rotations that might have been missed if the server restarted
     scheduler.add_job(
         func=check_and_rotate_guards,
         trigger="interval",
         minutes=5,
-        id="guard_rotation_job"
+        id="guard_rotation_check_job",
+        replace_existing=True
     )
     logger.info("Scheduled periodic guard rotation check job.")
 except Exception as e: