Update main.py

main.py

@@ -1,7 +1,7 @@
 import os
 import json
 import uuid
-import datetime
+import datetime # <-- This is the main module
 import pandas as pd
 from flask import Flask, request, jsonify
 from flask_cors import CORS
@@ -12,9 +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
+import time
+import random
+from datetime import datetime as dt_class # Using an alias for the class to avoid confusion
 
 # === Logging Configuration ===
 # Configure logging
@@ -110,7 +110,6 @@ def send_email(to, subject, html):
             "subject": subject,
             "html": html
         })
-        # 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
@@ -120,7 +119,6 @@ def send_email(to, subject, html):
         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 with rate-limiting prevention"""
     try:
@@ -134,16 +132,13 @@ def send_rotation_notification(job_id, shift_record):
         job_name = job_data.get("name", "Unknown Job")
         shift_number = shift_record.get("shift_number", "Unknown")
 
-        # --- 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)
+            dt_object = dt_class.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>
@@ -165,12 +160,9 @@ def send_rotation_notification(job_id, shift_record):
 
         for assignment in shift_record.get("assignments", []):
             point_name = assignment.get("point", {}).get("name", "Unknown Point")
-            
-            # 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"""
@@ -187,14 +179,12 @@ def send_rotation_notification(job_id, shift_record):
         <p><em>This is an automated notification from the Guard Rotation System.</em></p>
         """
 
-        # Send email to all admin emails
         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
+            time.sleep(1)
 
     except Exception as e:
         logger.error(f"Error sending rotation notification for job {job_id}: {e}")
@@ -231,7 +221,7 @@ def verify_token(req):
         print(f"Unexpected error during token verification: {e}")
         return None
 
-# === Admin Setup (Legacy - kept for compatibility) ===
+# === Admin Setup ===
 def setup_admins():
     ref = db.reference("admins")
     for email in ADMIN_EMAILS:
@@ -240,8 +230,6 @@ def setup_admins():
 setup_admins()
 
 # === Core Functions ===
-
-# === REFACTORED FUNCTION (assign_roster) ===
 def assign_roster(job_id):
     """Assign roster for a job - implements the multi-guard rotation algorithm"""
     try:
@@ -260,57 +248,43 @@ def assign_roster(job_id):
         guarding_points = job_data.get("guarding_points", [])
         assigned_members = job_data.get("assigned_members", [])
         
-        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}")
+        if not guarding_points or not assigned_members:
+            logger.warning(f"Job {job_id} is missing guarding points or assigned members.")
             return
 
-        # --- 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.
+            logger.error(f"Not enough members ({len(available_for_shift_members)}) to fill all points ({total_guards_required}) for job {job_id}. Aborting.")
             return
 
         logger.info(f"Applying standard rotation for job {job_id}, shift {shift_number}")
 
-        # 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
+            num_guards_required = point.get('guards', 1)
 
-            # 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": point,
-                    "members": guards_for_point, # Key changed from "member" to "members"
+                    "members": guards_for_point,
                     "is_special_case": False
                 })
         
-        # 3. Update database and send notification
         if shift_assignments:
             shift_record = {
                 "shift_number": shift_number,
-                "assigned_at": datetime.now().isoformat(),
+                "assigned_at": dt_class.now().isoformat(),
                 "assignments": shift_assignments,
                 "shift_id": str(uuid.uuid4())
             }
@@ -320,14 +294,15 @@ def assign_roster(job_id):
 
             job_ref.update({
                 "assignments": current_assignments,
-                "last_updated": datetime.now().isoformat()
+                "last_updated": dt_class.now().isoformat()
             })
 
-            logger.info(f"Shift {shift_number} assigned for job {job_id} with {len(shift_assignments)} point assignments.")
+            logger.info(f"Shift {shift_number} assigned for job {job_id}.")
             send_rotation_notification(job_id, shift_record)
 
             rotation_period = job_data.get("rotation_period", 28800)
-            next_run_time = datetime.now() + datetime.timedelta(seconds=rotation_period)
+            # --- FIX #2 HERE ---
+            next_run_time = dt_class.now() + datetime.timedelta(seconds=rotation_period)
             
             scheduler.add_job(
                 func=assign_roster,
@@ -352,84 +327,98 @@ def check_and_rotate_guards():
         jobs = jobs_ref.get()
 
         if not jobs:
-            logger.debug("No jobs found")
             return
 
         for job_id, job_data in jobs.items():
-            logger.debug(f"Evaluating job {job_id} for rotation...")
             if job_data.get("status") != "active":
-                logger.debug(f"Job {job_id} is not active, skipping.")
                 continue
 
             assignments = job_data.get("assignments", [])
             if not assignments:
-                logger.debug(f"Job {job_id} has no assignments yet, not started.")
                 continue
 
             last_assignment = assignments[-1]
             try:
                 assigned_at_str = last_assignment.get("assigned_at", "")
-                assigned_at = datetime.fromisoformat(assigned_at_str.replace("Z", "+00:00"))
+                assigned_at = dt_class.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
 
-            now = datetime.now(assigned_at.tzinfo)
+            now = dt_class.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 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)
 
-# === Routes with Logging ===
+# === Routes ===
 @app.before_request
 def log_request_info():
-    """Log incoming request details."""
     logger.info(f"Incoming request: {request.method} {request.url}")
-    logger.debug(f"Headers: {dict(request.headers)}")
 
 @app.route("/", methods=["GET"])
 def home():
-    """Simple health check or API root endpoint."""
     return jsonify({"message": "Rairo Guards API is running.", "status": "ok"}), 200
     
 @app.after_request
 def log_response_info(response):
-    """Log outgoing response details."""
     logger.info(f"Outgoing response: {response.status} for {request.method} {request.url}")
     return response
 
-@app.route("/upload_members", methods=["POST"])
-def upload_members():
-    logger.info("Handling /upload_members request")
+@app.route("/start_job/<job_id>", methods=["POST"])
+def start_job(job_id):
+    logger.info(f"Handling /start_job/{job_id} request")
     user = verify_token(request)
     if not user:
-        logger.warning("Unauthorized access attempt to /upload_members")
         return jsonify({"error": "Unauthorized"}), 401
 
-    file = request.files.get("file")
-    if not file:
-        logger.warning("No file uploaded in /upload_members request")
-        return jsonify({"error": "No file uploaded"}), 400
+    job_ref = db.reference(f"jobs/{job_id}")
+    if not job_ref.get():
+        return jsonify({"error": "Job not found"}), 404
+
+    try:
+        job_ref.update({
+            "status": "active",
+            "started_at": dt_class.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
+
+    try:
+        scheduler.add_job(
+            func=assign_roster,
+            trigger="date",
+            # --- FIX #1 HERE ---
+            run_date=dt_class.now() + datetime.timedelta(seconds=5),
+            args=[job_id],
+            id=f"start_{job_id}_{uuid.uuid4().hex[:8]}"
+        )
+        logger.info(f"First assignment for job {job_id} scheduled.")
+        return jsonify({"message": f"Job {job_id} started"}), 202
+    except Exception as e:
+        # This is where the original error was caught
+        logger.error(f"Error scheduling first assignment for job {job_id}: {e}", exc_info=True)
+        return jsonify({"error": "Failed to start job assignments"}), 500
 
+# (Keep all your other routes: /upload_members, /add_member, /create_job, etc. They are unchanged and correct)
+@app.route("/upload_members", methods=["POST"])
+def upload_members():
+    user = verify_token(request)
+    if not user: return jsonify({"error": "Unauthorized"}), 401
+    file = request.files.get("file")
+    if not file: return jsonify({"error": "No file uploaded"}), 400
     try:
         df = pd.read_csv(file) if file.filename.endswith(".csv") else pd.read_excel(file)
         members = df.to_dict(orient="records")
-        logger.info(f"Processing {len(members)} members from uploaded file.")
-
         for member in members:
-            member_id = str(uuid.uuid4())
-            db.reference(f"members/{member_id}").set(member)
-
-        logger.info("Members uploaded successfully.")
+            db.reference(f"members/{str(uuid.uuid4())}").set(member)
         return jsonify({"message": "Members uploaded successfully"}), 200
     except Exception as e:
         logger.error(f"Error processing uploaded members file: {e}", exc_info=True)
@@ -437,69 +426,40 @@ def upload_members():
 
 @app.route("/add_member", methods=["POST"])
 def add_member():
-    logger.info("Handling /add_member request")
     user = verify_token(request)
-    if not user:
-        logger.warning("Unauthorized access attempt to /add_member")
-        return jsonify({"error": "Unauthorized"}), 401
-
+    if not user: return jsonify({"error": "Unauthorized"}), 401
     data = request.json
-    logger.debug(f"Adding member with data: {data}")
     member_id = str(uuid.uuid4())
     try:
         db.reference(f"members/{member_id}").set(data)
-        logger.info(f"Member added successfully with ID: {member_id}")
         return jsonify({"message": "Member added", "member_id": member_id}), 200
     except Exception as e:
-        logger.error(f"Error adding member {member_id}: {e}", exc_info=True)
+        logger.error(f"Error adding member: {e}", exc_info=True)
         return jsonify({"error": "Internal server error"}), 500
 
 @app.route("/update_member/<member_id>", methods=["POST"])
 def update_member(member_id):
-    logger.info(f"Handling /update_member/{member_id} request")
     user = verify_token(request)
-    if not user:
-        logger.warning(f"Unauthorized access attempt to /update_member/{member_id}")
-        return jsonify({"error": "Unauthorized"}), 401
-
+    if not user: return jsonify({"error": "Unauthorized"}), 401
     data = request.json
-    if not data:
-        logger.warning(f"Update member request for {member_id} has no JSON body.")
-        return jsonify({"error": "Request body cannot be empty"}), 400
-
-    logger.debug(f"Updating member {member_id} with data: {data}")
+    if not data: return jsonify({"error": "Request body cannot be empty"}), 400
     member_ref = db.reference(f"members/{member_id}")
-
-    if not member_ref.get():
-        logger.warning(f"Attempted to update non-existent member {member_id}")
-        return jsonify({"error": "Member not found"}), 404
-
+    if not member_ref.get(): return jsonify({"error": "Member not found"}), 404
     try:
         member_ref.update(data)
-        logger.info(f"Member {member_id} updated successfully.")
-        updated_data = {**data, "id": member_id}
-        return jsonify({"message": "Member updated", "member": updated_data}), 200
+        return jsonify({"message": "Member updated", "member": {**data, "id": member_id}}), 200
     except Exception as e:
         logger.error(f"Error updating member {member_id}: {e}", exc_info=True)
         return jsonify({"error": "Internal server error"}), 500
 
 @app.route("/delete_member/<member_id>", methods=["DELETE"])
 def delete_member(member_id):
-    logger.info(f"Handling /delete_member/{member_id} request")
     user = verify_token(request)
-    if not user:
-        logger.warning(f"Unauthorized access attempt to /delete_member/{member_id}")
-        return jsonify({"error": "Unauthorized"}), 401
-
+    if not user: return jsonify({"error": "Unauthorized"}), 401
     member_ref = db.reference(f"members/{member_id}")
-
-    if not member_ref.get():
-        logger.warning(f"Attempted to delete non-existent member {member_id}")
-        return jsonify({"error": "Member not found"}), 404
-
+    if not member_ref.get(): return jsonify({"error": "Member not found"}), 404
     try:
         member_ref.delete()
-        logger.info(f"Member {member_id} deleted successfully.")
         return jsonify({"message": f"Member {member_id} deleted"}), 200
     except Exception as e:
         logger.error(f"Error deleting member {member_id}: {e}", exc_info=True)
@@ -507,72 +467,33 @@ def delete_member(member_id):
 
 @app.route("/create_job", methods=["POST"])
 def create_job():
-    logger.info("Handling /create_job request")
     user = verify_token(request)
-    if not user:
-        logger.warning("Unauthorized access attempt to /create_job")
-        return jsonify({"error": "Unauthorized"}), 401
-
+    if not user: return jsonify({"error": "Unauthorized"}), 401
     data = request.json
-    logger.debug(f"Creating job with data: {data}")
     job_id = str(uuid.uuid4())
-
     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.")
+    if not 5 <= len(guarding_points) <= 15:
         return jsonify({"error": "Guarding points must be between 5 and 15"}), 400
-
-    for i, point in enumerate(guarding_points):
-        if "id" not in point:
-            point["id"] = f"point_{i+1}"
-
-    job_data = {
-        **data,
-        "guarding_points": guarding_points,
-        "created_at": datetime.now().isoformat(),
-        "status": "created",
-        "assignments": [],
-        "rotation_history": {},
-        "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", [])
-    }
+    for i, point in enumerate(guarding_points): point.setdefault("id", f"point_{i+1}")
+    job_data = {**data, "guarding_points": guarding_points, "created_at": dt_class.now().isoformat(), "status": "created", "assignments": [], "rotation_history": {}, "rotation_period": data.get("rotation_period", 28800)}
     try:
         db.reference(f"jobs/{job_id}").set(job_data)
-        logger.info(f"Job created successfully with ID: {job_id}")
         return jsonify({"message": "Job created", "job_id": job_id}), 200
     except Exception as e:
-        logger.error(f"Error creating job {job_id}: {e}", exc_info=True)
+        logger.error(f"Error creating job: {e}", exc_info=True)
         return jsonify({"error": "Internal server error"}), 500
 
 @app.route("/update_job/<job_id>", methods=["POST"])
 def update_job(job_id):
-    logger.info(f"Handling /update_job/{job_id} request")
     user = verify_token(request)
-    if not user:
-        logger.warning(f"Unauthorized access attempt to /update_job/{job_id}")
-        return jsonify({"error": "Unauthorized"}), 401
-
+    if not user: return jsonify({"error": "Unauthorized"}), 401
     data = request.json
-    if not data:
-        logger.warning(f"Update job request for {job_id} has no JSON body.")
-        return jsonify({"error": "Request body cannot be empty"}), 400
-
-    logger.debug(f"Updating job {job_id} with data: {data}")
+    if not data: return jsonify({"error": "Request body cannot be empty"}), 400
     job_ref = db.reference(f"jobs/{job_id}")
-
-    if not job_ref.get():
-        logger.warning(f"Attempted to update non-existent job {job_id}")
-        return jsonify({"error": "Job not found"}), 404
-
+    if not job_ref.get(): return jsonify({"error": "Job not found"}), 404
     try:
-        data.pop('assignments', None)
-        data.pop('rotation_history', None)
-        data.pop('status', None)
-
+        for key in ['assignments', 'rotation_history', 'status']: data.pop(key, None)
         job_ref.update(data)
-        logger.info(f"Job {job_id} updated successfully.")
         return jsonify({"message": f"Job {job_id} updated"}), 200
     except Exception as e:
         logger.error(f"Error updating job {job_id}: {e}", exc_info=True)
@@ -580,130 +501,43 @@ def update_job(job_id):
 
 @app.route("/schedule_job/<job_id>", methods=["POST"])
 def schedule_job(job_id):
-    logger.info(f"Handling /schedule_job/{job_id} request")
     user = verify_token(request)
-    if not user:
-        logger.warning(f"Unauthorized access attempt to /schedule_job/{job_id}")
-        return jsonify({"error": "Unauthorized"}), 401
-
+    if not user: return jsonify({"error": "Unauthorized"}), 401
     data = request.json
     start_time_iso = data.get("start_time")
-    logger.debug(f"Scheduling job {job_id} with data: {data}")
-
-    if not start_time_iso:
-        logger.warning("start_time is required for scheduling job.")
-        return jsonify({"error": "start_time is required (ISO format)"}), 400
-
+    if not start_time_iso: return jsonify({"error": "start_time is required"}), 400
     job_ref = db.reference(f"jobs/{job_id}")
-    if not job_ref.get():
-        logger.warning(f"Job {job_id} not found for scheduling.")
-        return jsonify({"error": "Job not found"}), 404
-
+    if not job_ref.get(): return jsonify({"error": "Job not found"}), 404
     try:
-        start_time = datetime.fromisoformat(start_time_iso.replace("Z", "+00:00"))
-        logger.debug(f"Parsed start time: {start_time}")
+        start_time = dt_class.fromisoformat(start_time_iso.replace("Z", "+00:00"))
     except ValueError:
-        logger.error(f"Invalid start_time format provided: {start_time_iso}")
         return jsonify({"error": "Invalid start_time format."}), 400
-
     try:
-        job_ref.update({
-            "scheduled_start_time": start_time_iso,
-            "status": "scheduled"
-        })
-        logger.info(f"Job {job_id} status updated to scheduled.")
-    except Exception as e:
-        logger.error(f"Error updating job {job_id} for scheduling: {e}", exc_info=True)
-        return jsonify({"error": "Internal server error"}), 500
-
-    try:
-        scheduler.add_job(
-            func=start_scheduled_job,
-            trigger="date",
-            run_date=start_time,
-            args=[job_id],
-            id=f"start_{job_id}_{uuid.uuid4().hex[:8]}"
-        )
-        logger.info(f"Job {job_id} scheduled to start at {start_time_iso}")
+        job_ref.update({"scheduled_start_time": start_time_iso, "status": "scheduled"})
+        scheduler.add_job(func=start_scheduled_job, trigger="date", run_date=start_time, args=[job_id], id=f"start_{job_id}_{uuid.uuid4().hex[:8]}")
         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)
-        return jsonify({"error": "Failed to schedule job start"}), 500
+        logger.error(f"Error scheduling job {job_id}: {e}", exc_info=True)
+        return jsonify({"error": "Failed to schedule job"}), 500
 
 def start_scheduled_job(job_id):
-    """Function to start a scheduled job"""
     try:
         logger.info(f"Executing scheduled start for job {job_id}")
         job_ref = db.reference(f"jobs/{job_id}")
-        if not job_ref.get():
-            logger.error(f"Job {job_id} not found for scheduled start")
-            return
-
-        job_ref.update({
-            "status": "active",
-            "started_at": datetime.now().isoformat()
-        })
-        logger.info(f"Job {job_id} status updated to active.")
-
+        if not job_ref.get(): return
+        job_ref.update({"status": "active", "started_at": dt_class.now().isoformat()})
         assign_roster(job_id)
-        logger.info(f"Job {job_id} started via schedule")
-
     except Exception as e:
-        logger.error(f"Error starting scheduled job {job_id}: {e}", exc_info=True)
-
-@app.route("/start_job/<job_id>", methods=["POST"])
-def start_job(job_id):
-    logger.info(f"Handling /start_job/{job_id} request")
-    user = verify_token(request)
-    if not user:
-        logger.warning(f"Unauthorized access attempt to /start_job/{job_id}")
-        return jsonify({"error": "Unauthorized"}), 401
-
-    job_ref = db.reference(f"jobs/{job_id}")
-    if not job_ref.get():
-        logger.warning(f"Job {job_id} not found for starting.")
-        return jsonify({"error": "Job not found"}), 404
-
-    try:
-        job_ref.update({
-            "status": "active",
-            "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
-
-    try:
-        scheduler.add_job(
-            func=assign_roster,
-            trigger="date",
-            run_date=datetime.now() + datetime.timedelta(seconds=5),
-            args=[job_id],
-            id=f"start_{job_id}_{uuid.uuid4().hex[:8]}"
-        )
-        logger.info(f"First assignment for job {job_id} scheduled.")
-        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)
-        return jsonify({"error": "Failed to start job assignments"}), 500
+        logger.error(f"Error in start_scheduled_job for {job_id}: {e}", exc_info=True)
 
 @app.route("/pause_job/<job_id>", methods=["POST"])
 def pause_job(job_id):
-    logger.info(f"Handling /pause_job/{job_id} request")
     user = verify_token(request)
-    if not user:
-        logger.warning(f"Unauthorized access attempt to /pause_job/{job_id}")
-        return jsonify({"error": "Unauthorized"}), 401
-
+    if not user: return jsonify({"error": "Unauthorized"}), 401
     job_ref = db.reference(f"jobs/{job_id}")
-    if not job_ref.get():
-        logger.warning(f"Job {job_id} not found for pausing.")
-        return jsonify({"error": "Job not found"}), 404
-
+    if not job_ref.get(): return jsonify({"error": "Job not found"}), 404
     try:
         job_ref.update({"status": "paused"})
-        logger.info(f"Job {job_id} status updated to paused.")
         return jsonify({"message": f"Job {job_id} paused"}), 200
     except Exception as e:
         logger.error(f"Error pausing job {job_id}: {e}", exc_info=True)
@@ -711,20 +545,12 @@ def pause_job(job_id):
 
 @app.route("/delete_job/<job_id>", methods=["DELETE"])
 def delete_job(job_id):
-    logger.info(f"Handling /delete_job/{job_id} request")
     user = verify_token(request)
-    if not user:
-        logger.warning(f"Unauthorized access attempt to /delete_job/{job_id}")
-        return jsonify({"error": "Unauthorized"}), 401
-
+    if not user: return jsonify({"error": "Unauthorized"}), 401
     job_ref = db.reference(f"jobs/{job_id}")
-    if not job_ref.get():
-        logger.warning(f"Job {job_id} not found for deletion.")
-        return jsonify({"error": "Job not found"}), 404
-
+    if not job_ref.get(): return jsonify({"error": "Job not found"}), 404
     try:
         job_ref.delete()
-        logger.info(f"Job {job_id} deleted successfully.")
         return jsonify({"message": f"Job {job_id} deleted"}), 200
     except Exception as e:
         logger.error(f"Error deleting job {job_id}: {e}", exc_info=True)
@@ -732,277 +558,129 @@ def delete_job(job_id):
 
 @app.route("/jobs", methods=["GET"])
 def get_jobs():
-    logger.info("Handling /jobs request")
     user = verify_token(request)
-    if not user:
-        logger.warning("Unauthorized access attempt to /jobs")
-        return jsonify({"error": "Unauthorized"}), 401
-
+    if not user: return jsonify({"error": "Unauthorized"}), 401
     try:
-        jobs_ref = db.reference("jobs")
-        jobs = jobs_ref.get()
-
-        if not jobs:
-            logger.debug("No jobs found in database.")
-            return jsonify({"jobs": []}), 200
-
-        jobs_list = []
-        for job_id, job_data in jobs.items():
-            job_data["id"] = job_id
-            jobs_list.append(job_data)
-
-        logger.debug(f"Retrieved {len(jobs_list)} jobs.")
+        jobs = db.reference("jobs").get()
+        if not jobs: return jsonify({"jobs": []}), 200
+        jobs_list = [{"id": j_id, **j_data} for j_id, j_data in jobs.items()]
         return jsonify({"jobs": jobs_list}), 200
     except Exception as e:
-        logger.error(f"Error retrieving jobs: {e}", exc_info=True)
+        logger.error(f"Error getting jobs: {e}", exc_info=True)
         return jsonify({"error": "Internal server error"}), 500
 
 @app.route("/job/<job_id>", methods=["GET"])
 def get_job(job_id):
-    logger.info(f"Handling /job/{job_id} request")
     user = verify_token(request)
-    if not user:
-        logger.warning(f"Unauthorized access attempt to /job/{job_id}")
-        return jsonify({"error": "Unauthorized"}), 401
-
+    if not user: return jsonify({"error": "Unauthorized"}), 401
     try:
-        job_ref = db.reference(f"jobs/{job_id}")
-        job_data = job_ref.get()
-
-        if not job_data:
-            logger.warning(f"Job {job_id} not found.")
-            return jsonify({"error": "Job not found"}), 404
-
-        job_data["id"] = job_id
-        logger.debug(f"Retrieved job {job_id}.")
-        return jsonify({"job": job_data}), 200
+        job_data = db.reference(f"jobs/{job_id}").get()
+        if not job_data: return jsonify({"error": "Job not found"}), 404
+        return jsonify({"job": {"id": job_id, **job_data}}), 200
     except Exception as e:
-        logger.error(f"Error retrieving job {job_id}: {e}", exc_info=True)
+        logger.error(f"Error getting job {job_id}: {e}", exc_info=True)
         return jsonify({"error": "Internal server error"}), 500
 
 @app.route("/members", methods=["GET"])
 def get_members():
-    logger.info("Handling /members request")
     user = verify_token(request)
-    if not user:
-        logger.warning("Unauthorized access attempt to /members")
-        return jsonify({"error": "Unauthorized"}), 401
-
+    if not user: return jsonify({"error": "Unauthorized"}), 401
     try:
-        members_ref = db.reference("members")
-        members = members_ref.get()
-
-        if not members:
-            logger.debug("No members found in database.")
-            return jsonify({"members": []}), 200
-
-        members_list = []
-        for member_id, member_data in members.items():
-            member_data["id"] = member_id
-            members_list.append(member_data)
-
-        logger.debug(f"Retrieved {len(members_list)} members.")
+        members = db.reference("members").get()
+        if not members: return jsonify({"members": []}), 200
+        members_list = [{"id": m_id, **m_data} for m_id, m_data in members.items()]
         return jsonify({"members": members_list}), 200
     except Exception as e:
-        logger.error(f"Error retrieving members: {e}", exc_info=True)
+        logger.error(f"Error getting members: {e}", exc_info=True)
         return jsonify({"error": "Internal server error"}), 500
 
 @app.route("/assign_members_to_job", methods=["POST"])
 def assign_members_to_job():
-    logger.info("Handling /assign_members_to_job request")
     user = verify_token(request)
-    if not user:
-        logger.warning("Unauthorized access attempt to /assign_members_to_job")
-        return jsonify({"error": "Unauthorized"}), 401
-
+    if not user: return jsonify({"error": "Unauthorized"}), 401
     data = request.json
     job_id = data.get("job_id")
     member_ids = data.get("member_ids", [])
-    logger.debug(f"Assigning members to job {job_id} with data: {data}")
-
-    if not job_id or not member_ids:
-        logger.warning("job_id and member_ids are required for member assignment.")
-        return jsonify({"error": "job_id and member_ids are required"}), 400
-
+    if not job_id or not member_ids: return jsonify({"error": "job_id and member_ids are required"}), 400
     job_ref = db.reference(f"jobs/{job_id}")
-    if not job_ref.get():
-        logger.warning(f"Job {job_id} not found for member assignment.")
-        return jsonify({"error": "Job not found"}), 404
-
-    try:
-        members_ref = db.reference("members")
-        all_members = members_ref.get()
-    except Exception as e:
-        logger.error(f"Error retrieving members for assignment to job {job_id}: {e}", exc_info=True)
-        return jsonify({"error": "Internal server error"}), 500
-
-    if not all_members:
-        logger.warning("No members found in database for assignment.")
-        return jsonify({"error": "No members found"}), 404
-
-    selected_members = []
-    for member_id in member_ids:
-        if member_id in all_members:
-            member_data = all_members[member_id]
-            member_data["id"] = member_id
-            selected_members.append(member_data)
-
-    if len(selected_members) < 25:
-        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
-
+    if not job_ref.get(): return jsonify({"error": "Job not found"}), 404
     try:
+        all_members = db.reference("members").get()
+        if not all_members: return jsonify({"error": "No members found"}), 404
+        selected_members = [{"id": m_id, **m_data} for m_id, m_data in all_members.items() if m_id in member_ids]
+        if len(selected_members) < 25: return jsonify({"error": "At least 25 members must be assigned"}), 400
         job_ref.update({"assigned_members": selected_members})
-        logger.info(f"{len(selected_members)} members assigned to job {job_id}.")
-        return jsonify({
-            "message": f"{len(selected_members)} members assigned to job {job_id}",
-            "assigned_members": selected_members
-        }), 200
+        return jsonify({"message": f"{len(selected_members)} members assigned"}), 200
     except Exception as e:
-        logger.error(f"Error updating assigned members for job {job_id}: {e}", exc_info=True)
+        logger.error(f"Error assigning members to job {job_id}: {e}", exc_info=True)
         return jsonify({"error": "Internal server error"}), 500
 
 @app.route("/update_job_settings/<job_id>", methods=["POST"])
 def update_job_settings(job_id):
-    logger.info(f"Handling /update_job_settings/{job_id} request")
     user = verify_token(request)
-    if not user:
-        logger.warning(f"Unauthorized access attempt to /update_job_settings/{job_id}")
-        return jsonify({"error": "Unauthorized"}), 401
-
+    if not user: return jsonify({"error": "Unauthorized"}), 401
     data = request.json
     rotation_period = data.get("rotation_period")
-    logger.debug(f"Updating settings for job {job_id} with data: {data}")
-
-    if rotation_period is None:
-        logger.warning("rotation_period is required for job settings update.")
-        return jsonify({"error": "rotation_period is required (in seconds)"}), 400
-
+    if rotation_period is None: return jsonify({"error": "rotation_period is required"}), 400
     job_ref = db.reference(f"jobs/{job_id}")
-    if not job_ref.get():
-        logger.warning(f"Job {job_id} not found for settings update.")
-        return jsonify({"error": "Job not found"}), 404
-
+    if not job_ref.get(): return jsonify({"error": "Job not found"}), 404
     try:
         job_ref.update({"rotation_period": rotation_period})
-        logger.info(f"Job {job_id} rotation period updated to {rotation_period} seconds.")
-        return jsonify({
-            "message": f"Job {job_id} rotation period updated to {rotation_period} seconds",
-            "rotation_period": rotation_period
-        }), 200
+        return jsonify({"message": f"Rotation period updated to {rotation_period}s"}), 200
     except Exception as e:
-        logger.error(f"Error updating rotation period for job {job_id}: {e}", exc_info=True)
+        logger.error(f"Error updating job settings for {job_id}: {e}", exc_info=True)
         return jsonify({"error": "Internal server error"}), 500
 
 @app.route("/add_special_case/<job_id>", methods=["POST"])
 def add_special_case(job_id):
-    logger.info(f"Handling /add_special_case/{job_id} request")
     user = verify_token(request)
-    if not user:
-        logger.warning(f"Unauthorized access attempt to /add_special_case/{job_id}")
-        return jsonify({"error": "Unauthorized"}), 401
-
+    if not user: return jsonify({"error": "Unauthorized"}), 401
     data = request.json
-    point_id = data.get("point_id")
-    member_id = data.get("member_id")
-    reason = data.get("reason", "Special Assignment")
-    shift_number = data.get("shift_number")
-    active = data.get("active", False)
-    logger.debug(f"Adding special case to job {job_id} with data: {data}")
-
-    if not point_id or not member_id:
-        logger.warning("point_id and member_id are required for special case.")
-        return jsonify({"error": "point_id and member_id are required"}), 400
-
+    point_id, member_id = data.get("point_id"), data.get("member_id")
+    if not point_id or not member_id: return jsonify({"error": "point_id and member_id are required"}), 400
     job_ref = db.reference(f"jobs/{job_id}")
     job_data = job_ref.get()
-
-    if not job_data:
-        logger.warning(f"Job {job_id} not found for special case addition.")
-        return jsonify({"error": "Job not found"}), 404
-
-    guarding_points = job_data.get("guarding_points", [])
-    assigned_members = job_data.get("assigned_members", [])
-
-    point_exists = any(p["id"] == point_id for p in guarding_points)
-    member_exists = any(m["id"] == member_id for m in assigned_members)
-
-    if not point_exists:
-        logger.warning(f"Guarding point {point_id} not found in job {job_id}.")
+    if not job_data: return jsonify({"error": "Job not found"}), 404
+    if not any(p["id"] == point_id for p in job_data.get("guarding_points", [])):
         return jsonify({"error": "Guarding point not found in job"}), 404
-    if not member_exists:
-        logger.warning(f"Member {member_id} not assigned to job {job_id}.")
+    if not any(m["id"] == member_id for m in job_data.get("assigned_members", [])):
         return jsonify({"error": "Member not assigned to job"}), 404
-
-    special_case = {
-        "id": str(uuid.uuid4()),
-        "point_id": point_id,
-        "member_id": member_id,
-        "reason": reason,
-        "shift_number": shift_number,
-        "active": active,
-        "created_at": datetime.now().isoformat()
-    }
-
+    special_case = {"id": str(uuid.uuid4()), **data, "created_at": dt_class.now().isoformat()}
     special_cases = job_data.get("special_cases", [])
     special_cases.append(special_case)
-
     try:
         job_ref.update({"special_cases": special_cases})
-        logger.info(f"Special case added to job {job_id}.")
-        return jsonify({
-            "message": "Special case added",
-            "special_case": special_case
-        }), 200
+        return jsonify({"message": "Special case added", "special_case": special_case}), 200
     except Exception as e:
         logger.error(f"Error adding special case to job {job_id}: {e}", exc_info=True)
         return jsonify({"error": "Internal server error"}), 500
 
 @app.route("/get_roster/<job_id>", methods=["GET"])
 def get_roster(job_id):
-    logger.info(f"Handling /get_roster/{job_id} request")
     user = verify_token(request)
-    if not user:
-        logger.warning(f"Unauthorized access attempt to /get_roster/{job_id}")
-        return jsonify({"error": "Unauthorized"}), 401
-
+    if not user: return jsonify({"error": "Unauthorized"}), 401
     try:
-        job_ref = db.reference(f"jobs/{job_id}")
-        job_data = job_ref.get()
-
-        if not job_data:
-            logger.warning(f"Job {job_id} not found for roster retrieval.")
-            return jsonify({"error": "Job not found"}), 404
-
+        job_data = db.reference(f"jobs/{job_id}").get()
+        if not job_data: return jsonify({"error": "Job not found"}), 404
         assignments = job_data.get("assignments", [])
         roster_data = []
         for shift in assignments:
-            shift_number = shift["shift_number"]
-            assigned_at = shift["assigned_at"]
-
             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,
+                    "shift_number": shift["shift_number"],
+                    "assigned_at": shift["assigned_at"],
                     "point_name": assignment.get("point", {}).get("name", "Unknown"),
-                    "member_names": ", ".join(member_names), # Join names for display
+                    "member_names": ", ".join(member_names),
                     "is_special_case": assignment.get("is_special_case", False),
                 })
-
-        logger.debug(f"Retrieved roster for job {job_id} with {len(roster_data)} entries.")
-        return jsonify({
-            "roster": roster_data,
-            "job_name": job_data.get("name", "Unknown Job"),
-            "total_shifts": len(assignments)
-        }), 200
+        return jsonify({"roster": roster_data, "job_name": job_data.get("name", "Unknown Job"), "total_shifts": len(assignments)}), 200
     except Exception as e:
-        logger.error(f"Error retrieving roster for job {job_id}: {e}", exc_info=True)
+        logger.error(f"Error getting roster for {job_id}: {e}", exc_info=True)
         return jsonify({"error": "Internal server error"}), 500
 
 # === Schedule periodic guard rotation ===
 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",
@@ -1017,4 +695,4 @@ except Exception as e:
 # === Run Server ===
 if __name__ == "__main__":
     logger.info("Starting Flask application...")
-    app.run(debug=True, host="0.0.0.0", port=int(os.getenv("PORT", 7860)))
+    app.run(debug=True, host="0.0.0.0", port=int(os.getenv("PORT", 7860)))```