Better logging in backend

controllers/department_controller.py

@@ -281,11 +281,32 @@ def add_member(department_id):
 
 def get_department_members(department_id, current_user=None):
     """Get all members of a department"""
+    # Log input parameters
+    logger.info(f"get_department_members called with department_id: {department_id}")
+    if current_user:
+        logger.info(f"Current user: {current_user._id}, {current_user.email}, Department: {current_user.department_id}")
+    
+    # Find department by ID
     department = Department.find_by_id(department_id)
     if not department:
+        logger.error(f"Department with ID {department_id} not found")
         return jsonify({'message': 'Department not found'}), 404
     
+    # Log department info
+    logger.info(f"Found department: {department.name}, ID: {department._id}")
+    logger.info(f"Department members list (raw): {department.members}")
+    logger.info(f"Department has {len(department.members)} members in its members array")
+    
+    # Find users by department
+    logger.info(f"Calling User.find_by_department with department_id: {department_id}")
     users = User.find_by_department(department_id)
+    
+    # Log result
+    logger.info(f"User.find_by_department returned {len(users)} users")
+    for user in users:
+        logger.info(f"Found user: {user._id}, {user.email}, Department: {user.department_id}")
+    
+    # Return response
     return jsonify({'members': [user.to_dict() for user in users]}), 200
 
 def remove_member(department_id, user_id):
@@ -338,4 +359,82 @@ def update_member_permissions(department_id, user_id):
     if user.save():
         return jsonify({'message': 'User permissions updated successfully', 'user': user.to_dict()}), 200
     else:
-        return jsonify({'message': 'Failed to update user permissions'}), 500 
+        return jsonify({'message': 'Failed to update user permissions'}), 500
+
+def debug_department(department_id):
+    """Debug endpoint to get detailed information about a department and its members"""
+    logger.info(f"debug_department called with department_id: {department_id}")
+    
+    # Find department directly from MongoDB
+    from db import get_departments_collection, get_users_collection
+    from bson import ObjectId
+    
+    dept_id_obj = ObjectId(department_id) if isinstance(department_id, str) else department_id
+    logger.info(f"Looking up department with ObjectId: {dept_id_obj}")
+    
+    # Get raw department data
+    departments_collection = get_departments_collection()
+    department_data = departments_collection.find_one({"_id": dept_id_obj})
+    
+    if not department_data:
+        logger.error(f"Department with ID {department_id} not found in database")
+        return jsonify({'message': 'Department not found'}), 404
+    
+    # Get department object
+    department = Department.find_by_id(department_id)
+    
+    # Get users collection
+    users_collection = get_users_collection()
+    
+    # Find all users in database
+    all_users = list(users_collection.find())
+    logger.info(f"Total users in database: {len(all_users)}")
+    
+    # Collect user info for all department members
+    member_info = []
+    for member_id in department_data.get('members', []):
+        # Try to find user by ID
+        user_data = users_collection.find_one({"_id": member_id})
+        if user_data:
+            member_info.append({
+                "user_id": str(member_id),
+                "found_in_db": True,
+                "email": user_data.get('email'),
+                "name": user_data.get('name'),
+                "department_id": str(user_data.get('department_id')) if user_data.get('department_id') else None
+            })
+        else:
+            member_info.append({
+                "user_id": str(member_id),
+                "found_in_db": False
+            })
+    
+    # Find all users with this department_id
+    users_with_dept = list(users_collection.find({"department_id": dept_id_obj}))
+    logger.info(f"Found {len(users_with_dept)} users with department_id matching {dept_id_obj}")
+    
+    users_info = []
+    for user_data in users_with_dept:
+        users_info.append({
+            "user_id": str(user_data.get('_id')),
+            "email": user_data.get('email'),
+            "name": user_data.get('name'),
+            "in_members_array": any(str(user_data.get('_id')) == str(m) for m in department_data.get('members', []))
+        })
+    
+    # Build response with detailed info
+    response = {
+        "department": {
+            "_id": str(department_data.get('_id')),
+            "name": department_data.get('name'),
+            "raw_members": [str(m) for m in department_data.get('members', [])],
+            "member_count": len(department_data.get('members', [])),
+            "members_detail": member_info
+        },
+        "users_with_department_id": {
+            "count": len(users_with_dept),
+            "users": users_info
+        }
+    }
+    
+    return jsonify(response), 200 

controllers/user_controller.py

@@ -121,9 +121,15 @@ def create_users_bulk():
         'errors': errors
     }), 201 if created_users else 400
 
-def get_all_users():
+def get_all_users(current_user=None):
     """Get all users"""
+    logger.info(f"get_all_users called")
+    if current_user:
+        logger.info(f"Called by user: {current_user._id}, {current_user.email}, Permissions: {current_user.permissions}")
+    
     users = User.get_all()
+    logger.info(f"Found {len(users)} users in the database")
+    
     return jsonify({'users': [user.to_dict() for user in users]}), 200
 
 def get_user(user_id):

models/department.py

@@ -1,6 +1,7 @@
 from bson import ObjectId
 from datetime import datetime
 from db import get_departments_collection
+import logging
 
 class Department:
     def __init__(self, name, address, website, members=None, workflows=None, _id=None, created_at=None, updated_at=None):
@@ -108,28 +109,42 @@ class Department:
     
     def add_member(self, user_id):
         """Add a member to department"""
+        logger = logging.getLogger(__name__)
+        
+        logger.info(f"add_member called with user_id: {user_id}, type: {type(user_id)}")
+        logger.info(f"Department ID: {self._id}, Department name: {self.name}")
+        logger.info(f"Current members before adding: {self.members}")
+        
         # Convert user_id to ObjectId if it's a string
         user_id_obj = ObjectId(user_id) if isinstance(user_id, str) else user_id
+        logger.info(f"Converted user_id to ObjectId: {user_id_obj}, type: {type(user_id_obj)}")
         
         # Check if this user is already in the members array
         for member in self.members:
             if str(member) == str(user_id_obj):
                 # User already exists in members array
+                logger.info(f"User {user_id_obj} already exists in members array, skipping")
                 return True
             
         # Add the user to members
         self.members.append(user_id_obj)
+        logger.info(f"Added user {user_id_obj} to members array")
+        logger.info(f"Members after adding: {self.members}")
         
         # Save changes to database
         departments_collection = get_departments_collection()
         
         # Directly update the members array using $push to avoid issues with _id
+        logger.info(f"Updating database with $push operation for department {self._id}")
         result = departments_collection.update_one(
             {"_id": ObjectId(self._id)},
             {"$push": {"members": user_id_obj}}
         )
         
-        return result.modified_count > 0
+        success = result.modified_count > 0
+        logger.info(f"Database update result: modified_count={result.modified_count}, success={success}")
+        
+        return success
     
     def remove_member(self, user_id):
         """Remove a member from department"""

models/user.py

@@ -2,6 +2,7 @@ import bcrypt
 from bson import ObjectId
 from datetime import datetime
 from db import get_users_collection
+import logging
 
 class User:
     def __init__(self, email, name, password=None, permissions="User", position="Officer", 
@@ -114,9 +115,42 @@ class User:
     @classmethod
     def find_by_department(cls, department_id):
         """Find all users in a department"""
+        logger = logging.getLogger(__name__)
+        
+        # Log the input department_id
+        logger.info(f"find_by_department called with department_id: {department_id}, type: {type(department_id)}")
+        
+        # Ensure department_id is an ObjectId
+        department_id_obj = ObjectId(department_id) if isinstance(department_id, str) else department_id
+        logger.info(f"Converted department_id to ObjectId: {department_id_obj}, type: {type(department_id_obj)}")
+        
+        # Get all users and log their count
         users_collection = get_users_collection()
-        users_data = users_collection.find({"department_id": ObjectId(department_id)})
-        return [cls.from_dict(user_data) for user_data in users_data]
+        all_users = list(users_collection.find())
+        logger.info(f"Total users in database: {len(all_users)}")
+        
+        # Log some details about each user's department_id for debugging
+        for user in all_users:
+            user_dept_id = user.get('department_id')
+            logger.info(f"User {user.get('_id')} has department_id: {user_dept_id}, type: {type(user_dept_id)}")
+            
+            # Check if the department_id matches as string
+            if user_dept_id:
+                str_match = str(user_dept_id) == str(department_id_obj)
+                obj_match = user_dept_id == department_id_obj
+                logger.info(f"  String comparison match: {str_match}, Object comparison match: {obj_match}")
+        
+        # Execute the find query
+        query = {"department_id": department_id_obj}
+        logger.info(f"Executing MongoDB query: {query}")
+        users_data = users_collection.find(query)
+        
+        # Convert to list to get count and log result
+        users_list = list(users_data)
+        logger.info(f"Found {len(users_list)} users with department_id {department_id_obj}")
+        
+        # Convert to User objects and return
+        return [cls.from_dict(user_data) for user_data in users_list]
 
     @classmethod
     def get_all(cls):

routes/department_routes.py

@@ -2,7 +2,8 @@ from flask import Blueprint
 from controllers.department_controller import (
     create_department, get_department, update_department,
     delete_department, get_all_departments, add_members_csv,
-    add_member, get_department_members, remove_member, update_member_permissions
+    add_member, get_department_members, remove_member, update_member_permissions,
+    debug_department
 )
 from utils.auth import token_required, admin_required
 
@@ -27,4 +28,7 @@ department_bp.route('/<department_id>/members', methods=['GET'])(token_required(
 department_bp.route('/<department_id>/members', methods=['POST'])(admin_required(add_member))
 department_bp.route('/<department_id>/members/csv', methods=['POST'])(admin_required(add_members_csv))
 department_bp.route('/<department_id>/members/<user_id>', methods=['DELETE'])(admin_required(remove_member))
-department_bp.route('/<department_id>/members/<user_id>/permissions', methods=['PUT'])(admin_required(update_member_permissions)) 
+department_bp.route('/<department_id>/members/<user_id>/permissions', methods=['PUT'])(admin_required(update_member_permissions))
+
+# Debug route
+department_bp.route('/<department_id>/debug', methods=['GET'])(token_required(debug_department))