Update main.py

main.py

@@ -184,16 +184,27 @@ def send_rotation_notification(job_id, shift_record):
 # === Auth Middleware ===
 def verify_token(req):
     """
-    Verify Firebase ID token and check if user is admin.
-    Automatically creates admin entry in DB if email is in ADMIN_EMAILS but UID is not found.
-    Uses Firebase Admin SDK to get user email if not directly available in token or DB.
+    Verify Firebase ID token and check if user's email is in ADMIN_EMAILS.
+    Email is expected in the 'X-User-Email' header, sent by the client.
     Returns decoded token dict if valid admin, None otherwise.
     """
     auth_header = req.headers.get("Authorization")
+    # NEW: Get email from custom header sent by client
+    user_email = req.headers.get("X-User-Email")
+
     if not auth_header:
         print("Authorization header missing.")
         return None
 
+    # NEW: Check if email header is present and valid
+    if not user_email:
+        logging.info("X-User-Email header missing from request.")
+        return None
+
+    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:
         # Extract token
         if auth_header.startswith("Bearer "):
@@ -201,69 +212,14 @@ def verify_token(req):
         else:
             token = auth_header.strip()
 
-        # Verify the token to get the UID
+        # Verify the token (ensures token is genuine and user is authenticated)
         decoded = firebase_auth.verify_id_token(token)
-        # print(f"DEBUG: Token verified successfully. Decoded token keys: {list(decoded.keys())}") # Optional debug
-
-        # Get user UID from decoded token
-        uid = decoded.get('uid') or decoded.get('user_id') # Fallback for robustness
-        # print(f"DEBUG: Extracted UID: {uid}") # Optional debug
-
-        if not uid:
-            print("Verified token does not contain a UID or user_id.")
-            return None
-
-        # --- Core Logic Change Starts Here ---
-
-        # 1. Check if user is admin by querying Firebase Realtime Database using UID first
-        admins_ref = db.reference("/admins")
-        admin_data_db = admins_ref.child(uid).get()
-        # print(f"DEBUG: Admin data retrieved for UID {uid}: {admin_data_db}") # Optional debug
-
-        if admin_data_db and admin_data_db.get("is_admin", False):
-            # User is already an admin in the database
-            email_for_logging = admin_data_db.get("email", "Unknown Email")
-            print(f"User {uid} ({email_for_logging}) is authorized as admin (found in DB).")
-            return decoded
-
-        # 2. If not found in DB, get the user's email using the Firebase Admin SDK
-        email = None
-        try:
-            user_record = firebase_auth.get_user(uid)
-            email = user_record.email
-            # print(f"DEBUG: Email retrieved via Firebase Admin SDK for UID {uid}: {email}") # Optional debug
-        except firebase_auth.UserNotFoundError:
-            print(f"User with UID {uid} not found in Firebase Authentication.")
-            return None
-        except Exception as e:
-            print(f"Error fetching user details for UID {uid} from Firebase Auth: {e}")
-            # Cannot reliably verify email, deny access
-            return None
-
-        # 3. Check if the retrieved email is in the approved ADMIN_EMAILS list
-        if email and email in ADMIN_EMAILS:
-            # User's email is in the approved list, but UID not found in DB.
-            # This is likely their first time accessing the API.
-            # Automatically create their admin entry in the Realtime Database using their UID.
-            print(f"First time admin access for {email} (UID: {uid}). Creating database entry.")
-            try:
-                admins_ref.child(uid).set({
-                    "email": email,
-                    "is_admin": True
-                })
-                print(f"Admin entry successfully created for UID {uid}.")
-                # User is now an admin, grant access
-                return decoded
-            except Exception as db_error:
-                print(f"Failed to create admin entry for UID {uid} in database: {db_error}")
-                # Failed to record admin status, deny access for security
-                return None
-        else:
-            # User's email is not in the approved list or email could not be retrieved/verified
-            print(f"Access denied for UID {uid}. Email '{email}' not in approved list or not retrievable.")
-            return None
+        # Note: We are not checking the UID against the database anymore.
+        # We are trusting the email provided by the client, verified against ADMIN_EMAILS.
+        # The token verification ensures the request is from a logged-in user.
 
-        # --- Core Logic Change Ends Here ---
+        logging.info(f"User with email {user_email} (UID: {decoded.get('uid')}) is authorized as admin (email in ADMIN_EMAILS).")
+        return decoded # Return decoded token if needed by other parts of the app
 
     except firebase_auth.InvalidIdTokenError as e:
         print(f"Invalid Firebase ID token provided: {e}")