Update main.py

main.py

@@ -1,7 +1,7 @@
 import os
 import json
 import uuid
-import datetime # <-- This is the main module
+import datetime
 import pandas as pd
 from flask import Flask, request, jsonify
 from flask_cors import CORS
@@ -14,33 +14,21 @@ import logging
 from logging.handlers import RotatingFileHandler
 import time
 import random
-from datetime import datetime as dt_class # Using an alias for the class to avoid confusion
+from datetime import datetime as dt_class
 
 # === Logging Configuration ===
-# Configure logging
 if not os.path.exists('logs'):
     os.mkdir('logs')
-
-# Create a custom logger
 logger = logging.getLogger('guards_api')
-logger.setLevel(logging.DEBUG) # Capture DEBUG and above
-
-# Create handlers
+logger.setLevel(logging.DEBUG)
 file_handler = RotatingFileHandler('logs/guards_api.log', maxBytes=10240, backupCount=10)
-file_handler.setFormatter(logging.Formatter(
-    '%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'
-))
-file_handler.setLevel(logging.INFO) # File logs INFO and above
-
+file_handler.setFormatter(logging.Formatter('%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'))
+file_handler.setLevel(logging.INFO)
 console_handler = logging.StreamHandler()
 console_handler.setFormatter(logging.Formatter('%(levelname)s: %(message)s'))
-console_handler.setLevel(logging.DEBUG) # Console logs DEBUG and above
-
-# Add handlers to the logger
+console_handler.setLevel(logging.DEBUG)
 logger.addHandler(file_handler)
 logger.addHandler(console_handler)
-
-# Also configure the root logger for Flask's default messages
 root_logger = logging.getLogger()
 root_logger.setLevel(logging.INFO)
 root_logger.addHandler(file_handler)
@@ -51,58 +39,30 @@ RESEND_API_KEY = os.getenv("RESEND_API_KEY")
 FIREBASE_CRED_JSON = json.loads(os.getenv("FIREBASE"))
 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}")
 
 # === Firebase Init ===
 try:
     cred = credentials.Certificate(FIREBASE_CRED_JSON)
-    firebase_admin.initialize_app(cred, {
-        "databaseURL": FIREBASE_DB_URL
-    })
+    firebase_admin.initialize_app(cred, {"databaseURL": FIREBASE_DB_URL})
     logger.info("Firebase Admin initialized successfully.")
 except Exception as e:
-    logger.error(f"Failed to initialize Firebase Admin: {e}")
+    logger.error(f"Failed to initialize Firebase Admin: {e}", exc_info=True)
     raise
 
-admin_emails = [
-    "rairorr@gmail.com",
-    "nharingosheperd@gmail.com"
-]
-
-for email in admin_emails:
-    key = email.replace("@", "_").replace(".", "_")
-    try:
-        db.reference(f"admins/{key}").set({
-            "email": email,
-            "is_admin": True
-        })
-        logger.info(f"✅ Admin {email} added/updated in database.")
-    except Exception as e:
-        logger.error(f"Failed to add admin {email} to database: {e}")
-
-# === Flask App Setup ===
+# === Flask App & Scheduler & Resend Setup ===
 app = Flask(__name__)
 CORS(app)
-logger.info("Flask app initialized.")
-
-# === APScheduler Setup ===
-class Config(object):
-    SCHEDULER_API_ENABLED = True
-
-app.config.from_object(Config())
-
+app.config.from_object(type('Config', (object,), {'SCHEDULER_API_ENABLED': True})())
 scheduler = APScheduler()
 scheduler.init_app(app)
 scheduler.start()
-logger.info("APScheduler initialized and started.")
-
-# === Resend Init ===
 Emails.api_key = RESEND_API_KEY
-logger.info("Resend API key configured.")
+logger.info("Flask, APScheduler, and Resend initialized.")
+
 
 def send_email(to, subject, html):
+    """Sends an email and provides detailed error logging."""
     try:
         response = Emails.send({
             "from": "Admin <admin@resend.dev>",
@@ -111,20 +71,20 @@ def send_email(to, subject, html):
             "html": html
         })
         if response is None:
-            logger.warning(f"Email API returned None for recipient {to}. Check Resend dashboard for suppression or other issues.")
+            logger.warning(f"Email API returned None for recipient {to}. Check Resend dashboard for suppression list.")
             return None
-        logger.info(f"Email sent successfully to {to}. Response: {response}")
+        logger.info(f"Email sent successfully to {to}. Response ID: {response.get('id')}")
         return response
-    except Exception as e:
-        logger.error(f"Email error to {to}: {e}")
+    except Exception:
+        # IMPROVED LOGGING: This will now log the full traceback to your log file
+        logger.error(f"Caught exception while sending email to {to}", exc_info=True)
         return None
 
 def send_rotation_notification(job_id, shift_record):
-    """Send email notification for rotation to all admins with rate-limiting prevention"""
+    """Sends 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()
-
         if not job_data:
             logger.warning(f"Job {job_id} not found for rotation notification.")
             return
@@ -142,86 +102,40 @@ def send_rotation_notification(job_id, shift_record):
         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> {human_readable_time}</p>
-
         <h3>Assignments:</h3>
         <table border="1" style="border-collapse: collapse; width: 100%;">
-            <thead>
-                <tr>
-                    <th>Guarding Point</th>
-                    <th>Assigned Members</th>
-                    <th>Special Case</th>
-                </tr>
-            </thead>
+            <thead><tr><th>Guarding Point</th><th>Assigned Members</th><th>Special Case</th></tr></thead>
             <tbody>
         """
-
         for assignment in shift_record.get("assignments", []):
             point_name = assignment.get("point", {}).get("name", "Unknown Point")
-            assigned_members = assignment.get("members", [])
-            member_names = [member.get("name", "Unknown Member") for member in assigned_members]
+            member_names = [m.get("name", "Unknown Member") for m in assignment.get("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>{members_html}</td>
-                    <td>{is_special}</td>
-                </tr>
-            """
-
-        html_content += """
-            </tbody>
-        </table>
-        <p><em>This is an automated notification from the Guard Rotation System.</em></p>
-        """
+            html_content += f"<tr><td>{point_name}</td><td>{members_html}</td><td>{is_special}</td></tr>"
+        html_content += "</tbody></table><p><em>This is an automated notification from the Guard Rotation System.</em></p>"
 
         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)
             time.sleep(1)
-
     except Exception as e:
-        logger.error(f"Error sending rotation notification for job {job_id}: {e}")
+        logger.error(f"Error building rotation notification for job {job_id}", exc_info=True)
 
 
-# === Auth Middleware ===
 def verify_token(req):
-    auth_header = req.headers.get("Authorization")
-    user_email = req.headers.get("X-User-Email")
-
-    if not auth_header:
-        print("Authorization header missing.")
-        return None
-
-    if not user_email:
-        logging.info("X-User-Email header missing from request.")
-        return None
-
-    if user_email not in ADMIN_EMAILS:
-         logging.info(f"Email {user_email} from X-User-Email header not found in ADMIN_EMAILS list.")
-         return None
-
     try:
-        if auth_header.startswith("Bearer "):
-            token = auth_header[7:].strip()
-        else:
-            token = auth_header.strip()
-
-        decoded = firebase_auth.verify_id_token(token)
-        logging.info(f"User with email {user_email} (UID: {decoded.get('uid')}) is authorized as admin (email in ADMIN_EMAILS).")
-        return decoded
-
-    except Exception as e:
-        print(f"Unexpected error during token verification: {e}")
+        auth_header = req.headers.get("Authorization", "").split("Bearer ")[-1]
+        user_email = req.headers.get("X-User-Email")
+        if not auth_header or not user_email or user_email not in ADMIN_EMAILS:
+            return None
+        return firebase_auth.verify_id_token(auth_header)
+    except Exception:
         return None
 
-# === Admin Setup ===
 def setup_admins():
     ref = db.reference("admins")
     for email in ADMIN_EMAILS:
@@ -229,20 +143,15 @@ def setup_admins():
         ref.child(uid).set({"email": email, "is_admin": True})
 setup_admins()
 
-# === Core Functions ===
 def assign_roster(job_id):
-    """Assign roster for a job - implements the multi-guard rotation algorithm"""
+    """Assigns roster for a job, correctly handling multiple guards per point."""
     try:
         logger.info(f"Starting roster assignment for job {job_id}")
         job_ref = db.reference(f"jobs/{job_id}")
         job_data = job_ref.get()
 
-        if not job_data:
-            logger.error(f"Job {job_id} not found")
-            return
-
-        if job_data.get("status") != "active":
-            logger.info(f"Job {job_id} is not active (status: {job_data.get('status')}), skipping assignment.")
+        if not job_data or job_data.get("status") != "active":
+            logger.info(f"Job {job_id} not found or not active. Skipping assignment.")
             return
 
         guarding_points = job_data.get("guarding_points", [])
@@ -254,24 +163,29 @@ def assign_roster(job_id):
 
         shift_number = len(job_data.get("assignments", [])) + 1
         shift_assignments = []
-        available_for_shift_members = random.sample(assigned_members, len(assigned_members))
+        available_for_shift = 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.")
+        total_guards_required = sum(int(point.get('guards', 1)) for point in guarding_points)
+        if len(available_for_shift) < total_guards_required:
+            logger.error(f"INSUFFICIENT MEMBERS: Job {job_id} requires {total_guards_required} guards but only {len(available_for_shift)} are available. Aborting shift.")
             return
 
-        logger.info(f"Applying standard rotation for job {job_id}, shift {shift_number}")
+        logger.info(f"Assigning shift {shift_number} for job {job_id}. Required guards: {total_guards_required}.")
 
         for point in guarding_points:
             guards_for_point = []
-            num_guards_required = point.get('guards', 1)
+            try:
+                num_guards_required = int(point.get('guards', 1))
+            except (ValueError, TypeError):
+                num_guards_required = 1
+            
+            logger.debug(f"Assigning to point '{point.get('name')}'. Need {num_guards_required} guard(s).")
 
             for _ in range(num_guards_required):
-                if not available_for_shift_members:
+                if not available_for_shift:
                     logger.warning(f"Ran out of available members while assigning to point {point.get('name')}")
                     break
-                selected_member = available_for_shift_members.pop(0)
+                selected_member = available_for_shift.pop(0)
                 guards_for_point.append(selected_member)
 
             if guards_for_point:
@@ -288,10 +202,8 @@ def assign_roster(job_id):
                 "assignments": shift_assignments,
                 "shift_id": str(uuid.uuid4())
             }
-
             current_assignments = job_data.get("assignments", [])
             current_assignments.append(shift_record)
-
             job_ref.update({
                 "assignments": current_assignments,
                 "last_updated": dt_class.now().isoformat()
@@ -301,117 +213,37 @@ def assign_roster(job_id):
             send_rotation_notification(job_id, shift_record)
 
             rotation_period = job_data.get("rotation_period", 28800)
-            # --- FIX #2 HERE ---
             next_run_time = dt_class.now() + datetime.timedelta(seconds=rotation_period)
             
             scheduler.add_job(
-                func=assign_roster,
-                trigger="date",
-                run_date=next_run_time,
-                args=[job_id],
-                id=f"rotate_{job_id}_{uuid.uuid4().hex[:8]}"
+                func=assign_roster, trigger="date", run_date=next_run_time,
+                args=[job_id], id=f"rotate_{job_id}_{uuid.uuid4().hex[:8]}",
+                replace_existing=True
             )
             logger.info(f"Scheduled next rotation for job {job_id} in {rotation_period} seconds.")
         else:
             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...")
-        jobs_ref = db.reference("jobs")
-        jobs = jobs_ref.get()
-
-        if not jobs:
-            return
-
-        for job_id, job_data in jobs.items():
-            if job_data.get("status") != "active":
-                continue
-
-            assignments = job_data.get("assignments", [])
-            if not assignments:
-                continue
-
-            last_assignment = assignments[-1]
-            try:
-                assigned_at_str = last_assignment.get("assigned_at", "")
-                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 = dt_class.now(assigned_at.tzinfo)
-            rotation_period = job_data.get("rotation_period", 28800)
-            time_since_last_assignment = (now - assigned_at).total_seconds()
-            
-            if time_since_last_assignment > rotation_period:
-                logger.info(f"Rotating guards for job {job_id} based on interval check.")
-                assign_roster(job_id)
-
-    except Exception as e:
-        logger.error(f"Error in check_and_rotate_guards: {e}", exc_info=True)
+    except Exception:
+        logger.error(f"CRITICAL ERROR in assign_roster for job {job_id}", exc_info=True)
 
 # === Routes ===
 @app.before_request
 def log_request_info():
     logger.info(f"Incoming request: {request.method} {request.url}")
-
-@app.route("/", methods=["GET"])
-def home():
-    return jsonify({"message": "Rairo Guards API is running.", "status": "ok"}), 200
     
 @app.after_request
 def log_response_info(response):
     logger.info(f"Outgoing response: {response.status} for {request.method} {request.url}")
     return response
 
-@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:
-        return jsonify({"error": "Unauthorized"}), 401
-
-    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
+@app.route("/", methods=["GET"])
+def home():
+    return jsonify({"message": "Rairo Guards API is running.", "status": "ok"}), 200
 
-# (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
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     file = request.files.get("file")
     if not file: return jsonify({"error": "No file uploaded"}), 400
     try:
@@ -426,8 +258,7 @@ def upload_members():
 
 @app.route("/add_member", methods=["POST"])
 def add_member():
-    user = verify_token(request)
-    if not user: return jsonify({"error": "Unauthorized"}), 401
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     data = request.json
     member_id = str(uuid.uuid4())
     try:
@@ -439,8 +270,7 @@ def add_member():
 
 @app.route("/update_member/<member_id>", methods=["POST"])
 def update_member(member_id):
-    user = verify_token(request)
-    if not user: return jsonify({"error": "Unauthorized"}), 401
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     data = request.json
     if not data: return jsonify({"error": "Request body cannot be empty"}), 400
     member_ref = db.reference(f"members/{member_id}")
@@ -454,8 +284,7 @@ def update_member(member_id):
 
 @app.route("/delete_member/<member_id>", methods=["DELETE"])
 def delete_member(member_id):
-    user = verify_token(request)
-    if not user: return jsonify({"error": "Unauthorized"}), 401
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     member_ref = db.reference(f"members/{member_id}")
     if not member_ref.get(): return jsonify({"error": "Member not found"}), 404
     try:
@@ -467,26 +296,25 @@ def delete_member(member_id):
 
 @app.route("/create_job", methods=["POST"])
 def create_job():
-    user = verify_token(request)
-    if not user: return jsonify({"error": "Unauthorized"}), 401
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     data = request.json
     job_id = str(uuid.uuid4())
     guarding_points = data.get("guarding_points", [])
     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): 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)}
+    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": []}
     try:
         db.reference(f"jobs/{job_id}").set(job_data)
         return jsonify({"message": "Job created", "job_id": job_id}), 200
     except Exception as e:
-        logger.error(f"Error creating job: {e}", exc_info=True)
+        logger.error("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):
-    user = verify_token(request)
-    if not user: return jsonify({"error": "Unauthorized"}), 401
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     data = request.json
     if not data: return jsonify({"error": "Request body cannot be empty"}), 400
     job_ref = db.reference(f"jobs/{job_id}")
@@ -501,8 +329,7 @@ def update_job(job_id):
 
 @app.route("/schedule_job/<job_id>", methods=["POST"])
 def schedule_job(job_id):
-    user = verify_token(request)
-    if not user: return jsonify({"error": "Unauthorized"}), 401
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     data = request.json
     start_time_iso = data.get("start_time")
     if not start_time_iso: return jsonify({"error": "start_time is required"}), 400
@@ -510,12 +337,11 @@ def schedule_job(job_id):
     if not job_ref.get(): return jsonify({"error": "Job not found"}), 404
     try:
         start_time = dt_class.fromisoformat(start_time_iso.replace("Z", "+00:00"))
-    except ValueError:
-        return jsonify({"error": "Invalid start_time format."}), 400
-    try:
         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]}")
+        scheduler.add_job(func=start_scheduled_job, trigger="date", run_date=start_time, args=[job_id], id=f"start_{job_id}", replace_existing=True)
         return jsonify({"message": f"Job {job_id} scheduled to start at {start_time_iso}"}), 200
+    except ValueError:
+        return jsonify({"error": "Invalid start_time format."}), 400
     except Exception as e:
         logger.error(f"Error scheduling job {job_id}: {e}", exc_info=True)
         return jsonify({"error": "Failed to schedule job"}), 500
@@ -524,16 +350,34 @@ 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}")
-        if not job_ref.get(): return
-        job_ref.update({"status": "active", "started_at": dt_class.now().isoformat()})
-        assign_roster(job_id)
+        if job_ref.get():
+            job_ref.update({"status": "active", "started_at": dt_class.now().isoformat()})
+            assign_roster(job_id)
     except Exception as e:
         logger.error(f"Error in start_scheduled_job for {job_id}: {e}", exc_info=True)
 
+@app.route("/start_job/<job_id>", methods=["POST"])
+def start_job(job_id):
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
+    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.")
+        scheduler.add_job(
+            func=assign_roster, trigger="date",
+            run_date=dt_class.now() + datetime.timedelta(seconds=5),
+            args=[job_id], id=f"start_{job_id}", replace_existing=True
+        )
+        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 starting job {job_id}: {e}", exc_info=True)
+        return jsonify({"error": "Failed to start job assignments"}), 500
+
 @app.route("/pause_job/<job_id>", methods=["POST"])
 def pause_job(job_id):
-    user = verify_token(request)
-    if not user: return jsonify({"error": "Unauthorized"}), 401
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     job_ref = db.reference(f"jobs/{job_id}")
     if not job_ref.get(): return jsonify({"error": "Job not found"}), 404
     try:
@@ -545,8 +389,7 @@ def pause_job(job_id):
 
 @app.route("/delete_job/<job_id>", methods=["DELETE"])
 def delete_job(job_id):
-    user = verify_token(request)
-    if not user: return jsonify({"error": "Unauthorized"}), 401
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     job_ref = db.reference(f"jobs/{job_id}")
     if not job_ref.get(): return jsonify({"error": "Job not found"}), 404
     try:
@@ -558,11 +401,9 @@ def delete_job(job_id):
 
 @app.route("/jobs", methods=["GET"])
 def get_jobs():
-    user = verify_token(request)
-    if not user: return jsonify({"error": "Unauthorized"}), 401
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     try:
-        jobs = db.reference("jobs").get()
-        if not jobs: return jsonify({"jobs": []}), 200
+        jobs = db.reference("jobs").get() or {}
         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:
@@ -571,8 +412,7 @@ def get_jobs():
 
 @app.route("/job/<job_id>", methods=["GET"])
 def get_job(job_id):
-    user = verify_token(request)
-    if not user: return jsonify({"error": "Unauthorized"}), 401
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     try:
         job_data = db.reference(f"jobs/{job_id}").get()
         if not job_data: return jsonify({"error": "Job not found"}), 404
@@ -583,11 +423,9 @@ def get_job(job_id):
 
 @app.route("/members", methods=["GET"])
 def get_members():
-    user = verify_token(request)
-    if not user: return jsonify({"error": "Unauthorized"}), 401
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     try:
-        members = db.reference("members").get()
-        if not members: return jsonify({"members": []}), 200
+        members = db.reference("members").get() or {}
         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:
@@ -596,17 +434,14 @@ def get_members():
 
 @app.route("/assign_members_to_job", methods=["POST"])
 def assign_members_to_job():
-    user = verify_token(request)
-    if not user: return jsonify({"error": "Unauthorized"}), 401
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     data = request.json
-    job_id = data.get("job_id")
-    member_ids = data.get("member_ids", [])
+    job_id, member_ids = data.get("job_id"), data.get("member_ids", [])
     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(): 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
+        all_members = db.reference("members").get() or {}
         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})
@@ -617,8 +452,7 @@ def assign_members_to_job():
 
 @app.route("/update_job_settings/<job_id>", methods=["POST"])
 def update_job_settings(job_id):
-    user = verify_token(request)
-    if not user: return jsonify({"error": "Unauthorized"}), 401
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     data = request.json
     rotation_period = data.get("rotation_period")
     if rotation_period is None: return jsonify({"error": "rotation_period is required"}), 400
@@ -633,8 +467,7 @@ def update_job_settings(job_id):
 
 @app.route("/add_special_case/<job_id>", methods=["POST"])
 def add_special_case(job_id):
-    user = verify_token(request)
-    if not user: return jsonify({"error": "Unauthorized"}), 401
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     data = request.json
     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
@@ -657,8 +490,7 @@ def add_special_case(job_id):
 
 @app.route("/get_roster/<job_id>", methods=["GET"])
 def get_roster(job_id):
-    user = verify_token(request)
-    if not user: return jsonify({"error": "Unauthorized"}), 401
+    if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
     try:
         job_data = db.reference(f"jobs/{job_id}").get()
         if not job_data: return jsonify({"error": "Job not found"}), 404
@@ -679,19 +511,6 @@ def get_roster(job_id):
         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:
-    scheduler.add_job(
-        func=check_and_rotate_guards,
-        trigger="interval",
-        minutes=5,
-        id="guard_rotation_check_job",
-        replace_existing=True
-    )
-    logger.info("Scheduled periodic guard rotation check job.")
-except Exception as e:
-    logger.error(f"Failed to schedule periodic guard rotation check: {e}", exc_info=True)
-
 # === Run Server ===
 if __name__ == "__main__":
     logger.info("Starting Flask application...")