Update main.py

main.py

@@ -18,98 +18,67 @@ CORS(app, resources={r"/api/*": {"origins": "*"}})
 
 # --- Firebase Initialization (Firestore) ---
 try:
-    # 1. Load credentials from environment variable
     credentials_json_string = os.environ.get("FIREBASE")
     if not credentials_json_string:
         raise ValueError("The FIREBASE environment variable is not set.")
     
-    # 2. Parse the JSON string into a dictionary
     credentials_json = json.loads(credentials_json_string)
-    
-    # 3. Create a credential object
     cred = credentials.Certificate(credentials_json)
     
-    # 4. Initialize the app if not already done
     if not firebase_admin._apps:
         firebase_admin.initialize_app(cred)
         logging.info("Firebase Admin SDK initialized successfully.")
     
-    # 5. Get a Firestore client instance
     db = firestore.client()
 
 except Exception as e:
     logging.critical(f"FATAL: Error initializing Firebase: {e}")
-    # In a real deployment, this would cause the container/process to exit
     exit(1)
 
-
-
-
-
-
 # -----------------------------------------------------------------------------
 # 2. AUTHORIZATION MIDDLEWARE (HELPER FUNCTIONS)
 # -----------------------------------------------------------------------------
 
 def verify_token(auth_header):
-    """Verifies the Firebase ID token from the Authorization header."""
+    """Verifies the Firebase ID token and returns the user's UID."""
     if not auth_header or not auth_header.startswith('Bearer '):
         return None
     token = auth_header.split('Bearer ')[1]
     try:
-        decoded_token = auth.verify_id_token(token)
-        return decoded_token['uid']
+        return auth.verify_id_token(token)['uid']
     except Exception as e:
         logging.warning(f"Token verification failed: {e}")
         return None
 
 def verify_admin_and_get_uid(auth_header):
-    """
-    Verifies if the user is an admin based on our Firestore `users` collection.
-    Raises PermissionError if not authorized, otherwise returns admin UID.
-    """
+    """Verifies if the user is an admin and returns their UID."""
     uid = verify_token(auth_header)
     if not uid:
         raise PermissionError('Invalid or missing user token')
-    
-    user_ref = db.collection('users').document(uid)
-    user_doc = user_ref.get()
-
+    user_doc = db.collection('users').document(uid).get()
     if not user_doc.exists or not user_doc.to_dict().get('isAdmin', False):
         raise PermissionError('Admin access required')
     return uid
 
-
 # -----------------------------------------------------------------------------
 # 3. AUTHENTICATION & USER MANAGEMENT ENDPOINTS
 # -----------------------------------------------------------------------------
 
 @app.route('/api/auth/signup', methods=['POST'])
 def signup():
-    """Handles new user sign-up with email/password and creates their Firestore profile."""
+    """Handles new user sign-up."""
     try:
         data = request.get_json()
         email, password, display_name = data.get('email'), data.get('password'), data.get('displayName')
 
-        if not email or not password or not display_name:
+        if not all([email, password, display_name]):
             return jsonify({'error': 'Email, password, and display name are required'}), 400
 
-        # Step 1: Create the user in Firebase Authentication
-        user = auth.create_user(
-            email=email,
-            password=password,
-            display_name=display_name
-        )
+        user = auth.create_user(email=email, password=password, display_name=display_name)
         
-        # Step 2: Create the corresponding user profile in the Firestore 'users' collection
         user_data = {
-            'uid': user.uid,
-            'email': email,
-            'displayName': display_name,
-            'isAdmin': False,
-            'phone': None,
-            'phoneStatus': 'unsubmitted', # Initial status
-            'organizationId': None,
+            'uid': user.uid, 'email': email, 'displayName': display_name, 'isAdmin': False,
+            'phone': None, 'phoneStatus': 'unsubmitted', 'organizationId': None,
             'createdAt': firestore.SERVER_TIMESTAMP
         }
         db.collection('users').document(user.uid).set(user_data)
@@ -127,33 +96,23 @@ def signup():
 def social_signin():
     """Ensures a user record exists in Firestore after a social login."""
     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_ref = db.collection('users').document(uid)
     user_doc = user_ref.get()
 
     if user_doc.exists:
-        # User already exists, return their profile
         return jsonify({'uid': uid, **user_doc.to_dict()}), 200
     else:
-        # This is a new user (first social login), create their full profile in Firestore.
         logging.info(f"New social user detected: {uid}. Creating database profile.")
         try:
             firebase_user = auth.get_user(uid)
             new_user_data = {
-                'uid': uid,
-                'email': firebase_user.email,
-                'displayName': firebase_user.display_name,
-                'isAdmin': False,
-                'phone': None,
-                'phoneStatus': 'unsubmitted',
-                'organizationId': None,
+                'uid': uid, 'email': firebase_user.email, 'displayName': firebase_user.display_name,
+                'isAdmin': False, 'phone': None, 'phoneStatus': 'unsubmitted', 'organizationId': None,
                 'createdAt': firestore.SERVER_TIMESTAMP
             }
             user_ref.set(new_user_data)
-            
-            logging.info(f"Successfully created profile for new social user: {uid}")
             return jsonify({'success': True, 'uid': uid, **new_user_data}), 201
         except Exception as e:
             logging.error(f"Error creating profile for new social user {uid}: {e}")
@@ -167,12 +126,10 @@ def social_signin():
 def get_user_profile():
     """Retrieves the logged-in user's profile from Firestore."""
     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_doc = db.collection('users').document(uid).get()
-    if not user_doc.exists:
-        return jsonify({'error': 'User profile not found in database'}), 404
+    if not user_doc.exists: return jsonify({'error': 'User profile not found in database'}), 404
     
     return jsonify({'uid': uid, **user_doc.to_dict()})
 
@@ -180,8 +137,7 @@ def get_user_profile():
 def update_user_phone():
     """Allows a user to submit their WhatsApp phone number for admin approval."""
     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
 
     data = request.get_json()
     phone_number = data.get('phone')
@@ -190,68 +146,53 @@ def update_user_phone():
         return jsonify({'error': 'A valid phone number is required.'}), 400
 
     try:
-        user_ref = db.collection('users').document(uid)
-        user_ref.update({
-            'phone': phone_number,
-            'phoneStatus': 'pending'
-        })
-        
+        db.collection('users').document(uid).update({'phone': phone_number, 'phoneStatus': 'pending'})
         logging.info(f"User {uid} submitted phone number {phone_number} for approval.")
         return jsonify({'success': True, 'message': 'Phone number submitted for approval.'}), 200
-
     except Exception as e:
         logging.error(f"Error updating phone for user {uid}: {e}")
         return jsonify({'error': 'Failed to update phone number'}), 500
 
 @app.route('/api/user/dashboard', methods=['GET'])
 def get_user_dashboard():
-    """
-    Retrieves and aggregates data for the logged-in user's dashboard.
-    This endpoint reads from the bot's data collections.
-    """
+    """Retrieves and aggregates data for the user's dashboard with correct profit calculation."""
     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
 
-    # Get the user's phone number from their main profile
     user_doc = db.collection('users').document(uid).get()
-    if not user_doc.exists:
-        return jsonify({'error': 'User not found'}), 404
+    if not user_doc.exists: return jsonify({'error': 'User not found'}), 404
 
     user_data = user_doc.to_dict()
     if user_data.get('phoneStatus') != 'approved':
-        return jsonify({'error': 'Your phone number is not yet approved. Bot data is unavailable.'}), 403
+        return jsonify({'error': 'Your phone number is not yet approved.'}), 403
 
     phone_number = user_data.get('phone')
-    if not phone_number:
-        return jsonify({'error': 'No phone number is associated with your account.'}), 404
+    if not phone_number: return jsonify({'error': 'No phone number is associated with your account.'}), 404
     
     try:
-        # The phone number is the document ID in the bot's user collection
         bot_user_ref = db.collection('users').document(phone_number)
         
-        # Fetch data from sub-collections
         sales_docs = bot_user_ref.collection('sales').stream()
-        expenses_docs = bot_user_ref.collection('expenses').stream()
-
-        # Aggregate data
-        total_sales = 0
-        total_expenses = 0
-        sales_count = 0
+        total_sales_revenue, total_cogs, sales_count = 0, 0, 0
         for doc in sales_docs:
             details = doc.to_dict().get('details', {})
-            total_sales += float(details.get('price', 0))
+            total_sales_revenue += float(details.get('price', 0))
+            total_cogs += float(details.get('cost', 0))
             sales_count += 1
         
-        for doc in expenses_docs:
-            details = doc.to_dict().get('details', {})
-            total_expenses += float(details.get('amount', 0))
+        expenses_docs = bot_user_ref.collection('expenses').stream()
+        total_expenses = sum(float(doc.to_dict().get('details', {}).get('amount', 0)) for doc in expenses_docs)
+
+        gross_profit = total_sales_revenue - total_cogs
+        net_profit = gross_profit - total_expenses
             
         dashboard_data = {
-            'totalSalesAmount': total_sales,
-            'totalSalesCount': sales_count,
-            'totalExpensesAmount': total_expenses,
-            'net': total_sales - total_expenses
+            'totalSalesRevenue': round(total_sales_revenue, 2),
+            'totalCostOfGoodsSold': round(total_cogs, 2),
+            'grossProfit': round(gross_profit, 2),
+            'totalExpenses': round(total_expenses, 2),
+            'netProfit': round(net_profit, 2),
+            'salesCount': sales_count,
         }
         return jsonify(dashboard_data), 200
         
@@ -260,85 +201,307 @@ def get_user_dashboard():
         return jsonify({'error': 'An error occurred while fetching your dashboard data.'}), 500
 
 # -----------------------------------------------------------------------------
-# 5. ADMIN ENDPOINTS
+# 5. ADMIN USER MANAGEMENT (FULL CRUD)
 # -----------------------------------------------------------------------------
 
 @app.route('/api/admin/users', methods=['GET'])
 def get_all_users():
-    """Admin endpoint to retrieve a list of all users."""
+    """Admin: Retrieve a list of all users."""
     try:
         verify_admin_and_get_uid(request.headers.get('Authorization'))
-        
-        users_ref = db.collection('users')
-        all_users = [doc.to_dict() for doc in users_ref.stream()]
-        
+        all_users = [doc.to_dict() for doc in db.collection('users').stream()]
         return jsonify(all_users), 200
-    except PermissionError as e:
-        return jsonify({'error': str(e)}), 403
+    except PermissionError as e: return jsonify({'error': str(e)}), 403
     except Exception as e:
         logging.error(f"Admin failed to fetch all users: {e}")
         return jsonify({'error': 'An internal error occurred'}), 500
 
+@app.route('/api/admin/users/<string:target_uid>', methods=['GET'])
+def get_single_user(target_uid):
+    """Admin: Get the detailed profile of a single user."""
+    try:
+        verify_admin_and_get_uid(request.headers.get('Authorization'))
+        user_doc = db.collection('users').document(target_uid).get()
+        if not user_doc.exists: return jsonify({'error': 'User not found'}), 404
+        return jsonify(user_doc.to_dict()), 200
+    except PermissionError as e: return jsonify({'error': str(e)}), 403
+    except Exception as e:
+        logging.error(f"Admin failed to fetch user {target_uid}: {e}")
+        return jsonify({'error': 'An internal error occurred'}), 500
+
+@app.route('/api/admin/users/<string:target_uid>', methods=['PUT'])
+def admin_update_user(target_uid):
+    """Admin: Update a user's profile information."""
+    try:
+        verify_admin_and_get_uid(request.headers.get('Authorization'))
+        data = request.get_json()
+        update_data = {}
+        if 'displayName' in data: update_data['displayName'] = data['displayName']
+        if 'phone' in data: update_data['phone'] = data['phone']
+        if 'isAdmin' in data: update_data['isAdmin'] = data['isAdmin']
+        if not update_data: return jsonify({'error': 'No update data provided'}), 400
+        db.collection('users').document(target_uid).update(update_data)
+        logging.info(f"Admin updated profile for user {target_uid}")
+        return jsonify({'success': True, 'message': 'User profile updated'}), 200
+    except PermissionError as e: return jsonify({'error': str(e)}), 403
+    except Exception as e:
+        logging.error(f"Admin failed to update user {target_uid}: {e}")
+        return jsonify({'error': 'An internal error occurred'}), 500
+
+@app.route('/api/admin/users/<string:target_uid>', methods=['DELETE'])
+def admin_delete_user(target_uid):
+    """Admin: Delete a user from Auth and Firestore."""
+    try:
+        verify_admin_and_get_uid(request.headers.get('Authorization'))
+        auth.delete_user(target_uid)
+        db.collection('users').document(target_uid).delete()
+        logging.info(f"Admin deleted user {target_uid} from Auth and Firestore.")
+        return jsonify({'success': True, 'message': 'User deleted successfully'}), 200
+    except PermissionError as e: return jsonify({'error': str(e)}), 403
+    except Exception as e:
+        logging.error(f"Admin failed to delete user {target_uid}: {e}")
+        return jsonify({'error': 'An internal error occurred during deletion'}), 500
+
 @app.route('/api/admin/users/approve', methods=['POST'])
 def approve_user_phone():
-    """Admin endpoint to approve a user's phone number."""
+    """Admin: Approve a user's phone number, enabling bot access."""
     try:
         verify_admin_and_get_uid(request.headers.get('Authorization'))
         data = request.get_json()
         target_uid = data.get('uid')
-        if not target_uid:
-            return jsonify({'error': 'User UID is required'}), 400
-
+        if not target_uid: return jsonify({'error': 'User UID is required'}), 400
         user_ref = db.collection('users').document(target_uid)
         user_doc = user_ref.get()
-        if not user_doc.exists:
-            return jsonify({'error': 'User to approve not found'}), 404
+        if not user_doc.exists: return jsonify({'error': 'User not found'}), 404
+        phone_number = user_doc.to_dict().get('phone')
+        if not phone_number: return jsonify({'error': 'User has no phone number submitted'}), 400
+        batch = db.batch()
+        batch.update(user_ref, {'phoneStatus': 'approved'})
+        batch.set(db.collection('users').document(phone_number), {'status': 'approved'}, merge=True)
+        batch.commit()
+        return jsonify({'success': True, 'message': f'User {target_uid} approved.'}), 200
+    except PermissionError as e: return jsonify({'error': str(e)}), 403
+    except Exception as e:
+        logging.error(f"Admin approval failed for user {data.get('uid')}: {e}")
+        return jsonify({'error': 'An internal error occurred'}), 500
         
-        user_data = user_doc.to_dict()
-        phone_number = user_data.get('phone')
-        if not phone_number:
-            return jsonify({'error': 'User has not submitted a phone number'}), 400
+# -----------------------------------------------------------------------------
+# 6. ORGANIZATION MANAGEMENT (FULL CRUD)
+# -----------------------------------------------------------------------------
 
-        # Create a batch for atomic writes
+@app.route('/api/organizations', methods=['POST'])
+def create_organization():
+    """A logged-in user creates a new organization."""
+    uid = verify_token(request.headers.get('Authorization'))
+    if not uid: return jsonify({'error': 'Invalid or expired token'}), 401
+    
+    data = request.get_json()
+    org_name = data.get('name')
+    if not org_name: return jsonify({'error': 'Organization name is required'}), 400
+
+    try:
+        org_ref = db.collection('organizations').document()
+        org_data = {
+            'id': org_ref.id, 'name': org_name, 'ownerUid': uid,
+            'members': [uid], 'createdAt': firestore.SERVER_TIMESTAMP
+        }
+        
         batch = db.batch()
+        batch.set(org_ref, org_data)
+        batch.update(db.collection('users').document(uid), {'organizationId': org_ref.id})
+        batch.commit()
+        
+        return jsonify(org_data), 201
+    except Exception as e:
+        logging.error(f"User {uid} failed to create organization: {e}")
+        return jsonify({'error': 'An internal error occurred'}), 500
 
-        # Write 1: Update the main user profile
-        batch.update(user_ref, {'phoneStatus': 'approved'})
+@app.route('/api/my-organization', methods=['GET'])
+def get_my_organization():
+    """A logged-in user retrieves details of their organization."""
+    uid = verify_token(request.headers.get('Authorization'))
+    if not uid: return jsonify({'error': 'Invalid or expired token'}), 401
+    
+    user_doc = db.collection('users').document(uid).get()
+    org_id = user_doc.to_dict().get('organizationId')
+    if not org_id: return jsonify({'error': 'User does not belong to an organization'}), 404
+    
+    org_doc = db.collection('organizations').document(org_id).get()
+    if not org_doc.exists: return jsonify({'error': 'Organization not found'}), 404
+    
+    return jsonify(org_doc.to_dict()), 200
 
-        # Write 2: Update the bot's user data document
-        bot_user_ref = db.collection('users').document(phone_number)
-        batch.set(bot_user_ref, {'status': 'approved'}, merge=True)
+# --- Admin Organization Endpoints ---
+
+@app.route('/api/admin/organizations', methods=['GET'])
+def get_all_organizations():
+    """Admin: Get a list of all organizations."""
+    try:
+        verify_admin_and_get_uid(request.headers.get('Authorization'))
+        orgs = [doc.to_dict() for doc in db.collection('organizations').stream()]
+        return jsonify(orgs), 200
+    except PermissionError as e: return jsonify({'error': str(e)}), 403
+    except Exception as e:
+        logging.error(f"Admin failed to fetch organizations: {e}")
+        return jsonify({'error': 'An internal error occurred'}), 500
+
+@app.route('/api/admin/organizations/<string:org_id>', methods=['PUT'])
+def admin_update_organization(org_id):
+    """Admin: Update an organization's name."""
+    try:
+        verify_admin_and_get_uid(request.headers.get('Authorization'))
+        data = request.get_json()
+        new_name = data.get('name')
+        if not new_name: return jsonify({'error': 'New name is required'}), 400
+        db.collection('organizations').document(org_id).update({'name': new_name})
+        return jsonify({'success': True, 'message': 'Organization updated'}), 200
+    except PermissionError as e: return jsonify({'error': str(e)}), 403
+    except Exception as e:
+        logging.error(f"Admin failed to update organization {org_id}: {e}")
+        return jsonify({'error': 'An internal error occurred'}), 500
         
-        # Commit both writes
+@app.route('/api/admin/organizations/<string:org_id>', methods=['DELETE'])
+def admin_delete_organization(org_id):
+    """Admin: Delete an organization and clean up member profiles."""
+    try:
+        verify_admin_and_get_uid(request.headers.get('Authorization'))
+        org_ref = db.collection('organizations').document(org_id)
+        org_doc = org_ref.get()
+        if not org_doc.exists: return jsonify({'error': 'Organization not found'}), 404
+        
+        members = org_doc.to_dict().get('members', [])
+        for member_uid in members:
+            db.collection('users').document(member_uid).update({'organizationId': None})
+            
+        org_ref.delete()
+        return jsonify({'success': True, 'message': 'Organization deleted'}), 200
+    except PermissionError as e: return jsonify({'error': str(e)}), 403
+    except Exception as e:
+        logging.error(f"Admin failed to delete organization {org_id}: {e}")
+        return jsonify({'error': 'An internal error occurred'}), 500
+
+@app.route('/api/admin/organizations/<string:org_id>/members', methods=['POST'])
+def admin_add_member_to_org(org_id):
+    """Admin: Add a user to an organization."""
+    try:
+        verify_admin_and_get_uid(request.headers.get('Authorization'))
+        data = request.get_json()
+        member_uid = data.get('uid')
+        if not member_uid: return jsonify({'error': 'User UID is required'}), 400
+
+        batch = db.batch()
+        batch.update(db.collection('organizations').document(org_id), {'members': firestore.ArrayUnion([member_uid])})
+        batch.update(db.collection('users').document(member_uid), {'organizationId': org_id})
         batch.commit()
+        return jsonify({'success': True, 'message': 'Member added'}), 200
+    except PermissionError as e: return jsonify({'error': str(e)}), 403
+    except Exception as e:
+        logging.error(f"Admin failed to add member to org {org_id}: {e}")
+        return jsonify({'error': 'An internal error occurred'}), 500
+
+@app.route('/api/admin/organizations/<string:org_id>/members/<string:member_uid>', methods=['DELETE'])
+def admin_remove_member_from_org(org_id, member_uid):
+    """Admin: Remove a user from an organization."""
+    try:
+        verify_admin_and_get_uid(request.headers.get('Authorization'))
+        batch = db.batch()
+        batch.update(db.collection('organizations').document(org_id), {'members': firestore.ArrayRemove([member_uid])})
+        batch.update(db.collection('users').document(member_uid), {'organizationId': None})
+        batch.commit()
+        return jsonify({'success': True, 'message': 'Member removed'}), 200
+    except PermissionError as e: return jsonify({'error': str(e)}), 403
+    except Exception as e:
+        logging.error(f"Admin failed to remove member from org {org_id}: {e}")
+        return jsonify({'error': 'An internal error occurred'}), 500
+
+# -----------------------------------------------------------------------------
+# 7. ADMIN DASHBOARD ENDPOINT (INCLUDED)
+# -----------------------------------------------------------------------------
+
+@app.route('/api/admin/dashboard/stats', methods=['GET'])
+def get_admin_dashboard_stats():
+    """Retrieves global statistics for the admin dashboard with correct profit calculation."""
+    try:
+        verify_admin_and_get_uid(request.headers.get('Authorization'))
+
+        # --- User and Organization Statistics ---
+        all_users_docs = list(db.collection('users').stream())
+        all_orgs_docs = list(db.collection('organizations').stream())
         
-        logging.info(f"Admin approved phone {phone_number} for user {target_uid}")
-        return jsonify({'success': True, 'message': f'User {target_uid} approved.'}), 200
+        pending_approvals, approved_users, admin_count = 0, 0, 0
+        approved_phone_numbers = []
+
+        for doc in all_users_docs:
+            user_data = doc.to_dict()
+            if user_data.get('phoneStatus') == 'pending':
+                pending_approvals += 1
+            elif user_data.get('phoneStatus') == 'approved':
+                approved_users += 1
+                if user_data.get('phone'):
+                    approved_phone_numbers.append(user_data.get('phone'))
+            if user_data.get('isAdmin', False):
+                admin_count += 1
+        
+        user_stats = {
+            'total': len(all_users_docs),
+            'admins': admin_count,
+            'approvedForBot': approved_users,
+            'pendingApproval': pending_approvals,
+        }
+        
+        org_stats = {'total': len(all_orgs_docs)}
+
+        # --- Global Bot Data Financial Statistics (Corrected Logic) ---
+        # Note: This reads from many collections and can be slow at large scale.
+        # For production, consider using Firebase Functions to aggregate this data periodically.
+        total_sales_revenue, total_cogs, total_expenses, sales_count = 0, 0, 0, 0
+        
+        for phone in approved_phone_numbers:
+            bot_user_ref = db.collection('users').document(phone)
+            sales_docs = bot_user_ref.collection('sales').stream()
+            for sale_doc in sales_docs:
+                details = sale_doc.to_dict().get('details', {})
+                total_sales_revenue += float(details.get('price', 0))
+                total_cogs += float(details.get('cost', 0))
+                sales_count += 1
+            
+            expenses_docs = bot_user_ref.collection('expenses').stream()
+            total_expenses += sum(float(doc.to_dict().get('details', {}).get('amount', 0)) for doc in expenses_docs)
+        
+        gross_profit = total_sales_revenue - total_cogs
+        net_profit = gross_profit - total_expenses
+        
+        system_stats = {
+            'totalSalesRevenue': round(total_sales_revenue, 2),
+            'totalCostOfGoodsSold': round(total_cogs, 2),
+            'totalExpenses': round(total_expenses, 2),
+            'totalNetProfit': round(net_profit, 2),
+            'totalSalesCount': sales_count,
+        }
+
+        return jsonify({
+            'userStats': user_stats, 
+            'organizationStats': org_stats,
+            'systemStats': system_stats
+        }), 200
 
     except PermissionError as e:
         return jsonify({'error': str(e)}), 403
     except Exception as e:
-        logging.error(f"Admin approval failed for user {data.get('uid')}: {e}")
-        return jsonify({'error': 'An internal error occurred during approval'}), 500
-
-# Additional admin endpoints like 'reject', 'create_user', 'stats' can be added here
-# following the same pattern.
+        logging.error(f"Admin failed to fetch dashboard stats: {e}", exc_info=True)
+        return jsonify({'error': 'An internal error occurred while fetching stats'}), 500
 
 # -----------------------------------------------------------------------------
-# 6. SERVER EXECUTION
+# 8. SERVER EXECUTION
 # -----------------------------------------------------------------------------
 
 if __name__ == '__main__':
     port = int(os.environ.get("PORT", 7860))
     debug_mode = os.environ.get("FLASK_DEBUG", "False").lower() == "true"
-    logging.info(f"Starting Flask app. Debug mode: {debug_mode}, Port: {port}")
-    if not db:
-         logging.critical("Firestore client failed to initialize. Application cannot run.")
+    
+    logging.info(f"Starting Dashboard Server. Debug mode: {debug_mode}, Port: {port}")
+    if not debug_mode:
+        from waitress import serve
+        serve(app, host="0.0.0.0", port=port)
     else:
-         if not debug_mode:
-              from waitress import serve
-              logging.info("Running in production mode using Waitress.")
-              serve(app, host="0.0.0.0", port=port)
-         else:
-              logging.info("Running in debug mode using Flask development server.")
-              app.run(debug=True, host="0.0.0.0", port=port)
+        app.run(debug=True, host="0.0.0.0", port=port)