Update main.py

main.py

@@ -319,32 +319,58 @@ def image_proxy():
         return jsonify({'error': 'Internal server error processing the image request.'}), 500
 
 # -----------------------------------------------------------------------------
-# 3. AUTHENTICATION & USER MANAGEMENT
+# 3. AUTHENTICATION & USER MANAGEMENT (Corrected Version)
 # -----------------------------------------------------------------------------
 
 @app.route('/api/auth/signup', methods=['POST'])
 def signup():
+    """
+    Handles new user sign-up with email/password.
+    ✅ FIX: Now accepts an optional 'displayName' and saves it.
+    """
     try:
         data = request.get_json()
         email, password = data.get('email'), data.get('password')
-        if not email or not password: return jsonify({'error': 'Email and password are required'}), 400
+        # Get the optional displayName
+        display_name = data.get('displayName') # Will be None if not provided
+
+        if not email or not password:
+            return jsonify({'error': 'Email and password are required'}), 400
 
-        user = auth.create_user(email=email, password=password)
+        # Create the user in Firebase Authentication, including the displayName if available
+        user = auth.create_user(
+            email=email,
+            password=password,
+            display_name=display_name
+        )
+        
+        # Create the corresponding user profile in the Realtime Database
         user_ref = db_ref.child(f'users/{user.uid}')
-        user_data = {'email': email, 'credits': 15, 'is_admin': False, 'createdAt': datetime.utcnow().isoformat()}
+        user_data = {
+            'email': email,
+            'displayName': display_name, # Save the name to the database
+            'credits': 15,
+            'is_admin': False,
+            'createdAt': datetime.utcnow().isoformat()
+        }
         user_ref.set(user_data)
+        
+        logger.info(f"New user signed up: {user.uid}, Name: {display_name}")
         return jsonify({'success': True, 'uid': user.uid, **user_data}), 201
+        
     except Exception as e:
+        logger.error(f"Signup failed: {e}")
+        # Provide a more specific error for existing users
+        if 'EMAIL_EXISTS' in str(e):
+            return jsonify({'error': 'An account with this email already exists.'}), 409
         return jsonify({'error': str(e)}), 400
 
 @app.route('/api/auth/social-signin', methods=['POST'])
 def social_signin():
     """
-    Ensures a user record exists in the Realtime Database after a social login
-    (like Google Sign-In). The client should call this endpoint immediately after
-    a successful Firebase authentication on their side, sending the
-    Firebase ID Token. This creates the user's profile in our database if it's
-    their first time.
+    Ensures a user record exists and is up-to-date in the Realtime Database.
+    ✅ IMPROVEMENT: Now backfills the displayName for existing social users
+    if it's missing from the database.
     """
     uid = verify_token(request.headers.get('Authorization'))
     if not uid:
@@ -354,39 +380,87 @@ def social_signin():
     user_data = user_ref.get()
 
     if user_data:
-        # User already has a profile in our DB, return it.
+        # User already exists. Check if their displayName is missing.
+        if 'displayName' not in user_data or user_data['displayName'] is None:
+            try:
+                # The name is missing in our DB, let's sync it from Auth.
+                firebase_user = auth.get_user(uid)
+                if firebase_user.display_name:
+                    logger.info(f"Backfilling missing displayName for existing user {uid}.")
+                    user_ref.update({'displayName': firebase_user.display_name})
+                    # Get the updated data to return to the client
+                    user_data = user_ref.get()
+            except Exception as e:
+                logger.error(f"Could not backfill displayName for user {uid}: {e}")
+        
         return jsonify({'uid': uid, **user_data}), 200
     else:
-        # This is a new user (first social login), create their profile.
+        # This is a new user (first social login), create their full profile.
+        logger.info(f"New social user detected: {uid}. Creating database profile.")
         try:
-            # Get user details from Firebase Auth service. [8]
             firebase_user = auth.get_user(uid)
-            
-            # Create the user profile in our Realtime Database
             new_user_data = {
                 'email': firebase_user.email,
-                'credits': 15,  # Standard starting credits
+                'displayName': firebase_user.display_name,
+                'credits': 15,
                 'is_admin': False,
                 'createdAt': datetime.utcnow().isoformat()
             }
             user_ref.set(new_user_data)
             
-            # Return the newly created profile
+            logger.info(f"Successfully created profile for new social user: {uid}")
             return jsonify({'success': True, 'uid': uid, **new_user_data}), 201
         except Exception as e:
-            print(f"Error creating profile for new social user {uid}: {e}")
+            logger.error(f"Error creating profile for new social user {uid}: {e}")
             return jsonify({'error': f'Failed to create user profile: {str(e)}'}), 500
 
+
 @app.route('/api/user/profile', methods=['GET'])
 def get_user_profile():
+    """
+    Retrieves the user's profile from the Realtime Database.
+    ✅ FIX: This now correctly includes the 'displayName' in the response.
+    """
     uid = verify_token(request.headers.get('Authorization'))
-    if not uid: return jsonify({'error': 'Invalid or expired token'}), 401
+    if not uid:
+        return jsonify({'error': 'Invalid or expired token'}), 401
     
     user_data = db_ref.child(f'users/{uid}').get()
-    if not user_data: return jsonify({'error': 'User not found'}), 404
+    if not user_data:
+        return jsonify({'error': 'User not found'}), 404
     
     return jsonify({'uid': uid, **user_data})
 
+@app.route('/api/user/profile', methods=['PUT'])
+def update_user_profile():
+    """
+    ✅ NEW: Allows a logged-in user to update their profile, specifically their displayName.
+    """
+    uid = verify_token(request.headers.get('Authorization'))
+    if not uid:
+        return jsonify({'error': 'Invalid or expired token'}), 401
+
+    data = request.get_json()
+    new_display_name = data.get('displayName')
+
+    if not new_display_name or not isinstance(new_display_name, str) or len(new_display_name.strip()) == 0:
+        return jsonify({'error': 'A valid displayName is required.'}), 400
+
+    try:
+        # Step 1: Update the user record in Firebase Authentication
+        auth.update_user(uid, display_name=new_display_name)
+        
+        # Step 2: Update the user profile in the Realtime Database
+        user_ref = db_ref.child(f'users/{uid}')
+        user_ref.update({'displayName': new_display_name})
+        
+        logger.info(f"User {uid} updated their displayName to '{new_display_name}'.")
+        return jsonify({'success': True, 'message': 'Profile updated successfully.'}), 200
+
+    except Exception as e:
+        logger.error(f"Error updating profile for user {uid}: {e}")
+        return jsonify({'error': f'Failed to update profile: {str(e)}'}), 500
+        
 # -----------------------------------------------------------------------------
 # 4. FEEDBACK AND CREDIT REQUESTS (USER-FACING)
 # -----------------------------------------------------------------------------