Update main.py

main.py

@@ -132,9 +132,60 @@ def credit_required(cost=1):
 
 
 # Full signup function
+# Add this helper function to verify and repair user profiles
+def ensure_user_profile_exists(uid, email=None):
+    """
+    Ensures a user profile exists in Realtime DB. Creates one if missing.
+    Returns the user data or None if creation fails.
+    """
+    try:
+        user_ref = db.reference(f'users/{uid}')
+        user_data = user_ref.get()
+        
+        if not user_data:
+            logging.info(f"Creating missing profile for UID: {uid}")
+            
+            # Get email from Firebase Auth if not provided
+            if not email:
+                try:
+                    user_record = auth.get_user(uid)
+                    email = user_record.email
+                except Exception as e:
+                    logging.error(f"Failed to get email for UID {uid}: {e}")
+                    return None
+            
+            new_profile = {
+                'email': email,
+                'credits': 10,
+                'is_admin': False,
+                'created_at': datetime.utcnow().isoformat(),
+                'suspended': False
+            }
+            
+            # Use transaction to ensure atomic write
+            def create_profile_transaction(current_data):
+                if current_data is None:
+                    return new_profile
+                return current_data  # Profile already exists
+            
+            result = user_ref.transaction(create_profile_transaction)
+            if result.committed:
+                logging.info(f"Successfully created profile for UID: {uid}")
+                return new_profile
+            else:
+                logging.error(f"Failed to create profile for UID: {uid} - transaction not committed")
+                return None
+        
+        return user_data
+        
+    except Exception as e:
+        logging.error(f"Error ensuring profile exists for UID {uid}: {e}")
+        return None
+
+# Updated signup function with better error handling
 @app.route('/api/auth/signup', methods=['POST'])
 def signup():
-    if not FIREBASE_INITIALIZED: # Ensure this check is at the top
+    if not FIREBASE_INITIALIZED:
         logging.error("Firebase not initialized. Signup skipped.")
         return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
 
@@ -149,9 +200,12 @@ def signup():
         logging.info(f"Backend /signup: Processing request for email: {email}")
         
         user_record = None
+        is_new_user = False
+        
         try:
-            # Attempt to create the Firebase Auth user.
+            # Attempt to create the Firebase Auth user
             user_record = auth.create_user(email=email, password=password)
+            is_new_user = True
             logging.info(f"Backend /signup: NEW Firebase Auth user created: {user_record.uid} for email: {email}")
         except auth.EmailAlreadyExistsError:
             logging.warning(f"Backend /signup: Email {email} already exists in Firebase Auth. Fetching existing user.")
@@ -159,48 +213,46 @@ def signup():
                 user_record = auth.get_user_by_email(email)
                 logging.info(f"Backend /signup: Fetched EXISTING Firebase Auth user: {user_record.uid} for email: {email}")
             except Exception as e_get:
-                logging.error(f"Backend /signup: Failed to fetch existing user {email} after EmailAlreadyExistsError: {e_get}")
-                logging.error(traceback.format_exc())
+                logging.error(f"Backend /signup: Failed to fetch existing user {email}: {e_get}")
                 return jsonify({'error': f'Auth user exists but could not be fetched: {str(e_get)}'}), 500
         except Exception as e_create:
             logging.error(f"Backend /signup: Error during auth.create_user for {email}: {e_create}")
-            logging.error(traceback.format_exc())
             return jsonify({'error': f'Firebase Auth user creation failed: {str(e_create)}'}), 500
 
         if not user_record or not user_record.uid:
             logging.error(f"Backend /signup: Could not obtain valid user record or UID for {email}.")
             return jsonify({'error': 'Failed to establish user authentication identity.'}), 500
 
-        uid_to_use = user_record.uid
-        
-        user_ref = db.reference(f'users/{uid_to_use}')
+        uid = user_record.uid
         
-        user_data_to_set = {
-            'email': user_record.email, 
-            'credits': 10,
-            'is_admin': False,
-            'created_at': datetime.utcnow().isoformat(),
-            'suspended': False 
-        }
+        # Ensure profile exists in Realtime DB
+        user_data = ensure_user_profile_exists(uid, user_record.email)
+        if not user_data:
+            logging.error(f"Backend /signup: Failed to create/verify DB profile for UID: {uid}")
+            return jsonify({'error': 'Failed to create user profile in database.'}), 500
         
-        logging.info(f"Backend /signup: Attempting to write/overwrite DB profile for UID: {uid_to_use}. Data: {user_data_to_set}")
-        user_ref.set(user_data_to_set) 
-        logging.info(f"Backend /signup: DB profile set for UID: {uid_to_use} presumed successful.")
+        # Verify the profile was actually written
+        verification_data = db.reference(f'users/{uid}').get()
+        if not verification_data:
+            logging.error(f"Backend /signup: Profile verification failed for UID: {uid}")
+            return jsonify({'error': 'User profile creation could not be verified.'}), 500
         
+        logging.info(f"Backend /signup: Profile verified for UID: {uid}")
         
         return jsonify({
             'success': True,
             'user': {
-                'uid': uid_to_use,
-                **user_data_to_set 
+                'uid': uid,
+                **user_data
             }
         }), 201
 
     except Exception as e: 
-        logging.error(f"Backend /signup: UNHANDLED EXCEPTION for email {data.get('email', 'N/A')}: {e}")
+        logging.error(f"Backend /signup: UNHANDLED EXCEPTION: {e}")
         logging.error(traceback.format_exc())
         return jsonify({'error': f'An unexpected error occurred during signup: {str(e)}'}), 500
 
+# Updated profile endpoint with auto-repair
 @app.route('/api/user/profile', methods=['GET'])
 def get_user_profile():
     if not FIREBASE_INITIALIZED:
@@ -217,23 +269,26 @@ def get_user_profile():
         if not uid:
             return jsonify({'error': 'Invalid or expired token'}), 401
         
-        user_data = db.reference(f'users/{uid}').get()
+        # Try to get user data, create if missing
+        user_data = ensure_user_profile_exists(uid)
         if not user_data:
-            logging.warning(f"User {uid} found in Auth but not in Realtime DB when fetching profile.")
-            return jsonify({'error': 'User profile not found in database. Please try logging in again.'}), 404
+            logging.error(f"Failed to get/create profile for UID: {uid}")
+            return jsonify({'error': 'Unable to retrieve or create user profile. Please contact support.'}), 500
         
         return jsonify({
             'uid': uid,
             'email': user_data.get('email'),
             'credits': user_data.get('credits', 0),
             'is_admin': user_data.get('is_admin', False),
-            'suspended': user_data.get('suspended', False) # Include suspended status
+            'suspended': user_data.get('suspended', False)
         })
+        
     except Exception as e:
         logging.error(f"Error fetching user profile: {e}")
+        logging.error(traceback.format_exc())
         return jsonify({'error': str(e)}), 500
 
-# Backend app.py - Full google_signin function
+# Updated Google Sign-In with better error handling
 @app.route('/api/auth/google-signin', methods=['POST'])
 def google_signin():
     if not FIREBASE_INITIALIZED: 
@@ -253,34 +308,25 @@ def google_signin():
         email = decoded_token.get('email')
         logging.info(f"Backend /google-signin: ID token verified. UID: {uid}, Email: {email}")
 
-        user_ref = db.reference(f'users/{uid}')
-        user_data_from_db = user_ref.get()
-        final_user_data_for_response = None
+        # Ensure profile exists in Realtime DB
+        user_data = ensure_user_profile_exists(uid, email)
+        if not user_data:
+            logging.error(f"Backend /google-signin: Failed to create/verify DB profile for UID: {uid}")
+            return jsonify({'error': 'Failed to create user profile in database.'}), 500
 
-        if not user_data_from_db:
-            logging.info(f"Backend /google-signin: DB profile for Google user UID {uid} (Email: {email}) not found. Creating new DB profile.")
-            new_db_profile_data = {
-                'email': email,
-                'credits': 10, 
-                'is_admin': False,
-                'created_at': datetime.utcnow().isoformat(),
-                'suspended': False 
-            }
-            logging.info(f"Backend /google-signin: Attempting to write NEW DB profile for Google UID: {uid}. Data: {new_db_profile_data}")
-            user_ref.set(new_db_profile_data) 
-            logging.info(f"Backend /google-signin: DB profile set for Google UID: {uid} presumed successful.")
-            
+        # Double-check the profile exists
+        verification_data = db.reference(f'users/{uid}').get()
+        if not verification_data:
+            logging.error(f"Backend /google-signin: Profile verification failed for UID: {uid}")
+            return jsonify({'error': 'User profile creation could not be verified.'}), 500
 
-            final_user_data_for_response = new_db_profile_data
-        else:
-            logging.info(f"Backend /google-signin: Existing DB profile found for Google user UID {uid}. Data: {user_data_from_db}")
-            final_user_data_for_response = user_data_from_db
+        logging.info(f"Backend /google-signin: Profile verified for UID: {uid}")
 
         return jsonify({
             'success': True,
             'user': {
                 'uid': uid,
-                **final_user_data_for_response
+                **user_data
             }
         }), 200
 
@@ -288,12 +334,54 @@ def google_signin():
         logging.error(f"Backend /google-signin: Invalid ID token received.")
         return jsonify({'error': 'Invalid ID token.'}), 401
     except Exception as e: 
-        # Using 'decoded_token' safely in case it's not defined due to an early error
         uid_in_error = decoded_token.get('uid', 'N/A') if 'decoded_token' in locals() and decoded_token else 'N/A'
         logging.error(f"Backend /google-signin: UNHANDLED EXCEPTION for UID {uid_in_error}: {e}")
         logging.error(traceback.format_exc())
         return jsonify({'error': f'An unexpected error occurred during Google Sign-In: {str(e)}'}), 500
 
+# Add this endpoint to repair existing broken profiles
+@app.route('/api/admin/repair-profiles', methods=['POST'])
+def repair_profiles():
+    """Admin endpoint to repair missing user profiles"""
+    if not FIREBASE_INITIALIZED:
+        return jsonify({'error': 'Firebase not initialized'}), 500
+    
+    try:
+        # Get all users from Firebase Auth
+        page = auth.list_users()
+        repaired_count = 0
+        failed_count = 0
+        
+        while page:
+            for user in page.users:
+                uid = user.uid
+                email = user.email
+                
+                # Check if profile exists in DB
+                user_data = db.reference(f'users/{uid}').get()
+                if not user_data:
+                    logging.info(f"Repairing missing profile for UID: {uid}, Email: {email}")
+                    repaired_data = ensure_user_profile_exists(uid, email)
+                    if repaired_data:
+                        repaired_count += 1
+                        logging.info(f"Successfully repaired profile for UID: {uid}")
+                    else:
+                        failed_count += 1
+                        logging.error(f"Failed to repair profile for UID: {uid}")
+            
+            # Get next batch
+            page = page.get_next_page()
+        
+        return jsonify({
+            'success': True,
+            'repaired': repaired_count,
+            'failed': failed_count
+        })
+        
+    except Exception as e:
+        logging.error(f"Error repairing profiles: {e}")
+        return jsonify({'error': str(e)}), 500
+        
 @app.route('/api/user/request-credits', methods=['POST'])
 @credit_required(cost=0)
 def request_credits():