"Update space"

Signed-off-by: Emmanuel Frimpong Asante <[email protected]>

controllers/data_logging.py

@@ -7,7 +7,7 @@ from models.schemas.inventory_schema import create_inventory_item, update_invent
 from models.schemas.usage_schema import create_usage_record
 
 
-# Log a general user action (e.g., a user performs an action in the system)
+# Log a general user action
 def log_user_action(user_id, message, level="INFO", metadata=None):
     """
     Logs a general user action.
@@ -15,15 +15,17 @@ def log_user_action(user_id, message, level="INFO", metadata=None):
     :param user_id: The ID of the user performing the action.
     :param message: Description of the action.
     :param level: Log level (default is "INFO").
-    :param metadata: Additional information about the action.
-    :return: JSON response indicating success or failure.
+    :param metadata: Additional metadata or context for the action.
+    :return: JSON response with log creation result.
     """
     try:
-        ip_address = request.remote_addr  # Get the user's IP address from the request
+        ip_address = request.remote_addr  # Capture user's IP address
         log_id = create_log(level, message, metadata, ip_address, user_id)
         return jsonify({"message": "Action logged successfully", "log_id": log_id}), 201
+    except KeyError as e:
+        return jsonify({"error": f"Missing field: {str(e)}"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500
 
 
 # Log a health record for a poultry bird
@@ -31,86 +33,104 @@ def log_health_record(user_id, poultry_id, disease_name, status, recommendation,
     """
     Logs a health record for a poultry bird.
 
-    :param user_id: The ID of the user managing the poultry.
-    :param poultry_id: The unique identifier for the poultry bird.
-    :param disease_name: The name of the detected disease.
-    :param status: The health status of the bird (e.g., "Critical", "No issue").
-    :param recommendation: The recommended treatment or action.
-    :param image_path: Optional. The path to an image related to the health record.
-    :return: JSON response indicating success or failure.
+    :param user_id: ID of the user managing the poultry.
+    :param poultry_id: Unique identifier for the poultry.
+    :param disease_name: Detected disease name.
+    :param status: Health status of the poultry.
+    :param recommendation: Recommended treatment or action.
+    :param image_path: Optional image related to the health record.
+    :return: JSON response with health record logging result.
     """
     try:
+        # Create health record in database
         record_id = create_health_record(user_id, poultry_id, disease_name, status, recommendation, image_path)
-        # Log the health record creation action
+
+        # Log action for health record creation
         log_message = f"Health record created for poultry ID {poultry_id} - Disease: {disease_name}"
         log_user_action(user_id, log_message, "INFO")
+
         return jsonify({"message": "Health record logged successfully", "record_id": record_id}), 201
+    except KeyError as e:
+        return jsonify({"error": f"Missing field: {str(e)}"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500
 
 
 # Log an addition to the inventory
 def log_inventory_addition(user_id, item_name, category, quantity, unit, description=None):
     """
-    Logs an inventory addition (e.g., adding feed, medicine).
-
-    :param user_id: The ID of the user managing the inventory.
-    :param item_name: The name of the inventory item.
-    :param category: The category of the item (e.g., "Feed", "Medicine").
-    :param quantity: The quantity added.
-    :param unit: The unit of measurement (e.g., "kg", "liters").
-    :param description: Optional. Additional notes or description of the item.
-    :return: JSON response indicating success or failure.
+    Logs an inventory addition (e.g., adding feed or medicine).
+
+    :param user_id: ID of the user managing the inventory.
+    :param item_name: Name of the inventory item.
+    :param category: Category of the item (e.g., "Feed", "Medicine").
+    :param quantity: Quantity added.
+    :param unit: Unit of measurement (e.g., "kg", "liters").
+    :param description: Optional notes or description of the item.
+    :return: JSON response with inventory addition result.
     """
     try:
-        item_id = create_inventory_item(item_name, category, quantity, unit, user_id, description=description)
-        # Log the inventory addition action
+        # Add inventory item to database
+        item_id = create_inventory_item(item_name, category, quantity, unit, user_id, description)
+
+        # Log action for inventory addition
         log_message = f"Inventory item added: {item_name}, Quantity: {quantity} {unit}"
         log_user_action(user_id, log_message, "INFO")
+
         return jsonify({"message": "Inventory item logged successfully", "item_id": item_id}), 201
+    except KeyError as e:
+        return jsonify({"error": f"Missing field: {str(e)}"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500
 
 
-# Log updates to an inventory item (e.g., usage or quantity adjustment)
+# Log updates to an inventory item
 def log_inventory_update(user_id, item_id, updated_fields):
     """
-    Logs an update to an inventory item (e.g., when quantity is used).
+    Logs updates to an existing inventory item.
 
-    :param user_id: The ID of the user managing the inventory.
-    :param item_id: The ID of the inventory item being updated.
-    :param updated_fields: The fields to be updated (e.g., "used_quantity", "quantity").
-    :return: JSON response indicating success or failure.
+    :param user_id: ID of the user managing the inventory.
+    :param item_id: ID of the inventory item being updated.
+    :param updated_fields: Dictionary containing updated fields (e.g., "quantity", "used_quantity").
+    :return: JSON response with inventory update result.
     """
     try:
+        # Update inventory item in database
         update_success = update_inventory_item(item_id, updated_fields)
         if update_success:
-            # Log the inventory update action
+            # Log action for inventory update
             log_message = f"Inventory item updated: {item_id} - {updated_fields}"
             log_user_action(user_id, log_message, "INFO")
             return jsonify({"message": "Inventory item updated successfully"}), 200
         else:
             return jsonify({"message": "Inventory item update failed"}), 400
+    except KeyError as e:
+        return jsonify({"error": f"Missing field: {str(e)}"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500
 
 
 # Log assistant usage by a user
 def log_assistant_usage(user_id, manager_id, interaction_type, metadata=None):
     """
-    Logs the usage of the assistant by a user.
+    Logs usage of the assistant by a user.
 
-    :param user_id: The ID of the user interacting with the assistant.
-    :param manager_id: The ID of the manager overseeing the user.
-    :param interaction_type: The type of interaction (e.g., "disease_detection", "inventory_management").
-    :param metadata: Optional. Additional details about the interaction.
-    :return: JSON response indicating success or failure.
+    :param user_id: ID of the user interacting with the assistant.
+    :param manager_id: ID of the user's manager.
+    :param interaction_type: Type of interaction (e.g., "disease_detection", "inventory_management").
+    :param metadata: Optional additional details about the interaction.
+    :return: JSON response with assistant usage logging result.
     """
     try:
+        # Log assistant usage in database
         usage_record_id = create_usage_record(user_id, manager_id, interaction_type, metadata)
-        # Log the assistant usage action
+
+        # Log action for assistant usage
         log_message = f"Assistant interaction logged: {interaction_type} by user {user_id}"
         log_user_action(user_id, log_message, "INFO", metadata)
+
         return jsonify({"message": "Assistant usage logged successfully", "usage_record_id": usage_record_id}), 201
+    except KeyError as e:
+        return jsonify({"error": f"Missing field: {str(e)}"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500

controllers/health_management.py

@@ -5,29 +5,28 @@ from models.schemas.health_schema import create_health_record, get_health_record
 from services.disease_detection import detect_disease
 from controllers.data_logging import log_health_record
 
-
 # Detect Disease and Log Health Record
 def detect_and_log_disease():
     """
-    Detect disease from the provided image and log the health record.
-    Expects a POST request with the following fields:
+    Detects disease from the provided image and logs the health record.
+    Expects a POST request with:
     - user_id: ID of the user submitting the disease detection request.
-    - poultry_id: The ID of the poultry bird.
+    - poultry_id: ID of the poultry bird.
     - image: Image of the poultry feces for disease detection (binary file).
 
     Returns:
     - JSON response with the disease detection result and health record logging status.
     """
     try:
-        # Extract the data from the request
+        # Validate the input
         user_id = request.form.get('user_id')
         poultry_id = request.form.get('poultry_id')
         image = request.files.get('image')
 
-        if not user_id or not poultry_id or not image:
+        if not all([user_id, poultry_id, image]):
             return jsonify({"error": "Missing required fields: user_id, poultry_id, or image"}), 400
 
-        # Run disease detection
+        # Detect disease
         disease_name, status, recommendation = detect_disease(image)
 
         # Log the health record
@@ -47,8 +46,12 @@ def detect_and_log_disease():
             "record_id": record_id
         }), 201
 
+    except KeyError as e:
+        # Specific handling for missing fields
+        return jsonify({"error": f"Missing field in request: {str(e)}"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        # General error handling
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500
 
 
 # Get Health Record by ID
@@ -65,12 +68,14 @@ def get_health_record(record_id):
     try:
         health_record = get_health_record_by_id(record_id)
         if not health_record:
-            return jsonify({"message": "Health record not found"}), 404
+            return jsonify({"error": "Health record not found"}), 404
 
         return jsonify(health_record), 200
 
+    except ValueError:
+        return jsonify({"error": "Invalid record ID format"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500
 
 
 # Get Health Records by User
@@ -82,14 +87,16 @@ def get_health_records_for_user(user_id):
     - user_id: ID of the user whose records are being requested.
 
     Returns:
-    - JSON response with the list of health records for the user or an error message if not found.
+    - JSON response with the list of health records for the user or an error message if none are found.
     """
     try:
         health_records = get_health_records_by_user(user_id)
         if not health_records:
-            return jsonify({"message": "No health records found for this user"}), 404
+            return jsonify({"error": "No health records found for this user"}), 404
 
         return jsonify(health_records), 200
 
+    except ValueError:
+        return jsonify({"error": "Invalid user ID format"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500

controllers/inventory.py

@@ -1,8 +1,12 @@
 # controllers/inventory.py
 
 from flask import request, jsonify
-from models.schemas.inventory_schema import create_inventory_item, update_inventory_item, get_inventory_item_by_id, \
+from models.schemas.inventory_schema import (
+    create_inventory_item,
+    update_inventory_item,
+    get_inventory_item_by_id,
     get_all_inventory_items
+)
 from controllers.data_logging import log_inventory_addition, log_inventory_update
 
 
@@ -11,30 +15,34 @@ def add_inventory_item():
     """
     Adds a new inventory item to the system.
 
-    Expects:
+    Expects a POST request with:
     - user_id: The ID of the user adding the item.
-    - item_name: Name of the inventory item.
-    - category: Category of the item (e.g., "Feed", "Medicine").
-    - quantity: Total quantity of the item.
-    - unit: Unit of measurement (e.g., "kg", "liters").
-    - description: Optional. Additional notes or description about the item.
+    - item_name: The name of the inventory item.
+    - category: The category of the item (e.g., "Feed", "Medicine").
+    - quantity: The total quantity of the item.
+    - unit: The unit of measurement (e.g., "kg", "liters").
+    - description: Optional additional notes about the item.
 
     Returns:
     - JSON response with the result of the addition.
     """
     try:
-        # Extract data from the request
-        user_id = request.json.get('user_id')
-        item_name = request.json.get('item_name')
-        category = request.json.get('category')
-        quantity = request.json.get('quantity')
-        unit = request.json.get('unit')
-        description = request.json.get('description')
-
-        if not user_id or not item_name or not category or not quantity or not unit:
+        # Extract request data
+        data = request.json
+        required_fields = ['user_id', 'item_name', 'category', 'quantity', 'unit']
+
+        # Validate required fields
+        if not all(field in data for field in required_fields):
             return jsonify({"error": "Missing required fields"}), 400
 
-        # Add the inventory item
+        user_id = data['user_id']
+        item_name = data['item_name']
+        category = data['category']
+        quantity = data['quantity']
+        unit = data['unit']
+        description = data.get('description', '')
+
+        # Add the inventory item to the database
         item_id = create_inventory_item(item_name, category, quantity, unit, user_id, description)
 
         # Log the inventory addition
@@ -42,16 +50,18 @@ def add_inventory_item():
 
         return jsonify({"message": "Inventory item added successfully", "item_id": item_id}), 201
 
+    except KeyError as e:
+        return jsonify({"error": f"Missing field in request: {str(e)}"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500
 
 
 # Update an existing inventory item
 def update_inventory_item_by_id():
     """
-    Updates an existing inventory item.
+    Updates an existing inventory item in the system.
 
-    Expects:
+    Expects a PUT request with:
     - user_id: The ID of the user updating the item.
     - item_id: The ID of the inventory item to update.
     - updated_fields: Dictionary containing fields to update (e.g., "quantity", "used_quantity").
@@ -60,16 +70,18 @@ def update_inventory_item_by_id():
     - JSON response with the result of the update.
     """
     try:
-        # Extract data from the request
-        user_id = request.json.get('user_id')
-        item_id = request.json.get('item_id')
-        updated_fields = request.json.get('updated_fields')
+        # Extract request data
+        data = request.json
+        user_id = data.get('user_id')
+        item_id = data.get('item_id')
+        updated_fields = data.get('updated_fields')
 
-        if not user_id or not item_id or not updated_fields:
+        if not all([user_id, item_id, updated_fields]):
             return jsonify({"error": "Missing required fields"}), 400
 
-        # Update the inventory item
+        # Update the inventory item in the database
         update_success = update_inventory_item(item_id, updated_fields)
+
         if update_success:
             # Log the inventory update
             log_inventory_update(user_id, item_id, updated_fields)
@@ -77,8 +89,10 @@ def update_inventory_item_by_id():
         else:
             return jsonify({"message": "Inventory item update failed"}), 400
 
+    except KeyError as e:
+        return jsonify({"error": f"Missing field in request: {str(e)}"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500
 
 
 # Get an inventory item by its ID
@@ -87,7 +101,7 @@ def get_inventory_by_id(item_id):
     Retrieves an inventory item by its item_id (MongoDB ObjectId).
 
     Expects:
-    - item_id: ID of the inventory item.
+    - item_id: The ID of the inventory item.
 
     Returns:
     - JSON response with the inventory item details.
@@ -99,14 +113,16 @@ def get_inventory_by_id(item_id):
 
         return jsonify(inventory_item), 200
 
+    except ValueError:
+        return jsonify({"error": "Invalid item ID format"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500
 
 
 # Get all inventory items
 def get_all_inventory():
     """
-    Retrieves all inventory items.
+    Retrieves all inventory items in the system.
 
     Returns:
     - JSON response with the list of all inventory items.
@@ -119,4 +135,4 @@ def get_all_inventory():
         return jsonify(inventory_items), 200
 
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500

controllers/usage_tracking.py

@@ -1,8 +1,12 @@
 # controllers/usage_tracking.py
 
 from flask import request, jsonify
-from models.schemas.usage_schema import create_usage_record, get_usage_by_user, get_usage_by_manager, \
+from models.schemas.usage_schema import (
+    create_usage_record,
+    get_usage_by_user,
+    get_usage_by_manager,
     get_usage_by_interaction_type
+)
 from controllers.data_logging import log_assistant_usage
 
 
@@ -22,24 +26,31 @@ def log_usage():
     """
     try:
         # Extract data from the request
-        user_id = request.json.get('user_id')
-        manager_id = request.json.get('manager_id')
-        interaction_type = request.json.get('interaction_type')
-        metadata = request.json.get('metadata')
+        data = request.json
+        user_id = data.get('user_id')
+        manager_id = data.get('manager_id')
+        interaction_type = data.get('interaction_type')
+        metadata = data.get('metadata', {})
 
-        if not user_id or not manager_id or not interaction_type:
-            return jsonify({"error": "Missing required fields"}), 400
+        # Check for missing fields
+        if not all([user_id, manager_id, interaction_type]):
+            return jsonify({"error": "Missing required fields: 'user_id', 'manager_id', or 'interaction_type'"}), 400
 
-        # Log assistant usage
+        # Log assistant usage in the system
         usage_record_id = create_usage_record(user_id, manager_id, interaction_type, metadata)
 
-        # Log the usage in the system log
+        # Log the usage for auditing or tracking purposes
         log_assistant_usage(user_id, manager_id, interaction_type, metadata)
 
-        return jsonify({"message": "Assistant usage logged successfully", "usage_record_id": usage_record_id}), 201
+        return jsonify({
+            "message": "Assistant usage logged successfully",
+            "usage_record_id": usage_record_id
+        }), 201
 
+    except KeyError as e:
+        return jsonify({"error": f"Missing field in request: {str(e)}"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500
 
 
 # Get usage records by user
@@ -60,8 +71,10 @@ def get_usage_for_user(user_id):
 
         return jsonify(usage_records), 200
 
+    except ValueError:
+        return jsonify({"error": "Invalid user ID format"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500
 
 
 # Get usage records for all users managed by a specific manager
@@ -82,8 +95,10 @@ def get_usage_for_manager(manager_id):
 
         return jsonify(usage_records), 200
 
+    except ValueError:
+        return jsonify({"error": "Invalid manager ID format"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500
 
 
 # Get usage records by interaction type
@@ -104,5 +119,7 @@ def get_usage_by_type(interaction_type):
 
         return jsonify(usage_records), 200
 
+    except ValueError:
+        return jsonify({"error": f"Invalid interaction type: {interaction_type}"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500

routes/api.py

@@ -6,6 +6,10 @@ from controllers.inventory import add_inventory_item, update_inventory_item_by_i
     get_all_inventory
 from controllers.usage_tracking import log_usage, get_usage_for_user, get_usage_for_manager, get_usage_by_type
 from controllers.data_logging import log_user_action
+import logging
+
+# Initialize logger for API routes
+logger = logging.getLogger(__name__)
 
 # Create a Blueprint for the API routes
 api_bp = Blueprint('api', __name__)
@@ -14,66 +18,178 @@ api_bp = Blueprint('api', __name__)
 # Health Management Routes
 @api_bp.route('/detect-disease', methods=['POST'])
 def detect_disease_route():
-    return detect_and_log_disease()
+    """
+    Detect a disease and log the health record.
+    Expects a POST request with:
+    - user_id: ID of the user
+    - poultry_id: ID of the poultry
+    - image: Image of poultry feces for disease detection
+    """
+    try:
+        return detect_and_log_disease()
+    except Exception as e:
+        logger.error(f"Error detecting disease: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while detecting the disease."}), 500
 
 
 @api_bp.route('/health-record/<record_id>', methods=['GET'])
 def get_health_record_route(record_id):
-    return get_health_record(record_id)
+    """
+    Retrieve a health record by its ID.
+    """
+    try:
+        return get_health_record(record_id)
+    except Exception as e:
+        logger.error(f"Error fetching health record {record_id}: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while retrieving the health record."}), 500
 
 
 @api_bp.route('/health-records/<user_id>', methods=['GET'])
 def get_health_records_for_user_route(user_id):
-    return get_health_records_for_user(user_id)
+    """
+    Retrieve all health records for a specific user.
+    """
+    try:
+        return get_health_records_for_user(user_id)
+    except Exception as e:
+        logger.error(f"Error fetching health records for user {user_id}: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while retrieving health records."}), 500
 
 
 # Inventory Management Routes
 @api_bp.route('/add-inventory-item', methods=['POST'])
 def add_inventory_item_route():
-    return add_inventory_item()
+    """
+    Add a new inventory item.
+    Expects a POST request with:
+    - user_id: ID of the user
+    - item_name: Name of the inventory item
+    - category: Category of the item
+    - quantity: Total quantity
+    - unit: Unit of measurement
+    """
+    try:
+        return add_inventory_item()
+    except Exception as e:
+        logger.error(f"Error adding inventory item: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while adding the inventory item."}), 500
 
 
 @api_bp.route('/update-inventory-item', methods=['PUT'])
 def update_inventory_item_route():
-    return update_inventory_item_by_id()
+    """
+    Update an existing inventory item.
+    Expects a PUT request with:
+    - user_id: ID of the user
+    - item_id: ID of the inventory item
+    - updated_fields: Fields to be updated
+    """
+    try:
+        return update_inventory_item_by_id()
+    except Exception as e:
+        logger.error(f"Error updating inventory item: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while updating the inventory item."}), 500
 
 
 @api_bp.route('/inventory-item/<item_id>', methods=['GET'])
 def get_inventory_item_route(item_id):
-    return get_inventory_by_id(item_id)
+    """
+    Retrieve an inventory item by its ID.
+    """
+    try:
+        return get_inventory_by_id(item_id)
+    except Exception as e:
+        logger.error(f"Error fetching inventory item {item_id}: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while retrieving the inventory item."}), 500
 
 
 @api_bp.route('/inventory', methods=['GET'])
 def get_all_inventory_route():
-    return get_all_inventory()
+    """
+    Retrieve all inventory items.
+    """
+    try:
+        return get_all_inventory()
+    except Exception as e:
+        logger.error(f"Error fetching all inventory items: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while retrieving the inventory items."}), 500
 
 
 # Assistant Usage Tracking Routes
 @api_bp.route('/log-usage', methods=['POST'])
 def log_usage_route():
-    return log_usage()
+    """
+    Log the usage of the assistant by a user.
+    Expects a POST request with:
+    - user_id: ID of the user
+    - manager_id: ID of the manager
+    - interaction_type: Type of interaction (e.g., "disease_detection", "inventory_management")
+    """
+    try:
+        return log_usage()
+    except Exception as e:
+        logger.error(f"Error logging usage: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while logging the assistant usage."}), 500
 
 
 @api_bp.route('/usage/<user_id>', methods=['GET'])
 def get_usage_for_user_route(user_id):
-    return get_usage_for_user(user_id)
+    """
+    Retrieve all usage logs for a specific user.
+    """
+    try:
+        return get_usage_for_user(user_id)
+    except Exception as e:
+        logger.error(f"Error fetching usage logs for user {user_id}: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while retrieving usage logs for the user."}), 500
 
 
 @api_bp.route('/manager-usage/<manager_id>', methods=['GET'])
 def get_usage_for_manager_route(manager_id):
-    return get_usage_for_manager(manager_id)
+    """
+    Retrieve all usage logs for users managed by a specific manager.
+    """
+    try:
+        return get_usage_for_manager(manager_id)
+    except Exception as e:
+        logger.error(f"Error fetching usage logs for manager {manager_id}: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while retrieving usage logs for the manager."}), 500
 
 
 @api_bp.route('/usage-type/<interaction_type>', methods=['GET'])
 def get_usage_by_type_route(interaction_type):
-    return get_usage_by_type(interaction_type)
+    """
+    Retrieve all usage logs for a specific interaction type.
+    """
+    try:
+        return get_usage_by_type(interaction_type)
+    except Exception as e:
+        logger.error(f"Error fetching usage logs by interaction type {interaction_type}: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while retrieving usage logs for the interaction type."}), 500
 
 
 # User Action Logging Route
 @api_bp.route('/log-user-action', methods=['POST'])
 def log_user_action_route():
-    user_id = request.json.get('user_id')
-    message = request.json.get('message')
-    level = request.json.get('level', 'INFO')
-    metadata = request.json.get('metadata', {})
-    return log_user_action(user_id, message, level, metadata)
+    """
+    Log user actions with metadata.
+    Expects a POST request with:
+    - user_id: ID of the user performing the action
+    - message: Description of the action
+    - level: Logging level (default: "INFO")
+    - metadata: Optional metadata related to the action
+    """
+    try:
+        user_id = request.json.get('user_id')
+        message = request.json.get('message')
+        level = request.json.get('level', 'INFO')
+        metadata = request.json.get('metadata', {})
+
+        # Validate required fields
+        if not user_id or not message:
+            return jsonify({"error": "Missing required fields: user_id and message"}), 400
+
+        return log_user_action(user_id, message, level, metadata)
+    except Exception as e:
+        logger.error(f"Error logging user action: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while logging the user action."}), 500

routes/data_logging_routes.py

@@ -9,6 +9,10 @@ from controllers.data_logging import (
     log_inventory_update,
     log_assistant_usage
 )
+import logging
+
+# Initialize logger for data logging routes
+logger = logging.getLogger(__name__)
 
 # Create a Blueprint for the data logging routes
 data_logging_bp = Blueprint('data_logging', __name__)
@@ -17,23 +21,43 @@ data_logging_bp = Blueprint('data_logging', __name__)
 # Route to log user actions
 @data_logging_bp.route('/log-user-action', methods=['POST'])
 def log_user_action_route():
+    """
+    Log a user action with optional metadata.
+    Expects JSON input:
+    - user_id: ID of the user
+    - message: Action description
+    - level: Logging level (default: "INFO")
+    - metadata: Additional details (optional)
+    """
     try:
         user_id = request.json.get('user_id')
         message = request.json.get('message')
         level = request.json.get('level', 'INFO')
         metadata = request.json.get('metadata', {})
 
+        # Validate required fields
         if not user_id or not message:
-            return jsonify({"error": "Missing required fields"}), 400
+            return jsonify({"error": "Missing required fields: user_id and message"}), 400
 
         return log_user_action(user_id, message, level, metadata)
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error logging user action: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while logging the user action."}), 500
 
 
 # Route to log a health record
 @data_logging_bp.route('/log-health-record', methods=['POST'])
 def log_health_record_route():
+    """
+    Log a health record for poultry.
+    Expects JSON input:
+    - user_id: ID of the user
+    - poultry_id: ID of the poultry
+    - disease_name: Name of the detected disease
+    - status: Health status of the poultry
+    - recommendation: Treatment recommendation
+    - image_path: Optional image path
+    """
     try:
         user_id = request.json.get('user_id')
         poultry_id = request.json.get('poultry_id')
@@ -42,17 +66,29 @@ def log_health_record_route():
         recommendation = request.json.get('recommendation')
         image_path = request.json.get('image_path')
 
+        # Validate required fields
         if not all([user_id, poultry_id, disease_name, status, recommendation]):
             return jsonify({"error": "Missing required fields"}), 400
 
         return log_health_record(user_id, poultry_id, disease_name, status, recommendation, image_path)
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error logging health record: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while logging the health record."}), 500
 
 
 # Route to log inventory addition
 @data_logging_bp.route('/log-inventory-addition', methods=['POST'])
 def log_inventory_addition_route():
+    """
+    Log the addition of an inventory item.
+    Expects JSON input:
+    - user_id: ID of the user
+    - item_name: Name of the inventory item
+    - category: Category of the item (e.g., Feed, Medicine)
+    - quantity: Total quantity added
+    - unit: Unit of measurement (e.g., kg, liters)
+    - description: Optional description or notes
+    """
     try:
         user_id = request.json.get('user_id')
         item_name = request.json.get('item_name')
@@ -61,42 +97,63 @@ def log_inventory_addition_route():
         unit = request.json.get('unit')
         description = request.json.get('description')
 
+        # Validate required fields
         if not all([user_id, item_name, category, quantity, unit]):
             return jsonify({"error": "Missing required fields"}), 400
 
         return log_inventory_addition(user_id, item_name, category, quantity, unit, description)
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error logging inventory addition: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while logging the inventory addition."}), 500
 
 
 # Route to log inventory update
 @data_logging_bp.route('/log-inventory-update', methods=['PUT'])
 def log_inventory_update_route():
+    """
+    Log an update to an existing inventory item.
+    Expects JSON input:
+    - user_id: ID of the user
+    - item_id: ID of the inventory item
+    - updated_fields: Dictionary containing fields to be updated (e.g., quantity, used_quantity)
+    """
     try:
         user_id = request.json.get('user_id')
         item_id = request.json.get('item_id')
         updated_fields = request.json.get('updated_fields')
 
+        # Validate required fields
         if not all([user_id, item_id, updated_fields]):
             return jsonify({"error": "Missing required fields"}), 400
 
         return log_inventory_update(user_id, item_id, updated_fields)
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error logging inventory update: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while logging the inventory update."}), 500
 
 
 # Route to log assistant usage
 @data_logging_bp.route('/log-assistant-usage', methods=['POST'])
 def log_assistant_usage_route():
+    """
+    Log the usage of the assistant by a user.
+    Expects JSON input:
+    - user_id: ID of the user
+    - manager_id: ID of the manager overseeing the user
+    - interaction_type: Type of interaction (e.g., disease_detection, inventory_management)
+    - metadata: Optional metadata for additional details
+    """
     try:
         user_id = request.json.get('user_id')
         manager_id = request.json.get('manager_id')
         interaction_type = request.json.get('interaction_type')
-        metadata = request.json.get('metadata')
+        metadata = request.json.get('metadata', {})
 
+        # Validate required fields
         if not all([user_id, manager_id, interaction_type]):
             return jsonify({"error": "Missing required fields"}), 400
 
         return log_assistant_usage(user_id, manager_id, interaction_type, metadata)
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error logging assistant usage: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while logging the assistant usage."}), 500

routes/health_routes.py

@@ -1,7 +1,12 @@
 # routes/health_routes.py
 
-from flask import Blueprint, jsonify
+from flask import Blueprint, jsonify, request
 from controllers.health_management import detect_and_log_disease, get_health_record, get_health_records_for_user
+from services.disease_detection import detect_disease
+import logging
+
+# Initialize logger for the health routes
+logger = logging.getLogger(__name__)
 
 # Create a Blueprint for the health-related routes
 health_bp = Blueprint('health', __name__)
@@ -11,17 +16,35 @@ health_bp = Blueprint('health', __name__)
 @health_bp.route('/detect-disease', methods=['POST'])
 def detect_disease_route():
     """
-    Detect a poultry disease and log the health record.
-    Expects a POST request with the following fields:
-    - user_id: ID of the user.
-    - poultry_id: ID of the poultry.
+    Detect a poultry disease from an uploaded image and log the health record.
+
+    Expects a POST request with:
+    - user_id: ID of the user (in request form data or headers).
+    - poultry_id: ID of the poultry (in request form data or headers).
     - image: Image of poultry feces for disease detection.
+
     Returns: JSON response with disease detection result and health record log status.
     """
     try:
-        return detect_and_log_disease()
+        # Get the uploaded image and other request data
+        image = request.files.get('image')
+        user_id = request.form.get('user_id')
+        poultry_id = request.form.get('poultry_id')
+
+        # Validate required fields
+        if not image or not user_id or not poultry_id:
+            return jsonify({"error": "Missing required fields: image, user_id, or poultry_id"}), 400
+
+        # Assuming 'db' is accessible or passed via the route (refactor to pass db as a dependency)
+        result = detect_disease(image, db)
+
+        # Log the disease detection result in the health records
+        log_result = detect_and_log_disease(user_id, poultry_id, result)
+        return jsonify(log_result), 201
+
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error in disease detection: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred during disease detection. Please try again."}), 500
 
 
 # Route to get a health record by its ID
@@ -29,12 +52,18 @@ def detect_disease_route():
 def get_health_record_route(record_id):
     """
     Retrieve a health record by its ID.
+
     Returns: JSON response with the health record details.
     """
     try:
-        return get_health_record(record_id)
+        health_record = get_health_record(record_id)
+        if not health_record:
+            return jsonify({"error": "Health record not found"}), 404
+        return jsonify(health_record), 200
+
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error retrieving health record: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while fetching the health record."}), 500
 
 
 # Route to get all health records for a specific user
@@ -42,9 +71,15 @@ def get_health_record_route(record_id):
 def get_health_records_for_user_route(user_id):
     """
     Retrieve all health records for a specific user.
+
     Returns: JSON response with the list of health records for the user.
     """
     try:
-        return get_health_records_for_user(user_id)
+        health_records = get_health_records_for_user(user_id)
+        if not health_records:
+            return jsonify({"message": "No health records found for this user"}), 404
+        return jsonify(health_records), 200
+
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error retrieving health records for user {user_id}: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while fetching the health records."}), 500

routes/inventory_routes.py

@@ -1,13 +1,17 @@
 # routes/inventory_routes.py
 
 
-from flask import Blueprint, jsonify
+from flask import Blueprint, request, jsonify
 from controllers.inventory import (
     add_inventory_item,
     update_inventory_item_by_id,
     get_inventory_by_id,
     get_all_inventory
 )
+import logging
+
+# Initialize logger for inventory routes
+logger = logging.getLogger(__name__)
 
 # Create a Blueprint for the inventory-related routes
 inventory_bp = Blueprint('inventory', __name__)
@@ -25,12 +29,25 @@ def add_inventory_item_route():
     - quantity: The total quantity of the item.
     - unit: The unit of measurement (e.g., "kg", "liters").
     - description: Optional. Additional description or notes about the item.
+
     Returns: JSON response with the status of the addition.
     """
     try:
-        return add_inventory_item()
+        user_id = request.json.get('user_id')
+        item_name = request.json.get('item_name')
+        category = request.json.get('category')
+        quantity = request.json.get('quantity')
+        unit = request.json.get('unit')
+        description = request.json.get('description')
+
+        # Validate required fields
+        if not all([user_id, item_name, category, quantity, unit]):
+            return jsonify({"error": "Missing required fields"}), 400
+
+        return add_inventory_item(user_id, item_name, category, quantity, unit, description)
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error adding inventory item: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while adding the inventory item."}), 500
 
 
 # Route to update an existing inventory item
@@ -42,12 +59,22 @@ def update_inventory_item_route():
     - user_id: The ID of the user updating the item.
     - item_id: The ID of the inventory item to be updated.
     - updated_fields: Dictionary containing fields to be updated (e.g., quantity, used_quantity).
+
     Returns: JSON response with the status of the update.
     """
     try:
-        return update_inventory_item_by_id()
+        user_id = request.json.get('user_id')
+        item_id = request.json.get('item_id')
+        updated_fields = request.json.get('updated_fields')
+
+        # Validate required fields
+        if not all([user_id, item_id, updated_fields]):
+            return jsonify({"error": "Missing required fields"}), 400
+
+        return update_inventory_item_by_id(user_id, item_id, updated_fields)
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error updating inventory item: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while updating the inventory item."}), 500
 
 
 # Route to get an inventory item by its ID
@@ -56,12 +83,14 @@ def get_inventory_item_route(item_id):
     """
     Retrieve an inventory item by its ID.
     Expects a GET request with the item_id as a URL parameter.
+
     Returns: JSON response with the inventory item details.
     """
     try:
         return get_inventory_by_id(item_id)
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error retrieving inventory item: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while retrieving the inventory item."}), 500
 
 
 # Route to get all inventory items
@@ -69,9 +98,11 @@ def get_inventory_item_route(item_id):
 def get_all_inventory_route():
     """
     Retrieve all inventory items in the system.
+
     Returns: JSON response with the list of all inventory items.
     """
     try:
         return get_all_inventory()
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error retrieving all inventory items: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while retrieving the inventory items."}), 500

routes/usage_routes.py

@@ -1,7 +1,11 @@
 # routes/usage_routes.py
 
-from flask import Blueprint, jsonify
+from flask import Blueprint, jsonify, request
 from controllers.usage_tracking import log_usage, get_usage_for_user, get_usage_for_manager, get_usage_by_type
+import logging
+
+# Initialize logger for usage routes
+logger = logging.getLogger(__name__)
 
 # Create a Blueprint for the usage-related routes
 usage_bp = Blueprint('usage', __name__)
@@ -22,9 +26,19 @@ def log_usage_route():
     Returns: JSON response indicating success or failure.
     """
     try:
-        return log_usage()
+        user_id = request.json.get('user_id')
+        manager_id = request.json.get('manager_id')
+        interaction_type = request.json.get('interaction_type')
+        metadata = request.json.get('metadata', {})
+
+        # Validate required fields
+        if not all([user_id, manager_id, interaction_type]):
+            return jsonify({"error": "Missing required fields"}), 400
+
+        return log_usage(user_id, manager_id, interaction_type, metadata)
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error logging usage: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while logging the usage."}), 500
 
 
 # Route to get all assistant usage logs for a specific user
@@ -40,7 +54,8 @@ def get_usage_for_user_route(user_id):
     try:
         return get_usage_for_user(user_id)
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error retrieving usage logs for user {user_id}: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while retrieving the usage logs for the user."}), 500
 
 
 # Route to get all assistant usage logs for users managed by a specific manager
@@ -56,7 +71,8 @@ def get_usage_for_manager_route(manager_id):
     try:
         return get_usage_for_manager(manager_id)
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error retrieving usage logs for manager {manager_id}: {str(e)}", exc_info=True)
+        return jsonify({"error": "An error occurred while retrieving the usage logs for the manager's users."}), 500
 
 
 # Route to get all assistant usage logs for a specific interaction type
@@ -72,4 +88,6 @@ def get_usage_by_type_route(interaction_type):
     try:
         return get_usage_by_type(interaction_type)
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error retrieving usage logs for interaction type {interaction_type}: {str(e)}", exc_info=True)
+        return jsonify(
+            {"error": "An error occurred while retrieving the usage logs for the specified interaction type."}), 500

services/disease_detection.py

@@ -5,31 +5,45 @@ import numpy as np
 import tensorflow as tf
 from keras.models import load_model
 from services.llama_service import llama2_response
+import logging
 
-# Check your model optimizer configuration
-optimizer = tf.keras.optimizers.Adam()  # Default optimizer without weight_decay
+# Initialize logger for better error tracking
+logger = logging.getLogger(__name__)
 
 # Load TensorFlow/Keras models with GPU support if available, otherwise use CPU
 try:
     device_name = '/GPU:0' if len(tf.config.list_physical_devices('GPU')) > 0 else '/CPU:0'
     with tf.device(device_name):
+        # Load models
         my_model = load_model('models/Final_Chicken_disease_model.h5', compile=True)
         auth_model = load_model('models/auth_model.h5', compile=True)
         print(f"Models loaded successfully on {device_name}.")
 except Exception as e:
-    print(f"Error loading models: {e}")
+    logger.error(f"Error loading models: {e}")
+    my_model = None  # Ensure there's a fallback in case model loading fails
 
 # Mapping of disease labels to disease names, health status, and treatment recommendations
 name_disease = {0: 'Coccidiosis', 1: 'Healthy', 2: 'New Castle Disease', 3: 'Salmonella'}
-result = {0: 'Critical', 1: 'No issue', 2: 'Critical', 3: 'Critical'}
-recommend = {
+status_map = {0: 'Critical', 1: 'No issue', 2: 'Critical', 3: 'Critical'}
+recommendations = {
     0: 'Panadol',  # Treatment for Coccidiosis
-    1: 'You have no need for Medicine',  # Healthy case
+    1: 'No treatment needed',  # Healthy case
     2: 'Percetamol',  # Treatment for New Castle Disease
     3: 'Ponston'  # Treatment for Salmonella
 }
 
 
+def detect_disease(image, db):
+    """
+    Function to create an instance of PoultryFarmBot and detect disease.
+    :param image: Image of poultry feces for disease detection.
+    :param db: Database connection to pass into the bot.
+    :return: Result of disease detection.
+    """
+    bot = PoultryFarmBot(db)
+    return bot.diagnose_disease(image)
+
+
 class PoultryFarmBot:
     def __init__(self, db):
         """
@@ -47,11 +61,11 @@ class PoultryFarmBot:
         :return: Preprocessed image ready for prediction or None if an error occurs.
         """
         try:
-            image_check = cv2.resize(image, (224, 224))  # Resize image
-            image_check = np.expand_dims(image_check, axis=0)  # Add batch dimension
-            return image_check
+            image_resized = cv2.resize(image, (224, 224))  # Resize image
+            image_expanded = np.expand_dims(image_resized, axis=0)  # Add batch dimension
+            return image_expanded
         except Exception as e:
-            print(f"Error in image preprocessing: {e}")
+            logger.error(f"Error in image preprocessing: {e}")
             return None
 
     def predict(self, image):
@@ -61,27 +75,29 @@ class PoultryFarmBot:
         :param image: Input image (numpy array).
         :return: Tuple of predicted disease name, health status, and treatment recommendation.
         """
-        # Preprocess the image
-        image_check = self.preprocess_image(image)
+        image_preprocessed = self.preprocess_image(image)
 
-        if image_check is None:
+        if image_preprocessed is None:
             return "Image preprocessing failed.", None, None, None
 
+        if my_model is None:
+            logger.error("Disease detection model is not loaded.")
+            return "Model not loaded.", None, None, None
+
         try:
             # Predict disease using the loaded model
-            indx = my_model.predict(image_check).argmax()
+            indx = my_model.predict(image_preprocessed).argmax()
 
-            # Get the disease name, status, and recommended treatment
-            name = name_disease.get(indx, "Unknown disease")
-            status = result.get(indx, "Unknown condition")
-            recom = recommend.get(indx, "No recommendation available")
+            # Retrieve the disease name, status, and recommended treatment
+            disease_name = name_disease.get(indx, "Unknown disease")
+            status = status_map.get(indx, "Unknown condition")
+            recommendation = recommendations.get(indx, "No recommendation available")
 
-            return name, status, recom
+            return disease_name, status, recommendation
         except Exception as e:
-            print(f"Error during disease prediction: {e}")
+            logger.error(f"Error during disease prediction: {e}")
             return "Prediction failed.", None, None, None
 
-    # Generate a detailed response using Llama 2 for disease information and recommendations
     def generate_disease_response(self, disease_name, status, recommendation):
         """
         Generates a detailed response using Llama 2 model for disease information and recommendations.
@@ -99,21 +115,19 @@ class PoultryFarmBot:
                 "to effectively manage this condition on a poultry farm."
             )
             response = llama2_response(prompt)
-            # Post-process to remove the prompt if accidentally included in the response
             return response.replace(prompt, "").strip()
         except Exception as e:
-            print(f"Error generating detailed response: {e}")
+            logger.error(f"Error generating detailed response: {e}")
             return "Unable to generate detailed response."
 
-    # Diagnose Disease Using Fecal Image
     def diagnose_disease(self, image):
         """
         Diagnose a disease using a fecal image.
 
         :param image: The image of poultry feces to detect a disease.
-        :return: Tuple of diagnosis result and detailed response if applicable.
+        :return: Dictionary containing diagnosis result and detailed response if applicable.
         """
-        if image is not None and image.size > 0:  # Ensure the image is valid and has elements
+        if image is not None and image.size > 0:  # Ensure the image is valid
             disease_name, status, recommendation = self.predict(image)
             if disease_name and status and recommendation:
                 detailed_response = self.generate_disease_response(disease_name, status, recommendation)
@@ -123,4 +137,4 @@ class PoultryFarmBot:
                     "recommendation": recommendation,
                     "detailed_response": detailed_response
                 }
-        return "Please provide an image of poultry fecal matter for disease detection.", None, None, None
+        return {"error": "Please provide a valid image for disease detection."}

services/gradio_interface.py

@@ -1,37 +0,0 @@
-# services/gradio_interface.py
-
-
-import gradio as gr
-from services.disease_detection import PoultryFarmBot
-from services.llama_service import llama2_response
-
-
-def chatbot_response(image, text, bot):
-    if image is not None:
-        diagnosis, name, status, recom = bot.predict(image)
-        return f"Disease: {name}, Status: {status}, Recommendation: {recom}" if name else "No disease detected."
-    else:
-        return llama2_response(text)
-
-
-def create_gradio_interface():
-    bot = PoultryFarmBot(db=None)  # Pass your MongoDB instance here if needed
-
-    with gr.Blocks(theme=gr.themes.Soft(primary_hue="green", neutral_hue="slate")) as interface:
-        gr.Markdown("# 🐔 Poultry Management Chatbot")
-        gr.Markdown(
-            "This chatbot can help you manage your poultry with conversational AI. Upload an image or ask a question!")
-
-        with gr.Row():
-            with gr.Column(scale=1):
-                fecal_image = gr.Image(label="Upload Image of Poultry Feces (Optional)", type="numpy", show_label=True)
-            with gr.Column(scale=2):
-                user_input = gr.Textbox(label="Type your question", placeholder="Ask about poultry management...",
-                                        lines=3)
-
-        output_box = gr.Textbox(label="Response", interactive=False, lines=10)
-        submit_button = gr.Button("Submit")
-        submit_button.click(fn=lambda image, text: chatbot_response(image, text, bot),
-                            inputs=[fecal_image, user_input], outputs=[output_box])
-
-    return interface

services/inventory_manager.py

@@ -3,10 +3,14 @@
 
 from bson.objectid import ObjectId
 import datetime
+import logging
 
 # MongoDB Setup (import from your db configuration)
 from config.db import db
 
+# Define logger
+logger = logging.getLogger(__name__)
+
 # Define the inventory collection
 inventory_collection = db.inventory  # MongoDB collection to store inventory items
 
@@ -45,7 +49,7 @@ class InventoryManager:
             result = self.collection.insert_one(new_item)
             return str(result.inserted_id)
         except Exception as e:
-            print(f"Error adding inventory item: {e}")
+            logger.error(f"Error adding inventory item for user {user_id}: {e}")
             return None
 
     def update_inventory_item(self, item_id, updated_fields):
@@ -64,7 +68,7 @@ class InventoryManager:
             )
             return result.modified_count > 0
         except Exception as e:
-            print(f"Error updating inventory item: {e}")
+            logger.error(f"Error updating inventory item {item_id}: {e}")
             return False
 
     def get_inventory_item_by_id(self, item_id):
@@ -77,7 +81,7 @@ class InventoryManager:
         try:
             return self.collection.find_one({"_id": ObjectId(item_id)})
         except Exception as e:
-            print(f"Error retrieving inventory item: {e}")
+            logger.error(f"Error retrieving inventory item {item_id}: {e}")
             return None
 
     def get_all_inventory_items(self, user_id=None):
@@ -88,11 +92,10 @@ class InventoryManager:
         :return: A list of inventory items or an empty list if none are found.
         """
         try:
-            if user_id:
-                return list(self.collection.find({"user_id": ObjectId(user_id)}))
-            return list(self.collection.find())
+            query = {"user_id": ObjectId(user_id)} if user_id else {}
+            return list(self.collection.find(query))
         except Exception as e:
-            print(f"Error retrieving inventory items: {e}")
+            logger.error(f"Error retrieving inventory items for user {user_id}: {e}")
             return []
 
     def delete_inventory_item(self, item_id):
@@ -106,5 +109,5 @@ class InventoryManager:
             result = self.collection.delete_one({"_id": ObjectId(item_id)})
             return result.deleted_count > 0
         except Exception as e:
-            print(f"Error deleting inventory item: {e}")
+            logger.error(f"Error deleting inventory item {item_id}: {e}")
             return False

services/llama_service.py

@@ -1,25 +1,42 @@
 # services/llama_service.py
 
 import os
+import logging
 from transformers import AutoTokenizer, AutoModelForCausalLM
 from huggingface_hub import login
 
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 # Load Llama model and tokenizer for text generation
+model_name = "meta-llama/Llama-3.2-1B"
 
 # Ensure the Hugging Face token is set
-tok = os.getenv('HF_Token')
-if tok:
-    login(token=tok, add_to_git_credential=True)
+hf_token = os.getenv('HF_Token')
+if hf_token:
+    try:
+        login(token=hf_token, add_to_git_credential=True)
+        logger.info("Successfully logged into Hugging Face Hub.")
+    except Exception as e:
+        logger.error(f"Error logging into Hugging Face Hub: {e}")
 else:
-    print("Warning: Hugging Face token not found in environment variables.")
+    logger.warning("Warning: Hugging Face token not found in environment variables.")
 
-tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-1B")
-model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-1B")
+try:
+    # Load tokenizer and model
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForCausalLM.from_pretrained(model_name)
+    logger.info(f"Successfully loaded model and tokenizer: {model_name}")
+except Exception as e:
+    logger.error(f"Error loading model or tokenizer: {e}")
+    raise
 
-# Ensure the tokenizer has a padding token; if not, add a new padding token
+# Ensure the tokenizer has a padding token; if not, add one
 if tokenizer.pad_token is None:
     tokenizer.add_special_tokens({'pad_token': '[PAD]'})
     model.resize_token_embeddings(len(tokenizer))
+    logger.info("Added a padding token to the tokenizer.")
 
 
 def llama2_response(user_input):
@@ -32,6 +49,7 @@ def llama2_response(user_input):
     try:
         # Tokenize the input text, ensuring truncation and padding
         inputs = tokenizer(user_input, return_tensors="pt", truncation=True, max_length=150, padding=True)
+        logger.info("Successfully tokenized the input.")
 
         # Generate the model's response
         outputs = model.generate(
@@ -42,9 +60,12 @@ def llama2_response(user_input):
             pad_token_id=tokenizer.pad_token_id,  # Ensure the use of a valid pad token
             attention_mask=inputs["attention_mask"]  # Use attention mask for padded tokens
         )
+        logger.info("Response generation successful.")
 
         # Decode the generated response, skipping special tokens
         response = tokenizer.decode(outputs[0], skip_special_tokens=True)
         return response
+
     except Exception as e:
+        logger.error(f"Error generating response: {e}")
         return f"Error generating response: {str(e)}"

services/report_generator.py

@@ -3,9 +3,13 @@
 
 import pandas as pd
 from bson.objectid import ObjectId
-import datetime
+import logging
 from config.db import db
 
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 # Define collections for report generation
 inventory_collection = db.inventory
 health_collection = db.health
@@ -22,6 +26,24 @@ class ReportGenerator:
         self.health_collection = health_collection
         self.usage_collection = usage_collection
 
+    def _fetch_data(self, collection, query):
+        """
+        Private helper function to fetch data from MongoDB and convert it to a pandas DataFrame.
+
+        :param collection: MongoDB collection to query.
+        :param query: MongoDB query for filtering data.
+        :return: A pandas DataFrame or an empty DataFrame if no data is found.
+        """
+        try:
+            data = list(collection.find(query))
+            if not data:
+                logger.info("No data found for query: %s", query)
+                return pd.DataFrame([])
+            return pd.DataFrame(data)
+        except Exception as e:
+            logger.error(f"Error fetching data from {collection.name}: {e}")
+            return pd.DataFrame([])
+
     def generate_inventory_report(self, user_id=None):
         """
         Generates a report of all inventory items, optionally filtered by user.
@@ -29,20 +51,12 @@ class ReportGenerator:
         :param user_id: Optional. The ID of the user to filter the inventory report.
         :return: A pandas DataFrame containing the inventory report.
         """
-        try:
-            query = {"user_id": ObjectId(user_id)} if user_id else {}
-            inventory_items = list(self.inventory_collection.find(query))
-
-            if not inventory_items:
-                return pd.DataFrame([])
+        query = {"user_id": ObjectId(user_id)} if user_id else {}
+        df = self._fetch_data(self.inventory_collection, query)
 
-            # Convert MongoDB documents to a pandas DataFrame
-            df = pd.DataFrame(inventory_items)
-            df = df.drop(columns=['_id', 'user_id'])  # Drop internal fields
-            return df
-        except Exception as e:
-            print(f"Error generating inventory report: {e}")
-            return pd.DataFrame([])
+        if not df.empty:
+            df = df.drop(columns=['_id', 'user_id'], errors='ignore')  # Drop internal fields if they exist
+        return df
 
     def generate_health_report(self, user_id=None):
         """
@@ -51,20 +65,12 @@ class ReportGenerator:
         :param user_id: Optional. The ID of the user to filter the health report.
         :return: A pandas DataFrame containing the health report.
         """
-        try:
-            query = {"user_id": ObjectId(user_id)} if user_id else {}
-            health_records = list(self.health_collection.find(query))
+        query = {"user_id": ObjectId(user_id)} if user_id else {}
+        df = self._fetch_data(self.health_collection, query)
 
-            if not health_records:
-                return pd.DataFrame([])
-
-            # Convert MongoDB documents to a pandas DataFrame
-            df = pd.DataFrame(health_records)
-            df = df.drop(columns=['_id', 'user_id'])  # Drop internal fields
-            return df
-        except Exception as e:
-            print(f"Error generating health report: {e}")
-            return pd.DataFrame([])
+        if not df.empty:
+            df = df.drop(columns=['_id', 'user_id'], errors='ignore')  # Drop internal fields if they exist
+        return df
 
     def generate_usage_report(self, user_id=None, manager_id=None, interaction_type=None):
         """
@@ -75,27 +81,20 @@ class ReportGenerator:
         :param interaction_type: Optional. Filter by interaction type (e.g., "disease_detection").
         :return: A pandas DataFrame containing the assistant usage report.
         """
-        try:
-            query = {}
-            if user_id:
-                query['user_id'] = ObjectId(user_id)
-            if manager_id:
-                query['manager_id'] = ObjectId(manager_id)
-            if interaction_type:
-                query['interaction_type'] = interaction_type
-
-            usage_records = list(self.usage_collection.find(query))
+        query = {}
+        if user_id:
+            query['user_id'] = ObjectId(user_id)
+        if manager_id:
+            query['manager_id'] = ObjectId(manager_id)
+        if interaction_type:
+            query['interaction_type'] = interaction_type
 
-            if not usage_records:
-                return pd.DataFrame([])
+        df = self._fetch_data(self.usage_collection, query)
 
-            # Convert MongoDB documents to a pandas DataFrame
-            df = pd.DataFrame(usage_records)
-            df = df.drop(columns=['_id', 'user_id', 'manager_id'])  # Drop internal fields
-            return df
-        except Exception as e:
-            print(f"Error generating usage report: {e}")
-            return pd.DataFrame([])
+        if not df.empty:
+            df = df.drop(columns=['_id', 'user_id', 'manager_id'],
+                         errors='ignore')  # Drop internal fields if they exist
+        return df
 
     def generate_combined_report(self, user_id=None, manager_id=None):
         """
@@ -116,7 +115,7 @@ class ReportGenerator:
                 "usage_report": usage_report
             }
         except Exception as e:
-            print(f"Error generating combined report: {e}")
+            logger.error(f"Error generating combined report: {e}")
             return {
                 "inventory_report": pd.DataFrame([]),
                 "health_report": pd.DataFrame([]),
@@ -133,7 +132,8 @@ class ReportGenerator:
         """
         try:
             report_df.to_csv(file_path, index=False)
+            logger.info(f"Report successfully exported to {file_path}")
             return True
         except Exception as e:
-            print(f"Error exporting report to CSV: {e}")
+            logger.error(f"Error exporting report to CSV: {e}")
             return False

services/usage_tracker.py

@@ -1,10 +1,14 @@
 # services/usage_tracker.py
 
-from pymongo import MongoClient
-from bson.objectid import ObjectId
 import datetime
+from bson.objectid import ObjectId
+import logging
 from config.db import db
 
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 # Define the usage tracking collection
 usage_collection = db.user_usage  # MongoDB collection to store assistant usage logs
 
@@ -25,20 +29,21 @@ class UsageTracker:
         :param manager_id: The ID of the user's manager.
         :param interaction_type: The type of interaction (e.g., "disease_detection", "inventory_management").
         :param metadata: Optional. Additional details related to the interaction (e.g., query details, result).
-        :return: The inserted usage log's ID (MongoDB ObjectId).
+        :return: The inserted usage log's ID (MongoDB ObjectId) or None if there's an error.
         """
         try:
             log_entry = {
                 "user_id": ObjectId(user_id),
                 "manager_id": ObjectId(manager_id),
                 "interaction_type": interaction_type,
-                "metadata": metadata if metadata else {},
+                "metadata": metadata or {},
                 "timestamp": datetime.datetime.utcnow()
             }
             result = self.collection.insert_one(log_entry)
+            logger.info(f"Successfully logged usage for user {user_id} with interaction type {interaction_type}.")
             return str(result.inserted_id)
         except Exception as e:
-            print(f"Error logging usage: {e}")
+            logger.error(f"Error logging usage for user {user_id}: {e}")
             return None
 
     def get_usage_by_user(self, user_id):
@@ -49,9 +54,11 @@ class UsageTracker:
         :return: A list of usage logs for the user or an empty list if none are found.
         """
         try:
-            return list(self.collection.find({"user_id": ObjectId(user_id)}))
+            logs = list(self.collection.find({"user_id": ObjectId(user_id)}))
+            logger.info(f"Retrieved {len(logs)} usage logs for user {user_id}.")
+            return logs
         except Exception as e:
-            print(f"Error retrieving usage logs for user: {e}")
+            logger.error(f"Error retrieving usage logs for user {user_id}: {e}")
             return []
 
     def get_usage_by_manager(self, manager_id):
@@ -62,9 +69,11 @@ class UsageTracker:
         :return: A list of usage logs for the manager's users or an empty list if none are found.
         """
         try:
-            return list(self.collection.find({"manager_id": ObjectId(manager_id)}))
+            logs = list(self.collection.find({"manager_id": ObjectId(manager_id)}))
+            logger.info(f"Retrieved {len(logs)} usage logs for manager {manager_id}.")
+            return logs
         except Exception as e:
-            print(f"Error retrieving usage logs for manager: {e}")
+            logger.error(f"Error retrieving usage logs for manager {manager_id}: {e}")
             return []
 
     def get_usage_by_interaction_type(self, interaction_type):
@@ -75,9 +84,11 @@ class UsageTracker:
         :return: A list of usage logs for the interaction type or an empty list if none are found.
         """
         try:
-            return list(self.collection.find({"interaction_type": interaction_type}))
+            logs = list(self.collection.find({"interaction_type": interaction_type}))
+            logger.info(f"Retrieved {len(logs)} usage logs for interaction type {interaction_type}.")
+            return logs
         except Exception as e:
-            print(f"Error retrieving usage logs by interaction type: {e}")
+            logger.error(f"Error retrieving usage logs for interaction type {interaction_type}: {e}")
             return []
 
     def get_usage_logs(self, user_id=None, manager_id=None, interaction_type=None):
@@ -98,9 +109,13 @@ class UsageTracker:
             if interaction_type:
                 query["interaction_type"] = interaction_type
 
-            return list(self.collection.find(query))
+            logs = list(self.collection.find(query))
+            logger.info(
+                f"Retrieved {len(logs)} usage logs with filters user_id={user_id}, manager_id={manager_id}, interaction_type={interaction_type}.")
+            return logs
         except Exception as e:
-            print(f"Error retrieving usage logs: {e}")
+            logger.error(
+                f"Error retrieving usage logs with filters user_id={user_id}, manager_id={manager_id}, interaction_type={interaction_type}: {e}")
             return []
 
     def delete_usage_log(self, log_id):
@@ -112,7 +127,12 @@ class UsageTracker:
         """
         try:
             result = self.collection.delete_one({"_id": ObjectId(log_id)})
-            return result.deleted_count > 0
+            if result.deleted_count > 0:
+                logger.info(f"Successfully deleted usage log with ID {log_id}.")
+                return True
+            else:
+                logger.warning(f"Usage log with ID {log_id} not found for deletion.")
+                return False
         except Exception as e:
-            print(f"Error deleting usage log: {e}")
+            logger.error(f"Error deleting usage log with ID {log_id}: {e}")
             return False