Update main.py

main.py

@@ -56,14 +56,83 @@ Emails.api_key = RESEND_API_KEY
 
 def send_email(to, subject, html):
     try:
-        Emails.send({
+        response = Emails.send({
             "from": "Admin <admin@resend.dev>",
             "to": to,
             "subject": subject,
             "html": html
         })
+        print(f"Email sent successfully to {to}")
+        return response
     except Exception as e:
-        print("Email error:", e)
+        print(f"Email error to {to}: {e}")
+        return None
+
+def send_rotation_notification(job_id, shift_record):
+    """Send email notification for rotation to all admins"""
+    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")
+        
+        # Create HTML email content
+        html_content = f"""
+        <h2>Guard Rotation Notification</h2>
+        <p><strong>Job:</strong> {job_name}</p>
+        <p><strong>Job ID:</strong> {job_id}</p>
+        <p><strong>Shift Number:</strong> {shift_number}</p>
+        <p><strong>Rotation Time:</strong> {shift_record.get('assigned_at', 'Unknown')}</p>
+        
+        <h3>Assignments:</h3>
+        <table border="1" style="border-collapse: collapse; width: 100%;">
+            <thead>
+                <tr>
+                    <th>Guarding Point</th>
+                    <th>Assigned Member</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_name = assignment.get("member", {}).get("name", "Unknown Member")
+            is_special = "Yes" if assignment.get("is_special_case", False) else "No"
+            special_reason = assignment.get("special_case_reason", "") if assignment.get("is_special_case", False) else ""
+            
+            if special_reason:
+                member_info = f"{member_name} ({special_reason})"
+            else:
+                member_info = member_name
+                
+            html_content += f"""
+                <tr>
+                    <td>{point_name}</td>
+                    <td>{member_info}</td>
+                    <td>{is_special}</td>
+                </tr>
+            """
+        
+        html_content += """
+            </tbody>
+        </table>
+        <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:
+            send_email(admin_email, subject, html_content)
+            
+    except Exception as e:
+        print(f"Error sending rotation notification for job {job_id}: {e}")
 
 # === Auth Middleware ===
 def verify_token(req):
@@ -88,56 +157,151 @@ setup_admins()
 
 # === Core Functions ===
 def assign_roster(job_id):
-    """Assign roster for a job - now a regular function instead of Celery task"""
+    """Assign roster for a job - implements the rotation algorithm"""
     try:
         # Get job details
         job_ref = db.reference(f"jobs/{job_id}")
         job_data = job_ref.get()
         
-        if not job_data:
+        if not job_
             print(f"Job {job_id} not found")
             return
             
-        # Get all members
-        members_ref = db.reference("members")
-        members = members_ref.get()
-        
-        if not members:
-            print("No members found")
+        # Check if job is paused
+        if job_data.get("status") == "paused":
+            print(f"Job {job_id} is paused, skipping assignment")
             return
             
-        # Convert members to list
-        members_list = list(members.values()) if isinstance(members, dict) else members
+        # Get guarding points and assigned members
+        guarding_points = job_data.get("guarding_points", [])
+        assigned_members = job_data.get("assigned_members", [])
+        special_cases = job_data.get("special_cases", [])
         
-        # Simple rotation logic (you can enhance this)
+        if not guarding_points:
+            print(f"No guarding points defined for job {job_id}")
+            return
+            
+        if not assigned_members:
+            print(f"No members assigned to job {job_id}")
+            return
+            
+        # Get current assignments and rotation history
         current_assignments = job_data.get("assignments", [])
-        last_assigned_index = job_data.get("last_assigned_index", -1)
+        rotation_history = job_data.get("rotation_history", {})
+        
+        # Determine next shift
+        shift_number = len(current_assignments) + 1
+        
+        # Apply special cases if any match current shift
+        special_assignment = None
+        for case in special_cases:
+            if case.get("shift_number") == shift_number or case.get("active", False):
+                special_assignment = case
+                break
         
-        # Find next member to assign
-        next_index = (last_assigned_index + 1) % len(members_list)
-        assigned_member = members_list[next_index]
+        # Generate assignments for this shift
+        shift_assignments = []
+        
+        if special_assignment:
+            # Apply special case assignment
+            assigned_point = next((p for p in guarding_points if p["id"] == special_assignment["point_id"]), None)
+            assigned_member = next((m for m in assigned_members if m["id"] == special_assignment["member_id"]), None)
+            
+            if assigned_point and assigned_member:
+                shift_assignments.append({
+                    "point": assigned_point,
+                    "member": assigned_member,
+                    "is_special_case": True,
+                    "special_case_reason": special_assignment.get("reason", "Special Assignment")
+                })
+        else:
+            # Standard rotation algorithm
+            # Create point-specific rotation history
+            point_assignments = {}
+            
+            for point in guarding_points:
+                point_id = point["id"]
+                point_history = rotation_history.get(point_id, [])
+                
+                # Find member who hasn't been assigned to this point recently
+                available_members = assigned_members.copy()
+                
+                # Remove recently assigned members (no immediate repetition)
+                recently_assigned_member_ids = set()
+                for recent_assignment in point_history[-len(guarding_points):]:  # Look back N assignments
+                    recently_assigned_member_ids.add(recent_assignment["member_id"])
+                
+                # Filter available members
+                available_members = [m for m in available_members if m["id"] not in recently_assigned_member_ids]
+                
+                # If all members have been recently assigned, use all members
+                if not available_members:
+                    available_members = assigned_members
+                
+                # Select next member (simple round-robin from available)
+                if point_history:
+                    last_assigned_member_id = point_history[-1]["member_id"]
+                    last_member_index = next((i for i, m in enumerate(available_members) if m["id"] == last_assigned_member_id), -1)
+                    next_member_index = (last_member_index + 1) % len(available_members)
+                else:
+                    next_member_index = 0
+                
+                selected_member = available_members[next_member_index]
+                
+                # Record assignment
+                shift_assignments.append({
+                    "point": point,
+                    "member": selected_member,
+                    "is_special_case": False
+                })
+                
+                # Update rotation history
+                point_history.append({
+                    "member_id": selected_member["id"],
+                    "member_name": selected_member.get("name", "Unknown"),
+                    "assigned_at": datetime.datetime.now().isoformat(),
+                    "shift_number": shift_number
+                })
+                rotation_history[point_id] = point_history
+            
+            # Update rotation history in database
+            job_ref.update({"rotation_history": rotation_history})
         
-        # Create assignment record
-        assignment = {
-            "member": assigned_member,
+        # Create shift record
+        shift_record = {
+            "shift_number": shift_number,
             "assigned_at": datetime.datetime.now().isoformat(),
-            "assignment_id": str(uuid.uuid4())
+            "assignments": shift_assignments,
+            "shift_id": str(uuid.uuid4())
         }
         
-        # Update assignments
-        current_assignments.append(assignment)
+        # Add to current assignments
+        current_assignments.append(shift_record)
         
-        # Update job with new assignment and index
+        # Update job with new assignment
         job_ref.update({
             "assignments": current_assignments,
-            "last_assigned_index": next_index,
             "last_updated": datetime.datetime.now().isoformat()
         })
         
-        print(f"Assigned {assigned_member.get('name', 'Unknown')} to job {job_id}")
+        print(f"Shift {shift_number} assigned for job {job_id} with {len(shift_assignments)} assignments")
+        
+        # Send email notification to admins
+        send_rotation_notification(job_id, shift_record)
+        
+        # Schedule next rotation based on job's rotation period
+        rotation_period = job_data.get("rotation_period", 28800)  # Default 8 hours
+        next_run_time = datetime.datetime.now() + datetime.timedelta(seconds=rotation_period)
         
-        # Send notification email (optional)
-        # send_email(assigned_member.get('email'), "New Assignment", f"You have been assigned to job {job_id}")
+        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]}"
+        )
+        
+        print(f"Scheduled next rotation for job {job_id} in {rotation_period} seconds")
         
     except Exception as e:
         print(f"Error in assign_roster for job {job_id}: {e}")
@@ -155,23 +319,32 @@ def check_and_rotate_guards():
             print("No jobs found")
             return
             
-        # Check each job for rotation needs
+        # Check each job for rotation needs (for jobs that don't have scheduled rotations)
         for job_id, job_data in jobs.items():
-            # Check if job needs rotation (example logic - customize as needed)
+            # Skip paused jobs
+            if job_data.get("status") == "paused":
+                continue
+                
+            # Skip jobs that have scheduled rotations
+            if job_data.get("has_scheduled_rotation", False):
+                continue
+                
+            # For jobs without scheduled rotations, check manually
             assignments = job_data.get("assignments", [])
             
             if not assignments:
-                # If no assignments yet, start the first one
-                print(f"Starting first assignment for job {job_id}")
-                assign_roster(job_id)
+                # If no assignments yet, this job hasn't started manually
+                continue
             else:
-                # Check if current assignment is expired (example: 8 hours)
+                # Check if current assignment is expired
                 last_assignment = assignments[-1]
                 assigned_at = datetime.datetime.fromisoformat(last_assignment["assigned_at"].replace("Z", "+00:00"))
                 now = datetime.datetime.now(assigned_at.tzinfo)
                 
-                # Rotate every 8 hours (customize as needed)
-                if (now - assigned_at).total_seconds() > 28800:  # 8 hours in seconds
+                # Get rotation period from job or default to 8 hours
+                rotation_period = job_data.get("rotation_period", 28800)
+                
+                if (now - assigned_at).total_seconds() > rotation_period:
                     print(f"Rotating guard for job {job_id}")
                     assign_roster(job_id)
                     
@@ -217,15 +390,117 @@ def create_job():
 
     data = request.json
     job_id = str(uuid.uuid4())
-    db.reference(f"jobs/{job_id}").set(data)
+    
+    # Validate guarding points (5-15 points)
+    guarding_points = data.get("guarding_points", [])
+    if len(guarding_points) < 5 or len(guarding_points) > 15:
+        return jsonify({"error": "Guarding points must be between 5 and 15"}), 400
+    
+    # Add IDs to guarding points if not present
+    for i, point in enumerate(guarding_points):
+        if "id" not in point:
+            point["id"] = f"point_{i+1}"
+    
+    # Add default fields
+    job_data = {
+        **data,
+        "guarding_points": guarding_points,
+        "created_at": datetime.datetime.now().isoformat(),
+        "status": "created",  # New status: created, active, paused
+        "assignments": [],
+        "rotation_history": {},
+        "rotation_period": data.get("rotation_period", 28800),  # Default 8 hours (28800 seconds)
+        "scheduled_start_time": data.get("scheduled_start_time"),  # ISO format datetime string
+        "has_scheduled_rotation": False,
+        "special_cases": data.get("special_cases", [])
+    }
+    
+    db.reference(f"jobs/{job_id}").set(job_data)
     return jsonify({"message": "Job created", "job_id": job_id}), 200
 
+@app.route("/schedule_job/<job_id>", methods=["POST"])
+def schedule_job(job_id):
+    """Schedule a job to start at a specific time"""
+    user = verify_token(request)
+    if not user:
+        return jsonify({"error": "Unauthorized"}), 401
+
+    data = request.json
+    start_time_iso = data.get("start_time")  # ISO format datetime string
+    
+    if not start_time_iso:
+        return jsonify({"error": "start_time is required (ISO format)"}), 400
+
+    job_ref = db.reference(f"jobs/{job_id}")
+    job_data = job_ref.get()
+    
+    if not job_
+        return jsonify({"error": "Job not found"}), 404
+    
+    # Parse the start time
+    try:
+        start_time = datetime.datetime.fromisoformat(start_time_iso.replace("Z", "+00:00"))
+    except ValueError:
+        return jsonify({"error": "Invalid start_time format. Use ISO format (e.g., 2023-12-01T10:00:00)"}), 400
+    
+    # Update job with scheduled start time
+    job_ref.update({
+        "scheduled_start_time": start_time_iso,
+        "status": "scheduled"
+    })
+    
+    # Schedule the job to start at the specified time
+    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
+
+def start_scheduled_job(job_id):
+    """Function to start a scheduled job"""
+    try:
+        job_ref = db.reference(f"jobs/{job_id}")
+        job_data = job_ref.get()
+        
+        if not job_
+            print(f"Job {job_id} not found for scheduled start")
+            return
+            
+        # Update job status to active
+        job_ref.update({
+            "status": "active",
+            "started_at": datetime.datetime.now().isoformat()
+        })
+        
+        # Start first assignment
+        assign_roster(job_id)
+        
+        print(f"Job {job_id} started via schedule")
+    except Exception as e:
+        print(f"Error starting scheduled job {job_id}: {e}")
+
 @app.route("/start_job/<job_id>", methods=["POST"])
 def start_job(job_id):
     user = verify_token(request)
     if not user:
         return jsonify({"error": "Unauthorized"}), 401
 
+    job_ref = db.reference(f"jobs/{job_id}")
+    job_data = job_ref.get()
+    
+    if not job_
+        return jsonify({"error": "Job not found"}), 404
+        
+    # Update job status to active
+    job_ref.update({
+        "status": "active",
+        "started_at": datetime.datetime.now().isoformat()
+    })
+    
     # Schedule the first assignment immediately
     scheduler.add_job(
         func=assign_roster,
@@ -235,7 +510,258 @@ def start_job(job_id):
         id=f"start_{job_id}_{uuid.uuid4().hex[:8]}"
     )
     
-    return jsonify({"message": f"Roster assignment started for job {job_id}"}), 202
+    return jsonify({"message": f"Job {job_id} started"}), 202
+
+@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
+
+    job_ref = db.reference(f"jobs/{job_id}")
+    job_data = job_ref.get()
+    
+    if not job_
+        return jsonify({"error": "Job not found"}), 404
+        
+    job_ref.update({"status": "paused"})
+    return jsonify({"message": f"Job {job_id} paused"}), 200
+
+@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
+
+    job_ref = db.reference(f"jobs/{job_id}")
+    job_data = job_ref.get()
+    
+    if not job_
+        return jsonify({"error": "Job not found"}), 404
+        
+    job_ref.delete()
+    return jsonify({"message": f"Job {job_id} deleted"}), 200
+
+@app.route("/jobs", methods=["GET"])
+def get_jobs():
+    user = verify_token(request)
+    if not user:
+        return jsonify({"error": "Unauthorized"}), 401
+
+    jobs_ref = db.reference("jobs")
+    jobs = jobs_ref.get()
+    
+    if not jobs:
+        return jsonify({"jobs": []}), 200
+    
+    # Convert to list format
+    jobs_list = []
+    for job_id, job_data in jobs.items():
+        job_data["id"] = job_id
+        jobs_list.append(job_data)
+    
+    return jsonify({"jobs": jobs_list}), 200
+
+@app.route("/job/<job_id>", methods=["GET"])
+def get_job(job_id):
+    user = verify_token(request)
+    if not user:
+        return jsonify({"error": "Unauthorized"}), 401
+
+    job_ref = db.reference(f"jobs/{job_id}")
+    job_data = job_ref.get()
+    
+    if not job_
+        return jsonify({"error": "Job not found"}), 404
+        
+    job_data["id"] = job_id
+    return jsonify({"job": job_data}), 200
+
+@app.route("/members", methods=["GET"])
+def get_members():
+    user = verify_token(request)
+    if not user:
+        return jsonify({"error": "Unauthorized"}), 401
+
+    members_ref = db.reference("members")
+    members = members_ref.get()
+    
+    if not members:
+        return jsonify({"members": []}), 200
+    
+    # Convert to list format
+    members_list = []
+    for member_id, member_data in members.items():
+        member_data["id"] = member_id
+        members_list.append(member_data)
+    
+    return jsonify({"members": members_list}), 200
+
+@app.route("/assign_members_to_job", methods=["POST"])
+def assign_members_to_job():
+    """Bulk assign members to a job"""
+    user = verify_token(request)
+    if not user:
+        return jsonify({"error": "Unauthorized"}), 401
+
+    data = request.json
+    job_id = data.get("job_id")
+    member_ids = 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}")
+    job_data = job_ref.get()
+    
+    if not job_
+        return jsonify({"error": "Job not found"}), 404
+
+    # Get members
+    members_ref = db.reference("members")
+    all_members = members_ref.get()
+    
+    if not all_members:
+        return jsonify({"error": "No members found"}), 404
+
+    # Filter requested members (ensure at least 25)
+    selected_members = []
+    for member_id in member_ids:
+        if member_id in all_members:
+            member_data = all_members[member_id]
+            member_data["id"] = member_id
+            selected_members.append(member_data)
+
+    if len(selected_members) < 25:
+        return jsonify({"error": "At least 25 members must be assigned to the job"}), 400
+
+    # Update job with assigned members
+    job_ref.update({"assigned_members": selected_members})
+    
+    return jsonify({
+        "message": f"{len(selected_members)} members assigned to job {job_id}",
+        "assigned_members": selected_members
+    }), 200
+
+@app.route("/update_job_settings/<job_id>", methods=["POST"])
+def update_job_settings(job_id):
+    """Update job settings including rotation period"""
+    user = verify_token(request)
+    if not user:
+        return jsonify({"error": "Unauthorized"}), 401
+
+    data = request.json
+    rotation_period = data.get("rotation_period")  # In seconds
+    
+    if rotation_period is None:
+        return jsonify({"error": "rotation_period is required (in seconds)"}), 400
+
+    job_ref = db.reference(f"jobs/{job_id}")
+    job_data = job_ref.get()
+    
+    if not job_
+        return jsonify({"error": "Job not found"}), 404
+
+    # Update rotation period
+    job_ref.update({"rotation_period": rotation_period})
+    
+    return jsonify({
+        "message": f"Job {job_id} rotation period updated to {rotation_period} seconds",
+        "rotation_period": rotation_period
+    }), 200
+
+@app.route("/add_special_case/<job_id>", methods=["POST"])
+def add_special_case(job_id):
+    """Add a special case assignment for a job"""
+    user = verify_token(request)
+    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)
+    
+    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_
+        return jsonify({"error": "Job not found"}), 404
+
+    # Verify point and member exist
+    guarding_points = job_data.get("guarding_points", [])
+    assigned_members = job_data.get("assigned_members", [])
+    
+    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:
+        return jsonify({"error": "Guarding point not found in job"}), 404
+    if not member_exists:
+        return jsonify({"error": "Member not assigned to job"}), 404
+
+    # Add special case
+    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.datetime.now().isoformat()
+    }
+    
+    special_cases = job_data.get("special_cases", [])
+    special_cases.append(special_case)
+    
+    job_ref.update({"special_cases": special_cases})
+    
+    return jsonify({
+        "message": "Special case added",
+        "special_case": special_case
+    }), 200
+
+@app.route("/get_roster/<job_id>", methods=["GET"])
+def get_roster(job_id):
+    """Get formatted roster for a job"""
+    user = verify_token(request)
+    if not user:
+        return jsonify({"error": "Unauthorized"}), 401
+
+    job_ref = db.reference(f"jobs/{job_id}")
+    job_data = job_ref.get()
+    
+    if not job_
+        return jsonify({"error": "Job not found"}), 404
+
+    assignments = job_data.get("assignments", [])
+    
+    # Format roster as table data
+    roster_data = []
+    for shift in assignments:
+        shift_number = shift["shift_number"]
+        assigned_at = shift["assigned_at"]
+        
+        for assignment in shift["assignments"]:
+            roster_data.append({
+                "shift_number": shift_number,
+                "assigned_at": assigned_at,
+                "point_name": assignment["point"]["name"],
+                "member_name": assignment["member"].get("name", "Unknown"),
+                "is_special_case": assignment.get("is_special_case", False),
+                "special_case_reason": assignment.get("special_case_reason", "")
+            })
+    
+    return jsonify({
+        "roster": roster_data,
+        "job_name": job_data.get("name", "Unknown Job"),
+        "total_shifts": len(assignments)
+    }), 200
 
 # === Schedule periodic guard rotation ===
 # Run every 5 minutes to check for rotations
@@ -245,7 +771,6 @@ scheduler.add_job(
     minutes=5,
     id="guard_rotation_job"
 )
-
 # === Run Server ===
 if __name__ == "__main__":
     app.run(debug=True, host="0.0.0.0", port=7860)