Update main.py

main.py

@@ -15,8 +15,13 @@ import random
 from datetime import datetime as dt_class, timezone
 from zoneinfo import ZoneInfo
 import pandas as pd
-import requests # <-- Used for direct API calls
-import certifi  # <-- Used for modern SSL certificates
+import requests
+import certifi
+import base64
+
+# --- NEW IMPORTS FOR FILE GENERATION ---
+import weasyprint
+import imgkit
 
 # === Logging Configuration ===
 if not os.path.exists('logs'):
@@ -38,7 +43,7 @@ root_logger.addHandler(console_handler)
 
 # === ENV Config & Admin Setup ===
 ADMIN_EMAILS = ["rairorr@gmail.com", "nharingosheperd@gmail.com"]
-SEND_TO_EMAILS = ["rairorr@gmail.com", "nharingosheperd@gmail.com"]
+SEND_TO_EMAILS = ["rairorr@gmail.com", "nharingosheperd+guard@gmail.com"]
 
 RESEND_API_KEY = os.getenv("RESEND_API_KEY")
 FIREBASE_CRED_JSON = json.loads(os.getenv("FIREBASE"))
@@ -63,11 +68,12 @@ scheduler.init_app(app)
 scheduler.start()
 logger.info("Flask and APScheduler initialized.")
 
-# === DEFINITIVE EMAIL SENDING FUNCTION ===
-def send_email(to, subject, html):
+
+# === UPDATED EMAIL SENDING FUNCTION ===
+def send_email(to, subject, html, attachments=None):
     """
-    Sends an email using a direct requests call to bypass library issues and
-    ensure a modern SSL certificate bundle is used.
+    Sends an email using a direct requests call, now with attachment support.
+    Attachments should be a list of dicts: [{'filename': 'roster.pdf', 'content': 'base64_string'}]
     """
     if not RESEND_API_KEY:
         logger.error("RESEND_API_KEY is not configured. Cannot send email.")
@@ -79,33 +85,22 @@ def send_email(to, subject, html):
         "Content-Type": "application/json"
     }
     payload = {
-        "from": "Guard Admin <admin@sozofix.tech>",
+        "from": "Guard Admin <admin@sozofix.tech>", # Using custom domain
         "to": to.strip(),
         "subject": subject,
-        "html": html
+        "html": html,
+        "attachments": attachments or []
     }
     
-    logger.info(f"Attempting DIRECT API call to Resend for recipient: {to}")
-    
     try:
         response = requests.post(
-            url,
-            headers=headers,
-            json=payload,
-            verify=certifi.where(),
-            timeout=15
+            url, headers=headers, json=payload,
+            verify=certifi.where(), timeout=30 # Increased timeout for attachments
         )
-        
-        logger.info(f"Direct call response status for '{to}': {response.status_code}")
         response.raise_for_status()
-        
         response_data = response.json()
-        logger.info(f"Email sent successfully to {to}. Email ID: {response_data.get('id')}")
+        logger.info(f"Email with {len(payload['attachments'])} attachments sent to {to}. ID: {response_data.get('id')}")
         return response_data
-
-    except requests.exceptions.SSLError as e:
-        logger.error(f"CRITICAL: SSL Error occurred for '{to}' despite using Certifi. This points to a deep network issue or firewall. Error: {repr(e)}", exc_info=True)
-        return None
     except requests.exceptions.RequestException as e:
         logger.error(f"A low-level network error occurred for '{to}'. The raw error is: {repr(e)}", exc_info=True)
         return None
@@ -114,69 +109,139 @@ def send_email(to, subject, html):
         return None
 
 
+# === NEW FILE GENERATION HELPERS ===
+def create_csv_attachment(shift_data, filename):
+    """Creates a CSV file from shift data and returns its path."""
+    try:
+        df_data = []
+        for assignment in shift_data.get("assignments", []):
+            point = assignment.get("point", {}).get("name", "N/A")
+            members = ", ".join([m.get("name", "N/A") for m in assignment.get("members", [])])
+            df_data.append({"Guarding Point": point, "Assigned Members": members})
+        
+        df = pd.DataFrame(df_data)
+        filepath = f"/tmp/{filename}"
+        df.to_csv(filepath, index=False)
+        logger.info(f"Successfully created CSV attachment: {filepath}")
+        return filepath
+    except Exception as e:
+        logger.error(f"Failed to create CSV attachment: {e}", exc_info=True)
+        return None
+
+def create_pdf_attachment(html_content, filename):
+    """Creates a PDF file from HTML content and returns its path."""
+    try:
+        filepath = f"/tmp/{filename}"
+        weasyprint.HTML(string=html_content).write_pdf(filepath)
+        logger.info(f"Successfully created PDF attachment: {filepath}")
+        return filepath
+    except Exception as e:
+        logger.error(f"Failed to create PDF attachment: {e}", exc_info=True)
+        return None
+
+def create_image_attachment(html_content, filename):
+    """Creates a PNG image file from HTML content and returns its path."""
+    try:
+        filepath = f"/tmp/{filename}"
+        # Options to improve image quality and ensure full capture
+        options = {'width': 800, 'disable-smart-width': ''}
+        imgkit.from_string(html_content, filepath, options=options)
+        logger.info(f"Successfully created image attachment: {filepath}")
+        return filepath
+    except Exception as e:
+        logger.error(f"Failed to create image attachment: {e}", exc_info=True)
+        return None
+
+
+# === UPDATED NOTIFICATION FUNCTION ===
 def send_rotation_notification(job_id, shift_record):
-    """Builds and sends email notifications with CAT timezone."""
+    """Orchestrates creating HTML, generating file attachments, and sending the email."""
+    job_ref = db.reference(f"jobs/{job_id}")
+    job_data = job_ref.get()
+    if not job_data: return
+
+    job_name = job_data.get("name", "Unknown Job")
+    shift_number = shift_record.get("shift_number", "Unknown")
+
+    human_readable_time = 'Unknown'
     try:
-        job_ref = db.reference(f"jobs/{job_id}")
-        job_data = job_ref.get()
-        if not job_data: return
-
-        job_name = job_data.get("name", "Unknown Job")
-        shift_number = shift_record.get("shift_number", "Unknown")
-
-        human_readable_time = 'Unknown'
-        try:
-            assigned_time_iso = shift_record.get('assigned_at', '')
-            utc_time = dt_class.fromisoformat(assigned_time_iso)
-            cat_tz = ZoneInfo("Africa/Harare")
-            cat_time = utc_time.astimezone(cat_tz)
-            human_readable_time = cat_time.strftime("%B %d, %Y at %I:%M %p %Z")
-        except (ValueError, TypeError) as e:
-            logger.warning(f"Could not parse or convert timestamp for email: {e}")
-            human_readable_time = shift_record.get('assigned_at', 'Unknown')
-
-        html_content = f"""
-        <h2>Guard Rotation Notification</h2>
-        <p><strong>Job:</strong> {job_name}</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>
-            <tbody>
-        """
-        for assignment in shift_record.get("assignments", []):
-            point_name = assignment.get("point", {}).get("name", "Unknown Point")
-            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>"
+        utc_time = dt_class.fromisoformat(shift_record.get('assigned_at', ''))
+        cat_tz = ZoneInfo("Africa/Harare")
+        cat_time = utc_time.astimezone(cat_tz)
+        human_readable_time = cat_time.strftime("%B %d, %Y at %I:%M %p %Z")
+    except Exception:
+        human_readable_time = shift_record.get('assigned_at', 'Unknown')
+    
+    # Generate HTML content once
+    html_content = f"""
+    <html><head><style>
+        body {{ font-family: sans-serif; }}
+        table {{ border-collapse: collapse; width: 100%; }}
+        th, td {{ border: 1px solid #dddddd; text-align: left; padding: 8px; }}
+        th {{ background-color: #f2f2f2; }}
+    </style></head><body>
+    <h2>Guard Rotation Notification</h2>
+    <p><strong>Job:</strong> {job_name}</p>
+    <p><strong>Shift Number:</strong> {shift_number}</p>
+    <p><strong>Rotation Time:</strong> {human_readable_time}</p>
+    <h3>Assignments:</h3>
+    <table><thead><tr><th>Guarding Point</th><th>Assigned Members</th></tr></thead><tbody>
+    """
+    for assignment in shift_record.get("assignments", []):
+        point_name = assignment.get("point", {}).get("name", "N/A")
+        members_html = "<br>".join([m.get("name", "N/A") for m in assignment.get("members", [])])
+        html_content += f"<tr><td>{point_name}</td><td>{members_html}</td></tr>"
+    html_content += "</tbody></table><p><em>This is an automated notification from the Guard Rotation System.</em></p></body></html>"
 
-        subject = f"Guard Rotation - {job_name} (Shift {shift_number})"
+    # Generate Attachments
+    base_filename = f"roster_{job_name.replace(' ', '_')}_shift_{shift_number}_{int(time.time())}"
+    paths_to_clean = []
+    attachments = []
+
+    try:
+        # Create files
+        csv_path = create_csv_attachment(shift_record, f"{base_filename}.csv")
+        pdf_path = create_pdf_attachment(html_content, f"{base_filename}.pdf")
+        img_path = create_image_attachment(html_content, f"{base_filename}.png")
         
+        # Prepare for email sending
+        file_paths = {'roster.csv': csv_path, 'roster.pdf': pdf_path, 'roster.png': img_path}
+        for filename, filepath in file_paths.items():
+            if filepath:
+                paths_to_clean.append(filepath)
+                with open(filepath, "rb") as f:
+                    content_b64 = base64.b64encode(f.read()).decode('utf-8')
+                    attachments.append({'filename': filename, 'content': content_b64})
+
+        # Send emails
+        subject = f"Guard Rotation - {job_name} (Shift {shift_number})"
         for send_to_email in SEND_TO_EMAILS:
-            logger.info(f"Sending rotation notification to {send_to_email}...")
-            send_email(send_to_email, subject, html_content)
+            logger.info(f"Sending rotation notification with {len(attachments)} attachments to {send_to_email}...")
+            send_email(send_to_email, subject, html_content, attachments)
             time.sleep(1)
             
-    except Exception as e:
-        logger.error(f"Error building rotation notification for job {job_id}", exc_info=True)
-
+    finally:
+        # CRITICAL: Clean up temporary files
+        logger.info(f"Cleaning up {len(paths_to_clean)} temporary files...")
+        for path in paths_to_clean:
+            try:
+                os.remove(path)
+            except OSError as e:
+                logger.error(f"Error deleting temporary file {path}: {e}")
+
+# ... (The rest of your main.py file remains exactly the same)
+# === VERIFY TOKEN, SETUP ADMINS, ASSIGN ROSTER, ALL ROUTES ETC. ===
+# ...
 
 def verify_token(req):
-    """Verifies Firebase token and checks against the ADMIN_EMAILS list."""
     try:
         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
+        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
+    except Exception: return None
 
 def setup_admins():
-    """Sets up admin users in Firebase based on the ADMIN_EMAILS list."""
     ref = db.reference("admins")
     for email in ADMIN_EMAILS:
         uid = f"admin_{email.replace('@', '_').replace('.', '_')}"
@@ -184,36 +249,28 @@ def setup_admins():
 setup_admins()
 
 def assign_roster(job_id):
-    """Assigns roster for a job."""
     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 or job_data.get("status") != "active": return
-
         guarding_points = job_data.get("guarding_points", [])
         assigned_members = job_data.get("assigned_members", [])
-        
         if not guarding_points or not assigned_members:
             logger.warning(f"Job {job_id} is missing guarding points or assigned members.")
             return
-
         shift_number = len(job_data.get("assignments", [])) + 1
         available_for_shift = random.sample(assigned_members, len(assigned_members))
-        
         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} but only {len(available_for_shift)} are available. Aborting.")
             return
-
         shift_assignments = []
         for point in guarding_points:
             num_guards_required = int(point.get('guards', 1))
             guards_for_point = [available_for_shift.pop(0) for _ in range(num_guards_required) if available_for_shift]
             if guards_for_point:
                 shift_assignments.append({"point": point, "members": guards_for_point, "is_special_case": False})
-        
         if shift_assignments:
             shift_record = {
                 "shift_number": shift_number,
@@ -227,13 +284,10 @@ def assign_roster(job_id):
                 "assignments": current_assignments,
                 "last_updated": dt_class.now(timezone.utc).isoformat()
             })
-
             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 = dt_class.now(timezone.utc) + 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]}",
@@ -245,18 +299,13 @@ def assign_roster(job_id):
 
 # === Routes ===
 @app.before_request
-def log_request_info():
-    logger.info(f"Incoming request: {request.method} {request.url}")
-    
+def log_request_info(): logger.info(f"Incoming request: {request.method} {request.url}")
 @app.after_request
-def log_response_info(response):
-    logger.info(f"Outgoing response: {response.status} for {request.method} {request.url}")
-    return response
-
+def log_response_info(response): logger.info(f"Outgoing response: {response.status} for {request.method} {request.url}"); return response
 @app.route("/", methods=["GET"])
-def home():
-    return jsonify({"message": "Rairo Guards API is running.", "status": "ok"}), 200
+def home(): return jsonify({"message": "Rairo Guards API is running.", "status": "ok"}), 200
 
+# (All other routes follow)
 @app.route("/upload_members", methods=["POST"])
 def upload_members():
     if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
@@ -265,24 +314,16 @@ def upload_members():
     try:
         df = pd.read_csv(file) if file.filename.endswith(".csv") else pd.read_excel(file)
         members = df.to_dict(orient="records")
-        for member in members:
-            db.reference(f"members/{str(uuid.uuid4())}").set(member)
+        for member in members: 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)
-        return jsonify({"error": "Error processing file"}), 500
+    except Exception as e: logger.error(f"Error processing uploaded members file: {e}", exc_info=True); return jsonify({"error": "Error processing file"}), 500
 
 @app.route("/add_member", methods=["POST"])
 def add_member():
     if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
-    data = request.json
-    member_id = str(uuid.uuid4())
-    try:
-        db.reference(f"members/{member_id}").set(data)
-        return jsonify({"message": "Member added", "member_id": member_id}), 200
-    except Exception as e:
-        logger.error(f"Error adding member: {e}", exc_info=True)
-        return jsonify({"error": "Internal server error"}), 500
+    data, member_id = request.json, str(uuid.uuid4())
+    try: db.reference(f"members/{member_id}").set(data); return jsonify({"message": "Member added", "member_id": member_id}), 200
+    except Exception as e: 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):
@@ -291,42 +332,27 @@ def update_member(member_id):
     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(): return jsonify({"error": "Member not found"}), 404
-    try:
-        member_ref.update(data)
-        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
+    try: member_ref.update(data); 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):
     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:
-        member_ref.delete()
-        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)
-        return jsonify({"error": "Internal server error"}), 500
+    try: member_ref.delete(); 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); return jsonify({"error": "Internal server error"}), 500
 
 @app.route("/create_job", methods=["POST"])
 def create_job():
     if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
-    data = request.json
-    job_id = str(uuid.uuid4())
+    data, job_id = request.json, 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}")
+    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(timezone.utc).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)
-        return jsonify({"error": "Internal server error"}), 500
+    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); return jsonify({"error": "Internal server error"}), 500
 
 @app.route("/update_job/<job_id>", methods=["POST"])
 def update_job(job_id):
@@ -339,15 +365,12 @@ def update_job(job_id):
         for key in ['assignments', 'rotation_history', 'status']: data.pop(key, None)
         job_ref.update(data)
         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)
-        return jsonify({"error": "Internal server error"}), 500
+    except Exception as e: logger.error(f"Error updating job {job_id}: {e}", exc_info=True); return jsonify({"error": "Internal server error"}), 500
 
 @app.route("/schedule_job/<job_id>", methods=["POST"])
 def schedule_job(job_id):
     if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
-    data = request.json
-    start_time_iso = data.get("start_time")
+    data, start_time_iso = request.json, data.get("start_time")
     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(): return jsonify({"error": "Job not found"}), 404
@@ -356,11 +379,8 @@ def schedule_job(job_id):
         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}", 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
+    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
 
 def start_scheduled_job(job_id):
     try:
@@ -369,8 +389,7 @@ def start_scheduled_job(job_id):
         if job_ref.get():
             job_ref.update({"status": "active", "started_at": dt_class.now(timezone.utc).isoformat()})
             assign_roster(job_id)
-    except Exception as e:
-        logger.error(f"Error in start_scheduled_job for {job_id}: {e}", exc_info=True)
+    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):
@@ -386,33 +405,23 @@ def start_job(job_id):
             args=[job_id], id=f"start_{job_id}", replace_existing=True
         )
         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
+    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):
     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": "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)
-        return jsonify({"error": "Internal server error"}), 500
+    try: job_ref.update({"status": "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); return jsonify({"error": "Internal server error"}), 500
 
 @app.route("/delete_job/<job_id>", methods=["DELETE"])
 def delete_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.delete()
-        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)
-        return jsonify({"error": "Internal server error"}), 500
+    try: job_ref.delete(); 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); return jsonify({"error": "Internal server error"}), 500
 
 @app.route("/jobs", methods=["GET"])
 def get_jobs():
@@ -421,9 +430,7 @@ def get_jobs():
         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:
-        logger.error(f"Error getting jobs: {e}", exc_info=True)
-        return jsonify({"error": "Internal server error"}), 500
+    except Exception as e: 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):
@@ -432,9 +439,7 @@ def get_job(job_id):
         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 getting job {job_id}: {e}", exc_info=True)
-        return jsonify({"error": "Internal server error"}), 500
+    except Exception as e: 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():
@@ -443,9 +448,7 @@ def get_members():
         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:
-        logger.error(f"Error getting members: {e}", exc_info=True)
-        return jsonify({"error": "Internal server error"}), 500
+    except Exception as e: 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():
@@ -461,24 +464,17 @@ def assign_members_to_job():
         if len(selected_members) < 25: return jsonify({"error": "At least 25 members must be assigned"}), 400
         job_ref.update({"assigned_members": selected_members})
         return jsonify({"message": f"{len(selected_members)} members assigned"}), 200
-    except Exception as e:
-        logger.error(f"Error assigning members to job {job_id}: {e}", exc_info=True)
-        return jsonify({"error": "Internal server error"}), 500
+    except Exception as e: 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):
     if not verify_token(request): return jsonify({"error": "Unauthorized"}), 401
-    data = request.json
-    rotation_period = data.get("rotation_period")
+    data, rotation_period = request.json, data.get("rotation_period")
     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(): return jsonify({"error": "Job not found"}), 404
-    try:
-        job_ref.update({"rotation_period": rotation_period})
-        return jsonify({"message": f"Rotation period updated to {rotation_period}s"}), 200
-    except Exception as e:
-        logger.error(f"Error updating job settings for {job_id}: {e}", exc_info=True)
-        return jsonify({"error": "Internal server error"}), 500
+    try: job_ref.update({"rotation_period": rotation_period}); return jsonify({"message": f"Rotation period updated to {rotation_period}s"}), 200
+    except Exception as e: 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):
@@ -486,22 +482,15 @@ def add_special_case(job_id):
     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
-    job_ref = db.reference(f"jobs/{job_id}")
-    job_data = job_ref.get()
+    job_ref, job_data = db.reference(f"jobs/{job_id}"), job_ref.get()
     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 any(m["id"] == member_id for m in job_data.get("assigned_members", [])):
-        return jsonify({"error": "Member not assigned to job"}), 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 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()), **data, "created_at": dt_class.now(timezone.utc).isoformat()}
     special_cases = job_data.get("special_cases", [])
     special_cases.append(special_case)
-    try:
-        job_ref.update({"special_cases": special_cases})
-        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
+    try: job_ref.update({"special_cases": special_cases}); 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):
@@ -522,9 +511,7 @@ def get_roster(job_id):
                     "is_special_case": assignment.get("is_special_case", False),
                 })
         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 getting roster for {job_id}: {e}", exc_info=True)
-        return jsonify({"error": "Internal server error"}), 500
+    except Exception as e: logger.error(f"Error getting roster for {job_id}: {e}", exc_info=True); return jsonify({"error": "Internal server error"}), 500
 
 # === Run Server ===
 if __name__ == "__main__":