Update main.py

main.py

@@ -1103,20 +1103,95 @@ def admin_send_notification():
 @app.route('/api/user/notifications', methods=['GET'])
 def get_user_notifications():
     try:
-        token = request.headers.get('Authorization', '').split(' ')[1]
+        logger.info("Getting user notifications - start")
+        
+        # Get and validate authorization token
+        auth_header = request.headers.get('Authorization', '')
+        logger.info(f"Authorization header present: {bool(auth_header)}")
+        
+        if not auth_header or not auth_header.startswith('Bearer '):
+            logger.warning("Missing or invalid Authorization header format")
+            return jsonify({'error': 'Missing or invalid authorization header'}), 401
+        
+        token = auth_header.split(' ')[1]
+        logger.info(f"Token extracted, length: {len(token) if token else 0}")
+        
+        # Verify token and get user ID
         uid = verify_token(token)
-        if not uid: return jsonify({'error': 'Unauthorized'}), 401
+        if not uid:
+            logger.warning(f"Token verification failed for token: {token[:20]}...")
+            return jsonify({'error': 'Unauthorized'}), 401
+            
+        logger.info(f"User authenticated: {uid}")
 
+        # Get notifications reference
         notifications_ref = db.reference(f'notifications/{uid}')
-        user_notifications = notifications_ref.order_by_child('created_at').get() or {}
+        logger.info(f"Notifications reference created for path: notifications/{uid}")
         
-        # Sort descending (newest first)
-        sorted_notifications = sorted(user_notifications.values(), key=lambda item: item['created_at'], reverse=True)
+        # Try to get notifications with error handling
+        try:
+            user_notifications = notifications_ref.order_by_child('created_at').get()
+            logger.info(f"Notifications query successful, raw result type: {type(user_notifications)}")
+            logger.info(f"Raw notifications data: {user_notifications}")
+        except Exception as db_error:
+            logger.error(f"Database query failed: {str(db_error)}")
+            # Fallback to unordered query
+            logger.info("Attempting fallback to unordered query")
+            user_notifications = notifications_ref.get()
+            logger.info(f"Fallback query result: {user_notifications}")
+        
+        # Handle empty or None results
+        if not user_notifications:
+            logger.info("No notifications found for user")
+            return jsonify([]), 200
+        
+        # Convert to list and handle different data structures
+        notifications_list = []
+        
+        if isinstance(user_notifications, dict):
+            logger.info(f"Processing dict with {len(user_notifications)} items")
+            for key, notification in user_notifications.items():
+                if isinstance(notification, dict):
+                    # Add the key as id if not present
+                    notification_copy = notification.copy()
+                    if 'id' not in notification_copy:
+                        notification_copy['id'] = key
+                    notifications_list.append(notification_copy)
+                    logger.debug(f"Added notification: {key}")
+                else:
+                    logger.warning(f"Unexpected notification format for key {key}: {type(notification)}")
+        else:
+            logger.warning(f"Unexpected notifications data type: {type(user_notifications)}")
+            return jsonify({'error': 'Unexpected data format'}), 500
+        
+        logger.info(f"Processed {len(notifications_list)} notifications")
         
+        # Sort notifications by created_at (newest first)
+        try:
+            sorted_notifications = sorted(
+                notifications_list, 
+                key=lambda item: item.get('created_at', 0), 
+                reverse=True
+            )
+            logger.info(f"Notifications sorted successfully, count: {len(sorted_notifications)}")
+            
+            # Log first notification for debugging
+            if sorted_notifications:
+                logger.debug(f"First notification: {sorted_notifications[0]}")
+                
+        except Exception as sort_error:
+            logger.error(f"Error sorting notifications: {str(sort_error)}")
+            # Return unsorted if sorting fails
+            sorted_notifications = notifications_list
+        
+        logger.info(f"Returning {len(sorted_notifications)} notifications")
         return jsonify(sorted_notifications), 200
+        
     except Exception as e:
         logger.error(f"CRITICAL ERROR getting notifications: {traceback.format_exc()}")
-        return jsonify({'error': str(e)}), 500
+        logger.error(f"Exception type: {type(e).__name__}")
+        logger.error(f"Exception message: {str(e)}")
+        return jsonify({'error': 'Internal server error'}), 500
 
 @app.route('/api/user/notifications/<string:notification_id>/read', methods=['POST'])
 def mark_notification_read(notification_id):