"Update system"

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

.env

@@ -0,0 +1,27 @@
+# MongoDB Settings
+MONGO_URI=mongodb://localhost:27017
+DB_NAME=poultry_farm
+
+# JWT Settings
+SECRET_KEY=super_secret_key_here
+JWT_ALGORITHM=HS256
+JWT_EXPIRATION_HOURS=24
+
+# Email Settings (optional)
+EMAIL_HOST=smtp.your-email-provider.com
+EMAIL_PORT=587
+EMAIL_USE_TLS=True
+[email protected]
+EMAIL_HOST_PASSWORD=your_secure_password
+
+# Log Level
+LOG_LEVEL=DEBUG
+
+# External API Key (optional)
+EXTERNAL_API_KEY=your_external_api_key_here
+
+# Upload Folder Path
+UPLOAD_FOLDER=/path/to/uploads
+
+# Pagination
+PAGINATION_LIMIT=10

.idea/Poultry_Diseases_Detector.iml

@@ -4,7 +4,7 @@
     <content url="file://$MODULE_DIR$">
       <excludeFolder url="file://$MODULE_DIR$/.venv" />
     </content>
-    <orderEntry type="inheritedJdk" />
+    <orderEntry type="jdk" jdkName="Poultry_Diseases_Detector (2)" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
   <component name="PackageRequirementsSettings">

.idea/misc.xml

@@ -3,5 +3,5 @@
   <component name="Black">
     <option name="sdkName" value="Python 3.11 (Poultry_Diseases_Detector)" />
   </component>
-  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.13 (Poultry_Diseases_Detector)" project-jdk-type="Python SDK" />
+  <component name="ProjectRootManager" version="2" project-jdk-name="Poultry_Diseases_Detector (2)" project-jdk-type="Python SDK" />
 </project>

app.py

@@ -1,12 +1,26 @@
 import os
 import tensorflow as tf
-from keras.models import load_model
-import gradio as gr
-import cv2
-import numpy as np
-from huggingface_hub import login
 from pymongo import MongoClient
-from transformers import AutoModelForCausalLM, AutoTokenizer
+from flask import Flask, request, jsonify, render_template
+from huggingface_hub import login
+import threading
+from services.disease_detection import PoultryFarmBot
+from services.llama_service import llama2_response
+from config.db import db
+
+# Initialize Flask application
+app = Flask(__name__, template_folder="templates", static_folder="static")
+
+# Register Blueprints for API routes
+from auth.auth_routes import auth_bp
+from routes.health_routes import health_bp
+from routes.inventory_routes import inventory_bp
+from routes.usage_routes import usage_bp
+
+app.register_blueprint(usage_bp, url_prefix='/api/usage')
+app.register_blueprint(inventory_bp, url_prefix='/api/inventory')
+app.register_blueprint(health_bp, url_prefix='/api/health')
+app.register_blueprint(auth_bp, url_prefix='/auth')
 
 # Ensure the Hugging Face token is set
 tok = os.getenv('HF_Token')
@@ -15,7 +29,7 @@ if tok:
 else:
     print("Warning: Hugging Face token not found in environment variables.")
 
-# MongoDB Setup (for inventory, record-keeping, etc.)
+# MongoDB Setup
 MONGO_URI = os.getenv("MONGO_URI")
 client = MongoClient(MONGO_URI)
 db = client.poultry_farm  # Database
@@ -34,161 +48,35 @@ if len(tf.config.list_physical_devices('GPU')) > 0:
 else:
     print("Using CPU without mixed precision")
 
-# 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):
-        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}")
-
-# Updated Disease names and recommendations based on fecal analysis
-name_disease = {0: 'Coccidiosis', 1: 'Healthy', 2: 'New Castle Disease', 3: 'Salmonella'}
-result = {0: 'Critical', 1: 'No issue', 2: 'Critical', 3: 'Critical'}
-recommend = {
-    0: 'Panadol',
-    1: 'You have no need Medicine',
-    2: 'Percetamol',
-    3: 'Ponston'
-}
-
-class PoultryFarmBot:
-    def __init__(self):
-        self.db = db  # MongoDB database for future use
-
-    # Image Preprocessing for Fecal Disease Detection
-    def preprocess_image(self, image):
-        try:
-            image_check = cv2.resize(image, (224, 224))
-            image_check = np.expand_dims(image_check, axis=0)  # Add batch dimension
-            return image_check
-        except Exception as e:
-            print(f"Error in image preprocessing: {e}")
-            return None
-
-    # Predict Disease from Fecal Image
-    def predict(self, image):
-        image_check = self.preprocess_image(image)
-        if image_check is None:
-            return "Image preprocessing failed.", None, None, None
-
-        # Predict using the fecal disease detection model
-        indx = my_model.predict(image_check).argmax()
-        name = name_disease.get(indx, "Unknown disease")
-        status = result.get(indx, "unknown condition")
-        recom = recommend.get(indx, "no recommendation available")
-
-        # Generate additional information about the disease using Llama 2
-        detailed_response = self.generate_disease_response(name, status, recom)
-        return detailed_response, name, status, recom
-
-    # Generate a detailed response using Llama 2 for disease information and recommendations
-    def generate_disease_response(self, disease_name, status, recommendation):
-        prompt = (
-            f"The disease detected is {disease_name}, classified as {status}. "
-            f"Recommended action: {recommendation}. "
-            f"Here is some information about {disease_name}: causes, symptoms, and treatment methods "
-            "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()
-
-    # Diagnose Disease Using Fecal Image
-    def diagnose_disease(self, image):
-        if image is not None and image.size > 0:  # Ensure the image is valid and has elements
-            return self.predict(image)
-        return "Please provide an image of poultry faecal matter for disease detection.", None, None, None
-
-# Initialize the bot instance
-bot = PoultryFarmBot()
-
-# Load Llama 3.2 model and tokenizer for text generation
-model_name = "meta-llama/Llama-3.2-1B" 
-tokenizer = AutoTokenizer.from_pretrained(model_name)
-model = AutoModelForCausalLM.from_pretrained(model_name)
-
-# Set the padding token to EOS token or add a new padding token
-if tokenizer.pad_token is None:
-    tokenizer.add_special_tokens({'pad_token': '[PAD]'})
-    model.resize_token_embeddings(len(tokenizer))
-
-# Define Llama 2 response generation
-def llama2_response(user_input):
-    try:
-        inputs = tokenizer(user_input, return_tensors="pt", truncation=True, max_length=150, padding=True)
-        outputs = model.generate(
-            inputs["input_ids"],
-            max_length=150,
-            do_sample=True,
-            temperature=0.7,
-            pad_token_id=tokenizer.pad_token_id,  # Use the newly set padding token
-            attention_mask=inputs["attention_mask"]
-        )
-
-        # Decode and return the response
-        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        return response
-    except Exception as e:
-        return f"Error generating response: {str(e)}"
-
-# Main chatbot function: handles both generative AI and disease detection
-def chatbot_response(image, text):
-    # If an image is provided, perform disease detection
-    if image is not None:
-        diagnosis, name, status, recom = bot.diagnose_disease(image)
-        if name and status and recom:
-            return diagnosis
-        else:
-            return diagnosis  # Return only the diagnostic message if no disease found
-    else:
-        # Use Llama 2 for more accurate responses
-        return llama2_response(text)
-
-# Gradio interface styling and layout with ChatGPT-like theme
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="green", neutral_hue="slate")) as chatbot_interface:
-    gr.Markdown("# 🐔 Poultry Management Chatbot")
-    gr.Markdown(
-        "This chatbot can help you manage your poultry with conversational AI. Upload an image of poultry fecal matter for disease detection or just ask questions!"
-    )
-
-    with gr.Row():
-        with gr.Column(scale=1):
-            fecal_image = gr.Image(
-                label="Upload Image of Poultry Feces (Optional)",
-                type="numpy",
-                elem_id="image-upload",
-                show_label=True,
-            )
-        with gr.Column(scale=2):
-            user_input = gr.Textbox(
-                label="Type your question or chat with the assistant",
-                placeholder="Ask a question about poultry management...",
-                lines=3,
-                elem_id="user-input",
-            )
-
-    output_box = gr.Textbox(
-        label="Response",
-        placeholder="The response will appear here...",
-        interactive=False,
-        lines=10,
-        elem_id="output-box",
-    )
-
-    submit_button = gr.Button(
-        "Submit",
-        variant="primary",
-        elem_id="submit-button"
-    )
-    submit_button.click(
-        fn=chatbot_response,
-        inputs=[fecal_image, user_input],
-        outputs=[output_box]
-    )
-
-# Launch the Gradio interface
+# Initialize PoultryFarmBot
+bot = PoultryFarmBot(db=db)
+
+
+# Routes
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+
+# API to handle disease detection and AI assistant text response
+@app.route('/api/chat', methods=['POST'])
+def chat():
+    data = request.json
+    message = data.get('message')
+    image = data.get('image')
+
+    if image:
+        # Handle disease detection with image
+        diagnosis, name, status, recom = bot.predict(image)
+        return jsonify({
+            "response": f"Disease: {name}, Status: {status}, Recommendation: {recom}"
+        })
+
+    # Handle AI text generation with Llama model
+    response = llama2_response(message)
+    return jsonify({"response": response})
+
+
+# Run the Flask app
 if __name__ == "__main__":
-    chatbot_interface.queue().launch(debug=True, share=True)
+    app.run(debug=True)

auth/auth_controller.py

@@ -0,0 +1,137 @@
+import bcrypt
+import jwt
+import datetime
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+from flask import jsonify, request
+from functools import wraps
+from config.db import db
+
+# MongoDB setup (this should be moved to config/db.py and imported here)
+client = MongoClient("your_mongo_uri")  # Replace with your MongoDB URI
+db = client.poultry_farm  # Your database name
+users_collection = db.users  # Collection for storing user information
+
+# Secret key for JWT (move to config/settings.py and import here)
+SECRET_KEY = "your_secret_key"  # Replace with a secure secret key
+
+
+# JWT decorator to protect routes
+def token_required(f):
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        token = None
+        if 'x-access-token' in request.headers:
+            token = request.headers['x-access-token']
+        if not token:
+            return jsonify({'message': 'Token is missing!'}), 401
+        try:
+            data = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
+            current_user = users_collection.find_one({"_id": ObjectId(data["user_id"])})
+        except:
+            return jsonify({'message': 'Token is invalid!'}), 401
+        return f(current_user, *args, **kwargs)
+
+    return decorated
+
+
+# Register a new user
+def register():
+    data = request.get_json()
+    if not data or not data.get('username') or not data.get('password'):
+        return jsonify({"message": "Missing username or password"}), 400
+
+    # Check if user already exists
+    if users_collection.find_one({"username": data['username']}):
+        return jsonify({"message": "User already exists"}), 400
+
+    # Hash the password
+    hashed_password = bcrypt.hashpw(data['password'].encode('utf-8'), bcrypt.gensalt())
+
+    # Create user document
+    new_user = {
+        "username": data['username'],
+        "password": hashed_password,
+        "role": data.get('role', 'user'),  # Default role is 'user', could be 'manager'
+        "created_at": datetime.datetime.utcnow()
+    }
+
+    # Insert user into MongoDB
+    result = users_collection.insert_one(new_user)
+    return jsonify({"message": "User registered successfully", "user_id": str(result.inserted_id)}), 201
+
+
+# User login
+def login():
+    data = request.get_json()
+    if not data or not data.get('username') or not data.get('password'):
+        return jsonify({"message": "Missing username or password"}), 400
+
+    # Find user in MongoDB
+    user = users_collection.find_one({"username": data['username']})
+    if not user:
+        return jsonify({"message": "User not found"}), 404
+
+    # Verify password
+    if bcrypt.checkpw(data['password'].encode('utf-8'), user['password']):
+        # Create JWT token
+        token = jwt.encode({
+            'user_id': str(user['_id']),
+            'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=24)
+        }, SECRET_KEY, algorithm="HS256")
+
+        return jsonify({"token": token}), 200
+    else:
+        return jsonify({"message": "Invalid password"}), 401
+
+
+# Get user info (example of a protected route)
+@token_required
+def get_user_info(current_user):
+    user_info = {
+        "username": current_user['username'],
+        "role": current_user['role'],
+        "created_at": current_user['created_at']
+    }
+    return jsonify(user_info), 200
+
+
+# Update user info (for manager/admin use)
+@token_required
+def update_user_info(current_user):
+    if current_user['role'] != 'manager':  # Only managers can update user info
+        return jsonify({"message": "Permission denied"}), 403
+
+    data = request.get_json()
+    if not data or not data.get('user_id'):
+        return jsonify({"message": "Missing user_id"}), 400
+
+    user = users_collection.find_one({"_id": ObjectId(data['user_id'])})
+    if not user:
+        return jsonify({"message": "User not found"}), 404
+
+    # Update user information (only certain fields)
+    update_fields = {}
+    if 'username' in data:
+        update_fields['username'] = data['username']
+    if 'role' in data:
+        update_fields['role'] = data['role']
+
+    users_collection.update_one({"_id": ObjectId(data['user_id'])}, {"$set": update_fields})
+    return jsonify({"message": "User information updated successfully"}), 200
+
+
+# Delete a user (for manager/admin use)
+@token_required
+def delete_user(current_user):
+    if current_user['role'] != 'manager':  # Only managers can delete users
+        return jsonify({"message": "Permission denied"}), 403
+
+    data = request.get_json()
+    if not data or not data.get('user_id'):
+        return jsonify({"message": "Missing user_id"}), 400
+
+    result = users_collection.delete_one({"_id": ObjectId(data['user_id'])})
+    if result.deleted_count == 0:
+        return jsonify({"message": "User not found"}), 404
+    return jsonify({"message": "User deleted successfully"}), 200

auth/auth_routes.py

@@ -0,0 +1,72 @@
+from flask import Blueprint
+from .auth_controller import register, login, get_user_info, update_user_info, delete_user
+
+# Create a Blueprint for auth-related routes
+auth_bp = Blueprint('auth', __name__)
+
+
+# Define the routes
+@auth_bp.route('/register', methods=['POST'])
+def register_user():
+    """
+    Route for registering a new user.
+    This expects a POST request with a JSON payload containing:
+    {
+        "username": "user1",
+        "password": "password123",
+        "role": "user"  # Optional, default is "user"
+    }
+    """
+    return register()
+
+
+@auth_bp.route('/login', methods=['POST'])
+def login_user():
+    """
+    Route for logging in an existing user.
+    This expects a POST request with a JSON payload containing:
+    {
+        "username": "user1",
+        "password": "password123"
+    }
+    """
+    return login()
+
+
+@auth_bp.route('/user-info', methods=['GET'])
+def get_user_details():
+    """
+    Route for getting the authenticated user's information.
+    Requires the JWT token in the `x-access-token` header.
+    """
+    return get_user_info()
+
+
+@auth_bp.route('/update-user', methods=['PUT'])
+def update_user():
+    """
+    Route for updating a user's information.
+    Only accessible by managers.
+    Expects a PUT request with a JSON payload containing:
+    {
+        "user_id": "the user's MongoDB ObjectId",
+        "username": "newUsername"  # Optional
+        "role": "manager"  # Optional, can be "user" or "manager"
+    }
+    Requires the JWT token in the `x-access-token` header.
+    """
+    return update_user_info()
+
+
+@auth_bp.route('/delete-user', methods=['DELETE'])
+def remove_user():
+    """
+    Route for deleting a user from the system.
+    Only accessible by managers.
+    Expects a DELETE request with a JSON payload containing:
+    {
+        "user_id": "the user's MongoDB ObjectId"
+    }
+    Requires the JWT token in the `x-access-token` header.
+    """
+    return delete_user()

auth/schemas/user_schema.py

@@ -0,0 +1,109 @@
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+
+# MongoDB connection (move to config/db.py and import here if needed)
+client = MongoClient("your_mongo_uri")  # Replace with your MongoDB URI
+db = client.poultry_farm  # Your database name
+users_collection = db.users  # Collection for users
+
+
+# Define the User Schema
+class User:
+    def __init__(self, username, password, role="user"):
+        """
+        Initializes a User object.
+
+        :param username: String, the username for the user
+        :param password: String, the hashed password for the user
+        :param role: String, user role (either 'user' or 'manager'), default is 'user'
+        """
+        self.username = username
+        self.password = password
+        self.role = role
+        self.created_at = datetime.datetime.utcnow()  # Store account creation time
+
+    def to_dict(self):
+        """
+        Converts the User object to a dictionary format for MongoDB insertion.
+        :return: dict
+        """
+        return {
+            "username": self.username,
+            "password": self.password,  # Password should be hashed before storing
+            "role": self.role,
+            "created_at": self.created_at
+        }
+
+
+# CRUD Operations for User Schema
+
+def create_user(username, hashed_password, role="user"):
+    """
+    Create a new user in the MongoDB collection.
+
+    :param username: String, the username for the user
+    :param hashed_password: String, the hashed password of the user
+    :param role: String, role of the user (either 'user' or 'manager'), default is 'user'
+    :return: Inserted user's ID (MongoDB ObjectId)
+    """
+    user = User(username=username, password=hashed_password, role=role)
+    user_id = users_collection.insert_one(user.to_dict()).inserted_id
+    return str(user_id)
+
+
+def get_user_by_username(username):
+    """
+    Retrieve a user by their username.
+
+    :param username: String, the username of the user to retrieve
+    :return: User document if found, None if not
+    """
+    return users_collection.find_one({"username": username})
+
+
+def get_user_by_id(user_id):
+    """
+    Retrieve a user by their MongoDB ObjectId.
+
+    :param user_id: String, the MongoDB ObjectId of the user
+    :return: User document if found, None if not
+    """
+    return users_collection.find_one({"_id": ObjectId(user_id)})
+
+
+def update_user(user_id, updated_fields):
+    """
+    Update a user's information based on provided fields.
+
+    :param user_id: String, the MongoDB ObjectId of the user
+    :param updated_fields: dict, fields to update (e.g., username or role)
+    :return: Boolean, True if update was successful, False otherwise
+    """
+    result = users_collection.update_one(
+        {"_id": ObjectId(user_id)},
+        {"$set": updated_fields}
+    )
+    return result.modified_count > 0
+
+
+def delete_user(user_id):
+    """
+    Delete a user from the MongoDB collection by their ObjectId.
+
+    :param user_id: String, the MongoDB ObjectId of the user
+    :return: Boolean, True if deletion was successful, False otherwise
+    """
+    result = users_collection.delete_one({"_id": ObjectId(user_id)})
+    return result.deleted_count > 0
+
+
+# Example function to create a sample user
+if __name__ == "__main__":
+    # Hash a sample password (this should be done with bcrypt before passing into this function)
+    sample_username = "sample_user"
+    sample_hashed_password = "hashed_password_here"  # Use bcrypt to hash passwords
+    sample_role = "user"
+
+    # Insert a sample user into the database
+    user_id = create_user(sample_username, sample_hashed_password, sample_role)
+    print(f"User created with ID: {user_id}")

config/db.py

@@ -0,0 +1,46 @@
+from pymongo import MongoClient
+import os
+
+# Load environment variables (if using environment files like .env)
+from dotenv import load_dotenv
+
+# Load the .env file (ensure that it's present in the project root)
+load_dotenv()
+
+# MongoDB URI (retrieved from environment variables)
+MONGO_URI = os.getenv("MONGO_URI", "mongodb://localhost:27017")  # Default fallback URI for local MongoDB
+DB_NAME = os.getenv("DB_NAME", "poultry_farm")  # Default database name if not specified in environment
+
+# Initialize MongoDB client
+client = MongoClient(MONGO_URI)
+
+# Access the database
+db = client[DB_NAME]
+
+# Collections (define and expose MongoDB collections to be used in the system)
+users_collection = db.users  # User collection
+logs_collection = db.logs  # Logs collection (e.g., health logs, usage logs)
+inventory_collection = db.inventory  # Inventory collection for feed, medicines, etc.
+health_collection = db.health  # Health collection for poultry health records
+usage_collection = db.usage  # Assistant usage tracking collection
+
+# Test the database connection
+try:
+    # Print a list of databases to ensure connection is successful
+    print("Databases in MongoDB:", client.list_database_names())
+    print(f"Connected to MongoDB database: {DB_NAME}")
+except Exception as e:
+    print(f"Error connecting to MongoDB: {e}")
+
+# Example usage of collections
+if __name__ == "__main__":
+    # Insert a test document into the users collection
+    test_user = {
+        "username": "admin",
+        "password": "hashed_password",  # In practice, you would hash the password using bcrypt
+        "role": "manager",
+        "created_at": datetime.datetime.utcnow()
+    }
+
+    result = users_collection.insert_one(test_user)
+    print(f"Inserted test user with ID: {result.inserted_id}")

config/settings.py

@@ -0,0 +1,35 @@
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Secret Key for JWT encoding/decoding
+SECRET_KEY = os.getenv("SECRET_KEY", "your_default_secret_key")  # Replace with a strong default or pull from .env
+
+# MongoDB connection settings
+MONGO_URI = os.getenv("MONGO_URI", "mongodb://localhost:27017")  # Default to local MongoDB if not set
+DB_NAME = os.getenv("DB_NAME", "poultry_farm")  # Default database name
+
+# JWT Settings
+JWT_ALGORITHM = os.getenv("JWT_ALGORITHM", "HS256")  # Default to HS256 algorithm for JWT
+JWT_EXPIRATION_HOURS = int(os.getenv("JWT_EXPIRATION_HOURS", 24))  # Default JWT token expiration is 24 hours
+
+# Email settings (if email notifications are implemented)
+EMAIL_HOST = os.getenv("EMAIL_HOST", "smtp.example.com")
+EMAIL_PORT = int(os.getenv("EMAIL_PORT", 587))
+EMAIL_USE_TLS = bool(os.getenv("EMAIL_USE_TLS", True))
+EMAIL_HOST_USER = os.getenv("EMAIL_HOST_USER", "[email protected]")
+EMAIL_HOST_PASSWORD = os.getenv("EMAIL_HOST_PASSWORD", "your_email_password")
+
+# Logging settings (if any log levels or formats are configured)
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")  # Log level: DEBUG, INFO, WARNING, ERROR, CRITICAL
+
+# Example external APIs (if required for additional services)
+EXTERNAL_API_KEY = os.getenv("EXTERNAL_API_KEY", "your_default_api_key")
+
+# Path settings (if needed for file uploads or storage)
+UPLOAD_FOLDER = os.getenv("UPLOAD_FOLDER", "/path/to/uploads")
+
+# Define any other global settings here
+PAGINATION_LIMIT = int(os.getenv("PAGINATION_LIMIT", 10))  # Default pagination limit for listing endpoints

controllers/data_logging.py

@@ -0,0 +1,115 @@
+from flask import request, jsonify
+from models.schemas.log_schema import create_log
+from models.schemas.health_schema import create_health_record
+from models.schemas.inventory_schema import create_inventory_item, update_inventory_item
+from models.schemas.usage_schema import create_usage_record
+import datetime
+
+
+# Log an action performed by the user (general logging)
+def log_user_action(user_id, message, level="INFO", metadata=None):
+    """
+    Logs a general user action.
+
+    :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.
+    """
+    try:
+        ip_address = request.remote_addr  # Get the IP address from the request
+        log_id = create_log(level, message, metadata, ip_address, user_id)
+        return jsonify({"message": "Action logged successfully", "log_id": log_id}), 201
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Log a health record for a poultry
+def log_health_record(user_id, poultry_id, disease_name, status, recommendation, image_path=None):
+    """
+    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.
+    """
+    try:
+        record_id = create_health_record(user_id, poultry_id, disease_name, status, recommendation, image_path)
+        # Log the action
+        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 Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Log an inventory addition
+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.
+    """
+    try:
+        item_id = create_inventory_item(item_name, category, quantity, unit, user_id, description=description)
+        # Log the action
+        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 Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Log an inventory update (e.g., usage or adjustments)
+def log_inventory_update(user_id, item_id, updated_fields):
+    """
+    Logs an update to an inventory item (e.g., when quantity is used).
+
+    :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.
+    """
+    try:
+        update_success = update_inventory_item(item_id, updated_fields)
+        if update_success:
+            # Log the action
+            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 Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Log assistant usage
+def log_assistant_usage(user_id, manager_id, interaction_type, metadata=None):
+    """
+    Logs the 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.
+    """
+    try:
+        usage_record_id = create_usage_record(user_id, manager_id, interaction_type, metadata)
+        # Log the action
+        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 Exception as e:
+        return jsonify({"error": str(e)}), 500

controllers/health_management.py

@@ -0,0 +1,93 @@
+from flask import request, jsonify
+from models.schemas.health_schema import create_health_record, get_health_record_by_id, get_health_records_by_user
+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:
+    - user_id: ID of the user submitting the disease detection request.
+    - poultry_id: The 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
+        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:
+            return jsonify({"error": "Missing required fields: user_id, poultry_id, or image"}), 400
+
+        # Run disease detection
+        disease_name, status, recommendation = detect_disease(image)
+
+        # Log the health record
+        record_id = log_health_record(
+            user_id=user_id,
+            poultry_id=poultry_id,
+            disease_name=disease_name,
+            status=status,
+            recommendation=recommendation
+        )
+
+        return jsonify({
+            "message": "Disease detected and health record logged successfully",
+            "disease_name": disease_name,
+            "status": status,
+            "recommendation": recommendation,
+            "record_id": record_id
+        }), 201
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Get Health Record by ID
+def get_health_record(record_id):
+    """
+    Retrieves a health record by its record_id (MongoDB ObjectId).
+
+    Expects:
+    - record_id: ID of the health record.
+
+    Returns:
+    - JSON response with the health record details or an error message if not found.
+    """
+    try:
+        health_record = get_health_record_by_id(record_id)
+        if not health_record:
+            return jsonify({"message": "Health record not found"}), 404
+
+        return jsonify(health_record), 200
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Get Health Records by User
+def get_health_records_for_user(user_id):
+    """
+    Retrieves all health records created by a specific user.
+
+    Expects:
+    - 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.
+    """
+    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(health_records), 200
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500

controllers/inventory.py

@@ -0,0 +1,120 @@
+from flask import request, jsonify
+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
+
+
+# Add a new inventory item
+def add_inventory_item():
+    """
+    Adds a new inventory item to the system.
+
+    Expects:
+    - 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.
+
+    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:
+            return jsonify({"error": "Missing required fields"}), 400
+
+        # Add the inventory item
+        item_id = create_inventory_item(item_name, category, quantity, unit, user_id, description)
+
+        # Log the inventory addition
+        log_inventory_addition(user_id, item_name, category, quantity, unit, description)
+
+        return jsonify({"message": "Inventory item added successfully", "item_id": item_id}), 201
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Update an existing inventory item
+def update_inventory_item_by_id():
+    """
+    Updates an existing inventory item.
+
+    Expects:
+    - 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").
+
+    Returns:
+    - 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')
+
+        if not user_id or not item_id or not updated_fields:
+            return jsonify({"error": "Missing required fields"}), 400
+
+        # Update the inventory item
+        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)
+            return jsonify({"message": "Inventory item updated successfully"}), 200
+        else:
+            return jsonify({"message": "Inventory item update failed"}), 400
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Get an inventory item by its ID
+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.
+
+    Returns:
+    - JSON response with the inventory item details.
+    """
+    try:
+        inventory_item = get_inventory_item_by_id(item_id)
+        if not inventory_item:
+            return jsonify({"message": "Inventory item not found"}), 404
+
+        return jsonify(inventory_item), 200
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Get all inventory items
+def get_all_inventory():
+    """
+    Retrieves all inventory items.
+
+    Returns:
+    - JSON response with the list of all inventory items.
+    """
+    try:
+        inventory_items = get_all_inventory_items()
+        if not inventory_items:
+            return jsonify({"message": "No inventory items found"}), 404
+
+        return jsonify(inventory_items), 200
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500

controllers/usage_tracking.py

@@ -0,0 +1,106 @@
+from flask import request, jsonify
+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
+
+
+# Log assistant usage by a user
+def log_usage():
+    """
+    Logs the usage of the assistant by a user.
+
+    Expects:
+    - user_id: The ID of the user interacting with the assistant.
+    - manager_id: The ID of the user's manager.
+    - interaction_type: The type of interaction (e.g., "disease_detection", "inventory_management").
+    - metadata: Optional. Additional details about the interaction.
+
+    Returns:
+    - JSON response with the result of the logging operation.
+    """
+    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')
+
+        if not user_id or not manager_id or not interaction_type:
+            return jsonify({"error": "Missing required fields"}), 400
+
+        # Log assistant usage
+        usage_record_id = create_usage_record(user_id, manager_id, interaction_type, metadata)
+
+        # Log the usage in the system log
+        log_assistant_usage(user_id, manager_id, interaction_type, metadata)
+
+        return jsonify({"message": "Assistant usage logged successfully", "usage_record_id": usage_record_id}), 201
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Get usage records by user
+def get_usage_for_user(user_id):
+    """
+    Retrieves all assistant usage records for a specific user.
+
+    Expects:
+    - user_id: The ID of the user.
+
+    Returns:
+    - JSON response with the list of usage records for the user.
+    """
+    try:
+        usage_records = get_usage_by_user(user_id)
+        if not usage_records:
+            return jsonify({"message": "No usage records found for this user"}), 404
+
+        return jsonify(usage_records), 200
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Get usage records for all users managed by a specific manager
+def get_usage_for_manager(manager_id):
+    """
+    Retrieves all assistant usage records for users managed by a specific manager.
+
+    Expects:
+    - manager_id: The ID of the manager.
+
+    Returns:
+    - JSON response with the list of usage records for users under the manager.
+    """
+    try:
+        usage_records = get_usage_by_manager(manager_id)
+        if not usage_records:
+            return jsonify({"message": "No usage records found for this manager's users"}), 404
+
+        return jsonify(usage_records), 200
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Get usage records by interaction type
+def get_usage_by_type(interaction_type):
+    """
+    Retrieves all assistant usage records for a specific interaction type.
+
+    Expects:
+    - interaction_type: The type of interaction (e.g., "disease_detection", "inventory_management").
+
+    Returns:
+    - JSON response with the list of usage records for the specified interaction type.
+    """
+    try:
+        usage_records = get_usage_by_interaction_type(interaction_type)
+        if not usage_records:
+            return jsonify({"message": f"No usage records found for interaction type '{interaction_type}'"}), 404
+
+        return jsonify(usage_records), 200
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500

data/logs/daily_logs.py

@@ -0,0 +1,157 @@
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+import datetime
+
+# MongoDB connection (import from your db configuration)
+from config.db import db
+
+# Define the daily logs collection
+daily_logs_collection = db.daily_logs  # Collection to store daily logs
+
+
+# Daily Log Schema
+class DailyLog:
+    def __init__(self, user_id, date, health_status, feed_consumption, mortality_rate, inventory_levels=None,
+                 notes=None):
+        """
+        Initializes a DailyLog object.
+
+        :param user_id: The ID of the user submitting the daily log.
+        :param date: The date of the log (in YYYY-MM-DD format).
+        :param health_status: A summary of the poultry health status.
+        :param feed_consumption: Total feed consumed (in kg, liters, etc.).
+        :param mortality_rate: The percentage or number of poultry that died.
+        :param inventory_levels: Optional. Current inventory levels of key items (feed, medicine).
+        :param notes: Optional. Additional notes or comments about the day's events.
+        """
+        self.user_id = ObjectId(user_id)
+        self.date = date  # Date format: "YYYY-MM-DD"
+        self.health_status = health_status
+        self.feed_consumption = feed_consumption
+        self.mortality_rate = mortality_rate
+        self.inventory_levels = inventory_levels if inventory_levels else {}
+        self.notes = notes
+        self.created_at = datetime.datetime.utcnow()  # Timestamp when the log was created
+
+    def to_dict(self):
+        """
+        Converts the DailyLog object to a dictionary format for MongoDB insertion.
+        :return: dict
+        """
+        return {
+            "user_id": self.user_id,
+            "date": self.date,
+            "health_status": self.health_status,
+            "feed_consumption": self.feed_consumption,
+            "mortality_rate": self.mortality_rate,
+            "inventory_levels": self.inventory_levels,
+            "notes": self.notes,
+            "created_at": self.created_at
+        }
+
+
+# CRUD Operations for Daily Logs
+
+def create_daily_log(user_id, date, health_status, feed_consumption, mortality_rate, inventory_levels=None, notes=None):
+    """
+    Creates a new daily log in the MongoDB collection.
+
+    :param user_id: The ID of the user submitting the log.
+    :param date: The date of the log.
+    :param health_status: Summary of the poultry health status.
+    :param feed_consumption: Total feed consumed.
+    :param mortality_rate: The percentage or number of poultry that died.
+    :param inventory_levels: Optional. Current inventory levels of key items (feed, medicine).
+    :param notes: Optional. Additional notes or comments about the day's events.
+    :return: The inserted log's ID (MongoDB ObjectId).
+    """
+    daily_log = DailyLog(
+        user_id=user_id,
+        date=date,
+        health_status=health_status,
+        feed_consumption=feed_consumption,
+        mortality_rate=mortality_rate,
+        inventory_levels=inventory_levels,
+        notes=notes
+    )
+    log_id = daily_logs_collection.insert_one(daily_log.to_dict()).inserted_id
+    return str(log_id)
+
+
+def get_daily_log_by_id(log_id):
+    """
+    Retrieves a daily log by its MongoDB ObjectId.
+
+    :param log_id: The MongoDB ObjectId of the daily log.
+    :return: The daily log document if found, None if not.
+    """
+    return daily_logs_collection.find_one({"_id": ObjectId(log_id)})
+
+
+def get_daily_logs_by_user(user_id):
+    """
+    Retrieves all daily logs submitted by a specific user.
+
+    :param user_id: The ID of the user.
+    :return: A list of daily log documents.
+    """
+    return list(daily_logs_collection.find({"user_id": ObjectId(user_id)}))
+
+
+def get_daily_logs_by_date(date):
+    """
+    Retrieves all daily logs for a specific date.
+
+    :param date: The date of the logs (in YYYY-MM-DD format).
+    :return: A list of daily log documents for the specified date.
+    """
+    return list(daily_logs_collection.find({"date": date}))
+
+
+def update_daily_log(log_id, updated_fields):
+    """
+    Updates a daily log's fields based on provided data.
+
+    :param log_id: The MongoDB ObjectId of the daily log.
+    :param updated_fields: A dictionary of fields to update (e.g., health_status, feed_consumption).
+    :return: Boolean, True if the update was successful, False otherwise.
+    """
+    result = daily_logs_collection.update_one(
+        {"_id": ObjectId(log_id)},
+        {"$set": updated_fields}
+    )
+    return result.modified_count > 0
+
+
+def delete_daily_log(log_id):
+    """
+    Deletes a daily log from the MongoDB collection by its ObjectId.
+
+    :param log_id: The MongoDB ObjectId of the daily log.
+    :return: Boolean, True if the deletion was successful, False otherwise.
+    """
+    result = daily_logs_collection.delete_one({"_id": ObjectId(log_id)})
+    return result.deleted_count > 0
+
+
+# Example function to create a sample daily log
+if __name__ == "__main__":
+    # Insert a test daily log
+    test_user_id = "610c5e8a85f0b2a4e0b8b918"  # Replace with a valid user ObjectId
+    test_date = "2024-10-07"
+    test_health_status = "All poultry are healthy, no signs of disease."
+    test_feed_consumption = 500  # In kilograms
+    test_mortality_rate = 0.0  # No deaths today
+    test_inventory_levels = {"Feed": 1000, "Antibiotics": 50}  # Inventory in kilograms and units
+
+    log_id = create_daily_log(
+        user_id=test_user_id,
+        date=test_date,
+        health_status=test_health_status,
+        feed_consumption=test_feed_consumption,
+        mortality_rate=test_mortality_rate,
+        inventory_levels=test_inventory_levels,
+        notes="Everything ran smoothly today."
+    )
+
+    print(f"Daily log created with ID: {log_id}")

data/logs/user_usage.py

@@ -0,0 +1,131 @@
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+import datetime
+
+# MongoDB connection (import from your db configuration)
+from config.db import db
+
+# Define the user usage logs collection
+user_usage_collection = db.user_usage  # Collection to store assistant usage logs
+
+
+# User Usage Log Schema
+class UserUsageLog:
+    def __init__(self, user_id, manager_id, interaction_type, metadata=None):
+        """
+        Initializes a UserUsageLog object.
+
+        :param user_id: The ID of the user interacting with the assistant.
+        :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 metadata related to the interaction (e.g., details of the query or result).
+        """
+        self.user_id = ObjectId(user_id)
+        self.manager_id = ObjectId(manager_id)
+        self.interaction_type = interaction_type
+        self.metadata = metadata if metadata else {}
+        self.timestamp = datetime.datetime.utcnow()  # Timestamp when the interaction occurred
+
+    def to_dict(self):
+        """
+        Converts the UserUsageLog object to a dictionary format for MongoDB insertion.
+        :return: dict
+        """
+        return {
+            "user_id": self.user_id,
+            "manager_id": self.manager_id,
+            "interaction_type": self.interaction_type,
+            "metadata": self.metadata,
+            "timestamp": self.timestamp
+        }
+
+
+# CRUD Operations for User Usage Logs
+
+def create_user_usage_log(user_id, manager_id, interaction_type, metadata=None):
+    """
+    Creates a new user usage log in the MongoDB collection.
+
+    :param user_id: The ID of the user interacting with the assistant.
+    :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 metadata related to the interaction.
+    :return: The inserted log's ID (MongoDB ObjectId).
+    """
+    usage_log = UserUsageLog(
+        user_id=user_id,
+        manager_id=manager_id,
+        interaction_type=interaction_type,
+        metadata=metadata
+    )
+    log_id = user_usage_collection.insert_one(usage_log.to_dict()).inserted_id
+    return str(log_id)
+
+
+def get_usage_log_by_id(log_id):
+    """
+    Retrieves a user usage log by its MongoDB ObjectId.
+
+    :param log_id: The MongoDB ObjectId of the usage log.
+    :return: The usage log document if found, None if not.
+    """
+    return user_usage_collection.find_one({"_id": ObjectId(log_id)})
+
+
+def get_usage_logs_by_user(user_id):
+    """
+    Retrieves all usage logs for a specific user.
+
+    :param user_id: The ID of the user.
+    :return: A list of usage log documents for the user.
+    """
+    return list(user_usage_collection.find({"user_id": ObjectId(user_id)}))
+
+
+def get_usage_logs_by_manager(manager_id):
+    """
+    Retrieves all usage logs for users managed by a specific manager.
+
+    :param manager_id: The ID of the manager.
+    :return: A list of usage log documents for the users under the manager's supervision.
+    """
+    return list(user_usage_collection.find({"manager_id": ObjectId(manager_id)}))
+
+
+def get_usage_logs_by_interaction_type(interaction_type):
+    """
+    Retrieves all usage logs for a specific interaction type (e.g., "disease_detection").
+
+    :param interaction_type: The type of interaction.
+    :return: A list of usage log documents for the specified interaction type.
+    """
+    return list(user_usage_collection.find({"interaction_type": interaction_type}))
+
+
+def delete_usage_log(log_id):
+    """
+    Deletes a user usage log from the MongoDB collection by its ObjectId.
+
+    :param log_id: The MongoDB ObjectId of the usage log.
+    :return: Boolean, True if the deletion was successful, False otherwise.
+    """
+    result = user_usage_collection.delete_one({"_id": ObjectId(log_id)})
+    return result.deleted_count > 0
+
+
+# Example function to create a sample user usage log
+if __name__ == "__main__":
+    # Insert a test user usage log
+    test_user_id = "610c5e8a85f0b2a4e0b8b918"  # Replace with a valid user ObjectId
+    test_manager_id = "610c5e8a85f0b2a4e0b8b919"  # Replace with a valid manager ObjectId
+    test_interaction_type = "disease_detection"
+    test_metadata = {"disease_name": "Coccidiosis", "detected": True}
+
+    log_id = create_user_usage_log(
+        user_id=test_user_id,
+        manager_id=test_manager_id,
+        interaction_type=test_interaction_type,
+        metadata=test_metadata
+    )
+
+    print(f"User usage log created with ID: {log_id}")

models/schemas/health_schema.py

@@ -0,0 +1,138 @@
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+import datetime
+
+# MongoDB connection (move to config/db.py and import here)
+from config.db import db
+
+# Define the health collection
+health_collection = db.health  # Collection to store poultry health records
+
+
+# Health Record Schema
+class HealthRecord:
+    def __init__(self, user_id, poultry_id, disease_name, status, recommendation, image_path=None):
+        """
+        Initializes a HealthRecord object.
+
+        :param user_id: The ID of the user who is managing the poultry.
+        :param poultry_id: A unique identifier for the poultry (e.g., tag number).
+        :param disease_name: The name of the detected disease (e.g., Coccidiosis, New Castle Disease).
+        :param status: The health status of the poultry (e.g., "Critical", "No issue").
+        :param recommendation: The treatment recommendation (e.g., "Percetamol", "Panadol").
+        :param image_path: Optional. The path to the image of the poultry or fecal matter.
+        """
+        self.user_id = ObjectId(user_id)  # Link to the user (farm manager)
+        self.poultry_id = poultry_id  # Unique poultry ID (could be a tag, or system-generated)
+        self.disease_name = disease_name  # Disease detected
+        self.status = status  # Health status (e.g., "Critical", "No issue")
+        self.recommendation = recommendation  # Suggested treatment or recommendation
+        self.image_path = image_path  # Optional image path for the health record
+        self.created_at = datetime.datetime.utcnow()  # Timestamp for record creation
+
+    def to_dict(self):
+        """
+        Converts the HealthRecord object to a dictionary format for MongoDB insertion.
+        :return: dict
+        """
+        return {
+            "user_id": self.user_id,
+            "poultry_id": self.poultry_id,
+            "disease_name": self.disease_name,
+            "status": self.status,
+            "recommendation": self.recommendation,
+            "image_path": self.image_path,
+            "created_at": self.created_at
+        }
+
+
+# CRUD Operations for Health Records
+
+def create_health_record(user_id, poultry_id, disease_name, status, recommendation, image_path=None):
+    """
+    Creates a new health record in the MongoDB collection.
+
+    :param user_id: The ID of the user managing the poultry.
+    :param poultry_id: A unique identifier for the poultry.
+    :param disease_name: Name of the detected disease.
+    :param status: The health status of the poultry.
+    :param recommendation: Treatment recommendation.
+    :param image_path: Optional path to the related image.
+    :return: The inserted record's ID (MongoDB ObjectId).
+    """
+    health_record = HealthRecord(
+        user_id=user_id,
+        poultry_id=poultry_id,
+        disease_name=disease_name,
+        status=status,
+        recommendation=recommendation,
+        image_path=image_path
+    )
+    record_id = health_collection.insert_one(health_record.to_dict()).inserted_id
+    return str(record_id)
+
+
+def get_health_record_by_id(record_id):
+    """
+    Retrieves a health record by its MongoDB ObjectId.
+
+    :param record_id: The MongoDB ObjectId of the health record.
+    :return: The health record document if found, None if not.
+    """
+    return health_collection.find_one({"_id": ObjectId(record_id)})
+
+
+def get_health_records_by_user(user_id):
+    """
+    Retrieves all health records created by a specific user.
+
+    :param user_id: The ID of the user.
+    :return: A list of health record documents created by the user.
+    """
+    return list(health_collection.find({"user_id": ObjectId(user_id)}))
+
+
+def update_health_record(record_id, updated_fields):
+    """
+    Updates a health record's fields based on provided data.
+
+    :param record_id: The MongoDB ObjectId of the health record.
+    :param updated_fields: A dictionary of fields to update (e.g., status, recommendation).
+    :return: Boolean, True if the update was successful, False otherwise.
+    """
+    result = health_collection.update_one(
+        {"_id": ObjectId(record_id)},
+        {"$set": updated_fields}
+    )
+    return result.modified_count > 0
+
+
+def delete_health_record(record_id):
+    """
+    Deletes a health record from the MongoDB collection by its ObjectId.
+
+    :param record_id: The MongoDB ObjectId of the health record.
+    :return: Boolean, True if the deletion was successful, False otherwise.
+    """
+    result = health_collection.delete_one({"_id": ObjectId(record_id)})
+    return result.deleted_count > 0
+
+
+# Example function to create a sample health record
+if __name__ == "__main__":
+    # Insert a test health record
+    test_user_id = "610c5e8a85f0b2a4e0b8b918"  # Replace with a valid user ObjectId
+    test_poultry_id = "poultry123"
+    test_disease_name = "Coccidiosis"
+    test_status = "Critical"
+    test_recommendation = "Panadol"
+
+    record_id = create_health_record(
+        user_id=test_user_id,
+        poultry_id=test_poultry_id,
+        disease_name=test_disease_name,
+        status=test_status,
+        recommendation=test_recommendation
+    )
+
+    print(f"Health record created with ID: {record_id}")

models/schemas/inventory_schema.py

@@ -0,0 +1,146 @@
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+import datetime
+
+# MongoDB connection (move to config/db.py and import here)
+from config.db import db
+
+# Define the inventory collection
+inventory_collection = db.inventory  # Collection to store inventory items
+
+
+# Inventory Item Schema
+class InventoryItem:
+    def __init__(self, item_name, category, quantity, unit, added_by, used_quantity=0, description=None):
+        """
+        Initializes an InventoryItem object.
+
+        :param item_name: The name of the inventory item (e.g., "Chicken Feed", "Antibiotics").
+        :param category: The category of the item (e.g., "Feed", "Medicine", "Supplies").
+        :param quantity: The total quantity of the item.
+        :param unit: The unit of measurement (e.g., "kg", "liters", "units").
+        :param added_by: The ID of the user who added the item.
+        :param used_quantity: The quantity that has been used (defaults to 0).
+        :param description: Optional. Additional description or notes about the item.
+        """
+        self.item_name = item_name
+        self.category = category
+        self.quantity = quantity
+        self.unit = unit
+        self.added_by = ObjectId(added_by)  # User who added the item
+        self.used_quantity = used_quantity
+        self.description = description
+        self.created_at = datetime.datetime.utcnow()  # Timestamp when the item was added
+        self.updated_at = datetime.datetime.utcnow()  # Timestamp when the item was last updated
+
+    def to_dict(self):
+        """
+        Converts the InventoryItem object to a dictionary format for MongoDB insertion.
+        :return: dict
+        """
+        return {
+            "item_name": self.item_name,
+            "category": self.category,
+            "quantity": self.quantity,
+            "unit": self.unit,
+            "added_by": self.added_by,
+            "used_quantity": self.used_quantity,
+            "description": self.description,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at
+        }
+
+
+# CRUD Operations for Inventory Items
+
+def create_inventory_item(item_name, category, quantity, unit, added_by, used_quantity=0, description=None):
+    """
+    Creates a new inventory item in the MongoDB collection.
+
+    :param item_name: Name of the inventory item.
+    :param category: Category of the item (e.g., "Feed", "Medicine").
+    :param quantity: Total quantity available.
+    :param unit: Unit of measurement (e.g., kg, liters, units).
+    :param added_by: ID of the user who added the item.
+    :param used_quantity: Quantity that has been used (default is 0).
+    :param description: Optional description or notes.
+    :return: The inserted record's ID (MongoDB ObjectId).
+    """
+    inventory_item = InventoryItem(
+        item_name=item_name,
+        category=category,
+        quantity=quantity,
+        unit=unit,
+        added_by=added_by,
+        used_quantity=used_quantity,
+        description=description
+    )
+    item_id = inventory_collection.insert_one(inventory_item.to_dict()).inserted_id
+    return str(item_id)
+
+
+def get_inventory_item_by_id(item_id):
+    """
+    Retrieves an inventory item by its MongoDB ObjectId.
+
+    :param item_id: The MongoDB ObjectId of the inventory item.
+    :return: The inventory item document if found, None if not.
+    """
+    return inventory_collection.find_one({"_id": ObjectId(item_id)})
+
+
+def get_all_inventory_items():
+    """
+    Retrieves all inventory items from the MongoDB collection.
+
+    :return: A list of inventory item documents.
+    """
+    return list(inventory_collection.find())
+
+
+def update_inventory_item(item_id, updated_fields):
+    """
+    Updates an inventory item's fields based on provided data.
+
+    :param item_id: The MongoDB ObjectId of the inventory item.
+    :param updated_fields: A dictionary of fields to update (e.g., quantity, used_quantity).
+    :return: Boolean, True if the update was successful, False otherwise.
+    """
+    updated_fields["updated_at"] = datetime.datetime.utcnow()  # Update the timestamp
+    result = inventory_collection.update_one(
+        {"_id": ObjectId(item_id)},
+        {"$set": updated_fields}
+    )
+    return result.modified_count > 0
+
+
+def delete_inventory_item(item_id):
+    """
+    Deletes an inventory item from the MongoDB collection by its ObjectId.
+
+    :param item_id: The MongoDB ObjectId of the inventory item.
+    :return: Boolean, True if the deletion was successful, False otherwise.
+    """
+    result = inventory_collection.delete_one({"_id": ObjectId(item_id)})
+    return result.deleted_count > 0
+
+
+# Example function to create a sample inventory item
+if __name__ == "__main__":
+    # Insert a test inventory item
+    test_item_name = "Chicken Feed"
+    test_category = "Feed"
+    test_quantity = 1000  # 1000 kg
+    test_unit = "kg"
+    test_added_by = "610c5e8a85f0b2a4e0b8b918"  # Replace with a valid user ObjectId
+
+    item_id = create_inventory_item(
+        item_name=test_item_name,
+        category=test_category,
+        quantity=test_quantity,
+        unit=test_unit,
+        added_by=test_added_by,
+        description="Premium feed for broiler chickens"
+    )
+
+    print(f"Inventory item created with ID: {item_id}")

models/schemas/log_schema.py

@@ -0,0 +1,129 @@
+from pymongo import MongoClient, IndexModel, ASCENDING
+from bson.objectid import ObjectId
+import datetime
+
+# MongoDB connection (move to config/db.py and import here)
+from config.db import db
+
+# Define the logs collection
+logs_collection = db.logs  # Collection to store system logs
+
+# TTL index to expire documents after 30 days
+logs_collection.create_index([("timestamp", ASCENDING)], expireAfterSeconds=30 * 24 * 60 * 60)
+
+
+# Log Record Schema
+class LogRecord:
+    def __init__(self, level, message, metadata=None, ip_address=None, user_id=None):
+        """
+        Initializes a LogRecord object.
+
+        :param level: Logging level (e.g., "INFO", "ERROR", "WARNING", "DEBUG").
+        :param message: The log message or description of the event.
+        :param metadata: Optional. Additional metadata such as request details or stack trace.
+        :param ip_address: Optional. The IP address from where the action originated.
+        :param user_id: Optional. The ID of the user associated with the action (if applicable).
+        """
+        self.level = level
+        self.message = message
+        self.metadata = metadata if metadata else {}
+        self.ip_address = ip_address
+        self.user_id = ObjectId(user_id) if user_id else None
+        self.timestamp = datetime.datetime.utcnow()  # Timestamp of the log event
+
+    def to_dict(self):
+        """
+        Converts the LogRecord object to a dictionary format for MongoDB insertion.
+        :return: dict
+        """
+        return {
+            "level": self.level,
+            "message": self.message,
+            "metadata": self.metadata,
+            "ip_address": self.ip_address,
+            "user_id": self.user_id,
+            "timestamp": self.timestamp
+        }
+
+
+# CRUD Operations for Logs
+
+def create_log(level, message, metadata=None, ip_address=None, user_id=None):
+    """
+    Creates a new log record in the MongoDB collection.
+
+    :param level: Logging level (e.g., "INFO", "ERROR", "WARNING", "DEBUG").
+    :param message: Log message.
+    :param metadata: Optional metadata (e.g., stack trace, request details).
+    :param ip_address: Optional IP address from which the log originated.
+    :param user_id: Optional user ID associated with the log event.
+    :return: The inserted log record's ID (MongoDB ObjectId).
+    """
+    log_record = LogRecord(
+        level=level,
+        message=message,
+        metadata=metadata,
+        ip_address=ip_address,
+        user_id=user_id
+    )
+    log_id = logs_collection.insert_one(log_record.to_dict()).inserted_id
+    return str(log_id)
+
+
+def get_log_by_id(log_id):
+    """
+    Retrieves a log record by its MongoDB ObjectId.
+
+    :param log_id: The MongoDB ObjectId of the log.
+    :return: The log document if found, None if not.
+    """
+    return logs_collection.find_one({"_id": ObjectId(log_id)})
+
+
+def get_logs_by_user(user_id):
+    """
+    Retrieves all log records associated with a specific user.
+
+    :param user_id: The ID of the user associated with the logs.
+    :return: A list of log documents.
+    """
+    return list(logs_collection.find({"user_id": ObjectId(user_id)}))
+
+
+def get_logs_by_level(level):
+    """
+    Retrieves all log records with a specific logging level (e.g., "ERROR").
+
+    :param level: The logging level (e.g., "INFO", "ERROR", "DEBUG").
+    :return: A list of log documents.
+    """
+    return list(logs_collection.find({"level": level}))
+
+
+def delete_old_logs():
+    """
+    Deletes logs that are older than the TTL (30 days). This is automatically handled by the TTL index,
+    so this function can be used to manually trigger a cleanup if necessary.
+    """
+    # No manual deletion needed as MongoDB TTL will automatically handle the deletion.
+    pass
+
+
+# Example function to create a sample log
+if __name__ == "__main__":
+    # Insert a test log record
+    test_level = "ERROR"
+    test_message = "An error occurred in the system."
+    test_metadata = {"stack_trace": "Traceback (most recent call last): ..."}
+    test_ip_address = "192.168.1.1"
+    test_user_id = "610c5e8a85f0b2a4e0b8b918"  # Replace with a valid user ObjectId
+
+    log_id = create_log(
+        level=test_level,
+        message=test_message,
+        metadata=test_metadata,
+        ip_address=test_ip_address,
+        user_id=test_user_id
+    )
+
+    print(f"Log record created with ID: {log_id}")

models/schemas/usage_schema.py

@@ -0,0 +1,121 @@
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+import datetime
+
+# MongoDB connection (move to config/db.py and import here)
+from config.db import db
+
+# Define the usage collection
+usage_collection = db.usage  # Collection to store assistant usage records
+
+
+# Usage Record Schema
+class UsageRecord:
+    def __init__(self, user_id, manager_id, interaction_type, metadata=None):
+        """
+        Initializes a UsageRecord object.
+
+        :param user_id: The ID of the user who interacted with the assistant.
+        :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 metadata for the interaction (e.g., details of the query or response).
+        """
+        self.user_id = ObjectId(user_id)  # The user interacting with the assistant
+        self.manager_id = ObjectId(manager_id)  # The manager overseeing the user
+        self.interaction_type = interaction_type  # Type of interaction (e.g., disease detection, inventory management)
+        self.metadata = metadata if metadata else {}
+        self.timestamp = datetime.datetime.utcnow()  # Timestamp of the interaction
+
+    def to_dict(self):
+        """
+        Converts the UsageRecord object to a dictionary format for MongoDB insertion.
+        :return: dict
+        """
+        return {
+            "user_id": self.user_id,
+            "manager_id": self.manager_id,
+            "interaction_type": self.interaction_type,
+            "metadata": self.metadata,
+            "timestamp": self.timestamp
+        }
+
+
+# CRUD Operations for Usage Records
+
+def create_usage_record(user_id, manager_id, interaction_type, metadata=None):
+    """
+    Creates a new usage record in the MongoDB collection.
+
+    :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 metadata for the interaction.
+    :return: The inserted usage record's ID (MongoDB ObjectId).
+    """
+    usage_record = UsageRecord(
+        user_id=user_id,
+        manager_id=manager_id,
+        interaction_type=interaction_type,
+        metadata=metadata
+    )
+    record_id = usage_collection.insert_one(usage_record.to_dict()).inserted_id
+    return str(record_id)
+
+
+def get_usage_by_user(user_id):
+    """
+    Retrieves all usage records for a specific user.
+
+    :param user_id: The ID of the user.
+    :return: A list of usage record documents created by the user.
+    """
+    return list(usage_collection.find({"user_id": ObjectId(user_id)}))
+
+
+def get_usage_by_manager(manager_id):
+    """
+    Retrieves all usage records for users under a specific manager.
+
+    :param manager_id: The ID of the manager.
+    :return: A list of usage record documents for users managed by the manager.
+    """
+    return list(usage_collection.find({"manager_id": ObjectId(manager_id)}))
+
+
+def get_usage_by_interaction_type(interaction_type):
+    """
+    Retrieves all usage records with a specific interaction type (e.g., "disease_detection").
+
+    :param interaction_type: The type of interaction (e.g., "disease_detection", "inventory_management").
+    :return: A list of usage record documents for the specified interaction type.
+    """
+    return list(usage_collection.find({"interaction_type": interaction_type}))
+
+
+def delete_usage_record(record_id):
+    """
+    Deletes a usage record from the MongoDB collection by its ObjectId.
+
+    :param record_id: The MongoDB ObjectId of the usage record.
+    :return: Boolean, True if the deletion was successful, False otherwise.
+    """
+    result = usage_collection.delete_one({"_id": ObjectId(record_id)})
+    return result.deleted_count > 0
+
+
+# Example function to create a sample usage record
+if __name__ == "__main__":
+    # Insert a test usage record
+    test_user_id = "610c5e8a85f0b2a4e0b8b918"  # Replace with a valid user ObjectId
+    test_manager_id = "610c5e8a85f0b2a4e0b8b919"  # Replace with a valid manager ObjectId
+    test_interaction_type = "disease_detection"
+    test_metadata = {"disease_name": "Coccidiosis", "detected": True}
+
+    record_id = create_usage_record(
+        user_id=test_user_id,
+        manager_id=test_manager_id,
+        interaction_type=test_interaction_type,
+        metadata=test_metadata
+    )
+
+    print(f"Usage record created with ID: {record_id}")

requirements.txt

@@ -1,11 +1,28 @@
-keras~=2.12.0
-gradio~=4.40.0
-opencv-python~=4.10.0.84
-tensorflow==2.12.0
-transformers~=4.43.3
-numpy~=1.23.5
+# Machine Learning Libraries
+tensorflow
+tensorflow-gpu
+keras
+torch
 torchvision
+numpy
+
+# Transformers and AI model handling
+transformers
 accelerate
-openai==0.28
+
+# Image Processing Libraries
+opencv-python
+
+# Web Framework and MongoDB
+flask
 pymongo
-torch
+bson
+
+# Gradio Interface for the Chatbot
+gradio
+
+# Data Handling and Analysis
+pandas
+
+# OpenAI Integration
+openai

routes/api.py

@@ -0,0 +1,160 @@
+from flask import Blueprint, jsonify, request
+from controllers.health_management import detect_and_log_disease, get_health_record, get_health_records_for_user
+from controllers.inventory import add_inventory_item, update_inventory_item_by_id, get_inventory_by_id, \
+    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
+
+# Create a Blueprint for the API routes
+api_bp = Blueprint('api', __name__)
+
+
+# Health Management Routes
+@api_bp.route('/detect-disease', methods=['POST'])
+def detect_disease_route():
+    """
+    Route for detecting a disease and logging the health record.
+    Expects a POST request with:
+    - user_id: ID of the user.
+    - poultry_id: ID of the poultry.
+    - image: The image of poultry feces for disease detection.
+
+    Returns: JSON response with disease detection results and log status.
+    """
+    return detect_and_log_disease()
+
+
+@api_bp.route('/health-record/<record_id>', methods=['GET'])
+def get_health_record_route(record_id):
+    """
+    Route for retrieving a health record by its ID.
+
+    Returns: JSON response with the health record details.
+    """
+    return get_health_record(record_id)
+
+
+@api_bp.route('/health-records/<user_id>', methods=['GET'])
+def get_health_records_for_user_route(user_id):
+    """
+    Route for retrieving all health records for a specific user.
+
+    Returns: JSON response with the list of health records.
+    """
+    return get_health_records_for_user(user_id)
+
+
+# Inventory Management Routes
+@api_bp.route('/add-inventory-item', methods=['POST'])
+def add_inventory_item_route():
+    """
+    Route for adding a new inventory item.
+    Expects a POST request with:
+    - user_id: ID of the user.
+    - item_name: Name of the item.
+    - category: Category of the item.
+    - quantity: Quantity of the item.
+    - unit: Unit of measurement.
+
+    Returns: JSON response with the item addition status.
+    """
+    return add_inventory_item()
+
+
+@api_bp.route('/update-inventory-item', methods=['PUT'])
+def update_inventory_item_route():
+    """
+    Route for updating an inventory item.
+    Expects a PUT request with:
+    - user_id: ID of the user.
+    - item_id: ID of the inventory item to update.
+    - updated_fields: Fields to update (e.g., quantity, used_quantity).
+
+    Returns: JSON response with the item update status.
+    """
+    return update_inventory_item_by_id()
+
+
+@api_bp.route('/inventory-item/<item_id>', methods=['GET'])
+def get_inventory_item_route(item_id):
+    """
+    Route for retrieving an inventory item by its ID.
+
+    Returns: JSON response with the inventory item details.
+    """
+    return get_inventory_by_id(item_id)
+
+
+@api_bp.route('/inventory', methods=['GET'])
+def get_all_inventory_route():
+    """
+    Route for retrieving all inventory items.
+
+    Returns: JSON response with the list of all inventory items.
+    """
+    return get_all_inventory()
+
+
+# Assistant Usage Tracking Routes
+@api_bp.route('/log-usage', methods=['POST'])
+def log_usage_route():
+    """
+    Route for logging 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: The type of interaction.
+
+    Returns: JSON response with the log status.
+    """
+    return log_usage()
+
+
+@api_bp.route('/usage/<user_id>', methods=['GET'])
+def get_usage_for_user_route(user_id):
+    """
+    Route for retrieving all usage logs for a specific user.
+
+    Returns: JSON response with the list of usage logs for the user.
+    """
+    return get_usage_for_user(user_id)
+
+
+@api_bp.route('/manager-usage/<manager_id>', methods=['GET'])
+def get_usage_for_manager_route(manager_id):
+    """
+    Route for retrieving all usage logs for users managed by a specific manager.
+
+    Returns: JSON response with the list of usage logs for the manager's users.
+    """
+    return get_usage_for_manager(manager_id)
+
+
+@api_bp.route('/usage-type/<interaction_type>', methods=['GET'])
+def get_usage_by_type_route(interaction_type):
+    """
+    Route for retrieving all usage logs for a specific interaction type.
+
+    Returns: JSON response with the list of usage logs for the interaction type.
+    """
+    return get_usage_by_type(interaction_type)
+
+
+# User Action Logging Route
+@api_bp.route('/log-user-action', methods=['POST'])
+def log_user_action_route():
+    """
+    Route for logging general user actions.
+    Expects a POST request with:
+    - user_id: ID of the user performing the action.
+    - message: Description of the action.
+    - level: Logging level (default is "INFO").
+
+    Returns: JSON response with the log status.
+    """
+    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)

routes/data_logging_routes.py

@@ -0,0 +1,157 @@
+from flask import Blueprint, request, jsonify
+from controllers.data_logging import log_user_action, log_health_record, log_inventory_addition, log_inventory_update, \
+    log_assistant_usage
+
+# Create a Blueprint for the data logging routes
+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():
+    """
+    Logs a general user action.
+
+    Expects a POST request with:
+    - user_id: ID of the user performing the action.
+    - message: Description of the action.
+    - level: Logging level (default is "INFO").
+    - metadata: Optional. Additional metadata related to the action.
+
+    Returns: JSON response indicating success or failure.
+    """
+    try:
+        user_id = request.json.get('user_id')
+        message = request.json.get('message')
+        level = request.json.get('level', 'INFO')
+        metadata = request.json.get('metadata', {})
+
+        if not user_id or not message:
+            return jsonify({"error": "Missing required fields"}), 400
+
+        return log_user_action(user_id, message, level, metadata)
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Route to log a health record
+@data_logging_bp.route('/log-health-record', methods=['POST'])
+def log_health_record_route():
+    """
+    Logs a health record for poultry.
+
+    Expects a POST request with:
+    - user_id: ID of the user submitting the record.
+    - poultry_id: The ID of the poultry.
+    - disease_name: Name of the detected disease.
+    - status: The health status of the poultry.
+    - recommendation: Recommended treatment.
+    - image_path: Optional. Path to an image related to the health record.
+
+    Returns: JSON response indicating success or failure.
+    """
+    try:
+        user_id = request.json.get('user_id')
+        poultry_id = request.json.get('poultry_id')
+        disease_name = request.json.get('disease_name')
+        status = request.json.get('status')
+        recommendation = request.json.get('recommendation')
+        image_path = request.json.get('image_path')
+
+        if not user_id or not poultry_id or not disease_name or not status or not 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
+
+
+# Route to log inventory addition
+@data_logging_bp.route('/log-inventory-addition', methods=['POST'])
+def log_inventory_addition_route():
+    """
+    Logs the addition of an inventory item.
+
+    Expects a POST request with:
+    - user_id: 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 added.
+    - unit: Unit of measurement (e.g., "kg", "liters").
+    - description: Optional. Additional description or notes.
+
+    Returns: JSON response indicating success or failure.
+    """
+    try:
+        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:
+            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
+
+
+# Route to log inventory update
+@data_logging_bp.route('/log-inventory-update', methods=['PUT'])
+def log_inventory_update_route():
+    """
+    Logs an update to an existing inventory item.
+
+    Expects a PUT request with:
+    - user_id: ID of the user updating the item.
+    - item_id: ID of the inventory item being updated.
+    - updated_fields: Fields being updated (e.g., "quantity", "used_quantity").
+
+    Returns: JSON response indicating success or failure.
+    """
+    try:
+        user_id = request.json.get('user_id')
+        item_id = request.json.get('item_id')
+        updated_fields = request.json.get('updated_fields')
+
+        if not user_id or not item_id or not 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
+
+
+# Route to log assistant usage
+@data_logging_bp.route('/log-assistant-usage', methods=['POST'])
+def log_assistant_usage_route():
+    """
+    Logs 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 overseeing the user.
+    - interaction_type: The type of interaction (e.g., "disease_detection", "inventory_management").
+    - metadata: Optional. Additional details about the interaction.
+
+    Returns: JSON response indicating success or failure.
+    """
+    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')
+
+        if not user_id or not manager_id or not 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

routes/health_routes.py

@@ -0,0 +1,56 @@
+from flask import Blueprint, request, jsonify
+from controllers.health_management import detect_and_log_disease, get_health_record, get_health_records_for_user
+
+# Create a Blueprint for the health-related routes
+health_bp = Blueprint('health', __name__)
+
+
+# Route to detect disease and log the health record
+@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.
+    - 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()
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Route to get a health record by its ID
+@health_bp.route('/health-record/<record_id>', methods=['GET'])
+def get_health_record_route(record_id):
+    """
+    Retrieve a health record by its ID.
+
+    Expects a GET request with the health record ID in the URL.
+
+    Returns: JSON response with the health record details.
+    """
+    try:
+        return get_health_record(record_id)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Route to get all health records for a specific user
+@health_bp.route('/health-records/<user_id>', methods=['GET'])
+def get_health_records_for_user_route(user_id):
+    """
+    Retrieve all health records for a specific user.
+
+    Expects a GET request with the user ID in the URL.
+
+    Returns: JSON response with the list of health records for the user.
+    """
+    try:
+        return get_health_records_for_user(user_id)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500

routes/inventory_routes.py

@@ -0,0 +1,77 @@
+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
+
+# Create a Blueprint for the inventory-related routes
+inventory_bp = Blueprint('inventory', __name__)
+
+
+# Route to add a new inventory item
+@inventory_bp.route('/add-inventory-item', methods=['POST'])
+def add_inventory_item_route():
+    """
+    Add a new inventory item to the system.
+
+    Expects a POST request with the following fields:
+    - user_id: The ID of the user adding 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 description or notes about the item.
+
+    Returns: JSON response with the status of the addition.
+    """
+    try:
+        return add_inventory_item()
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Route to update an existing inventory item
+@inventory_bp.route('/update-inventory-item', methods=['PUT'])
+def update_inventory_item_route():
+    """
+    Update an existing inventory item in the system.
+
+    Expects a PUT request with the following fields:
+    - 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()
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Route to get an inventory item by its ID
+@inventory_bp.route('/inventory-item/<item_id>', methods=['GET'])
+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
+
+
+# Route to get all inventory items
+@inventory_bp.route('/inventory', methods=['GET'])
+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

routes/usage_routes.py

@@ -0,0 +1,73 @@
+from flask import Blueprint, request, jsonify
+from controllers.usage_tracking import log_usage, get_usage_for_user, get_usage_for_manager, get_usage_by_type
+
+# Create a Blueprint for the usage-related routes
+usage_bp = Blueprint('usage', __name__)
+
+
+# Route to log the usage of the assistant by a user
+@usage_bp.route('/log-usage', methods=['POST'])
+def log_usage_route():
+    """
+    Logs the usage of the assistant by a user.
+
+    Expects a POST request with the following fields:
+    - user_id: The ID of the user interacting with the assistant.
+    - manager_id: The ID of the user's manager.
+    - interaction_type: The type of interaction (e.g., "disease_detection", "inventory_management").
+    - metadata: Optional. Additional details about the interaction (e.g., query details or results).
+
+    Returns: JSON response indicating success or failure.
+    """
+    try:
+        return log_usage()
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Route to get all assistant usage logs for a specific user
+@usage_bp.route('/usage/<user_id>', methods=['GET'])
+def get_usage_for_user_route(user_id):
+    """
+    Retrieve all assistant usage logs for a specific user.
+
+    Expects a GET request with the user_id as a URL parameter.
+
+    Returns: JSON response with the list of usage logs for the user.
+    """
+    try:
+        return get_usage_for_user(user_id)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Route to get all assistant usage logs for users managed by a specific manager
+@usage_bp.route('/manager-usage/<manager_id>', methods=['GET'])
+def get_usage_for_manager_route(manager_id):
+    """
+    Retrieve all assistant usage logs for users managed by a specific manager.
+
+    Expects a GET request with the manager_id as a URL parameter.
+
+    Returns: JSON response with the list of usage logs for the manager's users.
+    """
+    try:
+        return get_usage_for_manager(manager_id)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# Route to get all assistant usage logs for a specific interaction type
+@usage_bp.route('/usage-type/<interaction_type>', methods=['GET'])
+def get_usage_by_type_route(interaction_type):
+    """
+    Retrieve all assistant usage logs for a specific interaction type.
+
+    Expects a GET request with the interaction_type as a URL parameter (e.g., "disease_detection", "inventory_management").
+
+    Returns: JSON response with the list of usage logs for the specified interaction type.
+    """
+    try:
+        return get_usage_by_type(interaction_type)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500

services/disease_detection.py

@@ -0,0 +1,35 @@
+import cv2
+import numpy as np
+from keras.models import load_model
+
+# Load the model (ensure the path is correct)
+my_model = load_model('models/Final_Chicken_disease_model.h5')
+
+# Disease names and recommendations
+name_disease = {0: 'Coccidiosis', 1: 'Healthy', 2: 'New Castle Disease', 3: 'Salmonella'}
+result = {0: 'Critical', 1: 'No issue', 2: 'Critical', 3: 'Critical'}
+recommend = {0: 'Panadol', 1: 'You have no need Medicine', 2: 'Percetamol', 3: 'Ponston'}
+
+
+class PoultryFarmBot:
+    def __init__(self, db):
+        self.db = db  # MongoDB database for future use
+
+    def preprocess_image(self, image):
+        try:
+            image_check = cv2.resize(image, (224, 224))
+            image_check = np.expand_dims(image_check, axis=0)
+            return image_check
+        except Exception as e:
+            print(f"Error in image preprocessing: {e}")
+            return None
+
+    def predict(self, image):
+        image_check = self.preprocess_image(image)
+        if image_check is None:
+            return "Image preprocessing failed.", None, None, None
+        indx = my_model.predict(image_check).argmax()
+        name = name_disease.get(indx, "Unknown disease")
+        status = result.get(indx, "unknown condition")
+        recom = recommend.get(indx, "no recommendation available")
+        return name, status, recom

services/gradio_interface.py

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,111 @@
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+import datetime
+
+# MongoDB Setup (import from your db configuration)
+from config.db import db
+
+# Define the inventory collection
+inventory_collection = db.inventory  # MongoDB collection to store inventory items
+
+
+# Inventory Management Service
+
+class InventoryManager:
+    """
+    Inventory Manager Service to handle adding, updating, and retrieving inventory items.
+    """
+
+    def __init__(self):
+        self.collection = inventory_collection
+
+    def add_inventory_item(self, user_id, item_name, category, quantity, unit, description=None):
+        """
+        Add a new item to the inventory.
+
+        :param user_id: The ID of the user adding the item.
+        :param item_name: The name of the inventory item.
+        :param category: The category of the item (e.g., "Feed", "Medicine").
+        :param quantity: The total quantity of the item.
+        :param unit: The unit of measurement (e.g., "kg", "liters").
+        :param description: Optional. Additional description or notes about the item.
+        :return: The inserted inventory item's ID.
+        """
+        try:
+            new_item = {
+                "user_id": ObjectId(user_id),
+                "item_name": item_name,
+                "category": category,
+                "quantity": quantity,
+                "unit": unit,
+                "description": description,
+                "created_at": datetime.datetime.utcnow(),
+                "updated_at": datetime.datetime.utcnow()
+            }
+            result = self.collection.insert_one(new_item)
+            return str(result.inserted_id)
+        except Exception as e:
+            print(f"Error adding inventory item: {e}")
+            return None
+
+    def update_inventory_item(self, item_id, updated_fields):
+        """
+        Update an existing inventory item with new values.
+
+        :param item_id: The ID of the inventory item to be updated.
+        :param updated_fields: A dictionary containing the fields to be updated (e.g., quantity, description).
+        :return: Boolean indicating whether the update was successful.
+        """
+        try:
+            updated_fields['updated_at'] = datetime.datetime.utcnow()  # Update timestamp
+            result = self.collection.update_one(
+                {"_id": ObjectId(item_id)},
+                {"$set": updated_fields}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            print(f"Error updating inventory item: {e}")
+            return False
+
+    def get_inventory_item_by_id(self, item_id):
+        """
+        Retrieve an inventory item by its ID.
+
+        :param item_id: The ID of the inventory item.
+        :return: The inventory item document or None if not found.
+        """
+        try:
+            return self.collection.find_one({"_id": ObjectId(item_id)})
+        except Exception as e:
+            print(f"Error retrieving inventory item: {e}")
+            return None
+
+    def get_all_inventory_items(self, user_id=None):
+        """
+        Retrieve all inventory items, optionally filtered by user ID.
+
+        :param user_id: Optional. The ID of the user to filter by.
+        :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)}))
+            else:
+                return list(self.collection.find())
+        except Exception as e:
+            print(f"Error retrieving inventory items: {e}")
+            return []
+
+    def delete_inventory_item(self, item_id):
+        """
+        Delete an inventory item by its ID.
+
+        :param item_id: The ID of the inventory item to be deleted.
+        :return: Boolean indicating whether the deletion was successful.
+        """
+        try:
+            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}")
+            return False

services/llama_service.py

@@ -0,0 +1,28 @@
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# Load Llama 3.2 model and tokenizer for text generation
+model_name = "meta-llama/Llama-3.2-1B"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(model_name)
+
+# Set the padding token to EOS token or add a new padding token
+if tokenizer.pad_token is None:
+    tokenizer.add_special_tokens({'pad_token': '[PAD]'})
+    model.resize_token_embeddings(len(tokenizer))
+
+
+def llama2_response(user_input):
+    try:
+        inputs = tokenizer(user_input, return_tensors="pt", truncation=True, max_length=150, padding=True)
+        outputs = model.generate(
+            inputs["input_ids"],
+            max_length=150,
+            do_sample=True,
+            temperature=0.7,
+            pad_token_id=tokenizer.pad_token_id,
+            attention_mask=inputs["attention_mask"]
+        )
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        return response
+    except Exception as e:
+        return f"Error generating response: {str(e)}"

services/report_generator.py

@@ -0,0 +1,145 @@
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+import pandas as pd
+import datetime
+
+# MongoDB Setup (import from your db configuration)
+from config.db import db
+
+# Define collections for report generation
+inventory_collection = db.inventory
+health_collection = db.health_records
+usage_collection = db.user_usage
+
+
+class ReportGenerator:
+    """
+    Report Generator Service for generating reports on inventory, health, and assistant usage data.
+    """
+
+    def __init__(self):
+        self.inventory_collection = inventory_collection
+        self.health_collection = health_collection
+        self.usage_collection = usage_collection
+
+    def generate_inventory_report(self, user_id=None):
+        """
+        Generates a report of all inventory items, optionally filtered by user.
+
+        :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([])
+
+            # Convert the MongoDB documents to a pandas DataFrame
+            df = pd.DataFrame(inventory_items)
+            df = df.drop(columns=['_id', 'user_id'])  # Drop internal fields
+
+            # Add a column for total value (if relevant for future use)
+            # df['total_value'] = df['quantity'] * df['unit_price']
+
+            return df
+        except Exception as e:
+            print(f"Error generating inventory report: {e}")
+            return pd.DataFrame([])
+
+    def generate_health_report(self, user_id=None):
+        """
+        Generates a health report based on logged health records for poultry.
+
+        :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))
+
+            if not health_records:
+                return pd.DataFrame([])
+
+            # Convert the MongoDB documents to a pandas DataFrame
+            df = pd.DataFrame(health_records)
+            df = df.drop(columns=['_id', 'user_id'])
+
+            return df
+        except Exception as e:
+            print(f"Error generating health report: {e}")
+            return pd.DataFrame([])
+
+    def generate_usage_report(self, user_id=None, manager_id=None, interaction_type=None):
+        """
+        Generates a report based on assistant usage data.
+
+        :param user_id: Optional. The ID of the user to filter the report.
+        :param manager_id: Optional. The ID of the manager to filter the report.
+        :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))
+
+            if not usage_records:
+                return pd.DataFrame([])
+
+            # Convert the MongoDB documents to a pandas DataFrame
+            df = pd.DataFrame(usage_records)
+            df = df.drop(columns=['_id', 'user_id', 'manager_id'])
+
+            return df
+        except Exception as e:
+            print(f"Error generating usage report: {e}")
+            return pd.DataFrame([])
+
+    def generate_combined_report(self, user_id=None, manager_id=None):
+        """
+        Generates a combined report containing inventory, health, and usage data.
+
+        :param user_id: Optional. The ID of the user to filter all reports.
+        :param manager_id: Optional. The ID of the manager to filter usage report.
+        :return: A dictionary with three DataFrames for inventory, health, and usage reports.
+        """
+        try:
+            inventory_report = self.generate_inventory_report(user_id)
+            health_report = self.generate_health_report(user_id)
+            usage_report = self.generate_usage_report(user_id=user_id, manager_id=manager_id)
+
+            return {
+                "inventory_report": inventory_report,
+                "health_report": health_report,
+                "usage_report": usage_report
+            }
+        except Exception as e:
+            print(f"Error generating combined report: {e}")
+            return {
+                "inventory_report": pd.DataFrame([]),
+                "health_report": pd.DataFrame([]),
+                "usage_report": pd.DataFrame([])
+            }
+
+    def export_report_to_csv(self, report_df, file_path):
+        """
+        Exports a report (DataFrame) to a CSV file.
+
+        :param report_df: The pandas DataFrame containing the report data.
+        :param file_path: The file path to save the CSV file.
+        :return: Boolean indicating success or failure of the export.
+        """
+        try:
+            report_df.to_csv(file_path, index=False)
+            return True
+        except Exception as e:
+            print(f"Error exporting report to CSV: {e}")
+            return False

services/usage_tracker.py

@@ -0,0 +1,118 @@
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+import datetime
+
+# MongoDB Setup (import from your db configuration)
+from config.db import db
+
+# Define the usage tracking collection
+usage_collection = db.user_usage  # MongoDB collection to store assistant usage logs
+
+
+class UsageTracker:
+    """
+    Usage Tracker Service for logging and retrieving assistant usage.
+    """
+
+    def __init__(self):
+        self.collection = usage_collection
+
+    def log_usage(self, user_id, manager_id, interaction_type, metadata=None):
+        """
+        Logs an interaction with the assistant.
+
+        :param user_id: The ID of the user interacting with the assistant.
+        :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).
+        """
+        try:
+            log_entry = {
+                "user_id": ObjectId(user_id),
+                "manager_id": ObjectId(manager_id),
+                "interaction_type": interaction_type,
+                "metadata": metadata if metadata else {},
+                "timestamp": datetime.datetime.utcnow()
+            }
+            result = self.collection.insert_one(log_entry)
+            return str(result.inserted_id)
+        except Exception as e:
+            print(f"Error logging usage: {e}")
+            return None
+
+    def get_usage_by_user(self, user_id):
+        """
+        Retrieve all assistant usage logs for a specific user.
+
+        :param user_id: The ID of the user.
+        :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)}))
+        except Exception as e:
+            print(f"Error retrieving usage logs for user: {e}")
+            return []
+
+    def get_usage_by_manager(self, manager_id):
+        """
+        Retrieve all assistant usage logs for users managed by a specific manager.
+
+        :param manager_id: The ID of the manager.
+        :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)}))
+        except Exception as e:
+            print(f"Error retrieving usage logs for manager: {e}")
+            return []
+
+    def get_usage_by_interaction_type(self, interaction_type):
+        """
+        Retrieve all assistant usage logs for a specific interaction type.
+
+        :param interaction_type: The type of interaction (e.g., "disease_detection", "inventory_management").
+        :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}))
+        except Exception as e:
+            print(f"Error retrieving usage logs by interaction type: {e}")
+            return []
+
+    def get_usage_logs(self, user_id=None, manager_id=None, interaction_type=None):
+        """
+        Retrieves assistant usage logs, optionally filtered by user, manager, and/or interaction type.
+
+        :param user_id: Optional. Filter by user ID.
+        :param manager_id: Optional. Filter by manager ID.
+        :param interaction_type: Optional. Filter by interaction type.
+        :return: A list of usage logs or an empty list if none are found.
+        """
+        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
+
+            return list(self.collection.find(query))
+        except Exception as e:
+            print(f"Error retrieving usage logs: {e}")
+            return []
+
+    def delete_usage_log(self, log_id):
+        """
+        Deletes a specific usage log by its ID.
+
+        :param log_id: The ID of the usage log to be deleted.
+        :return: Boolean indicating whether the deletion was successful.
+        """
+        try:
+            result = self.collection.delete_one({"_id": ObjectId(log_id)})
+            return result.deleted_count > 0
+        except Exception as e:
+            print(f"Error deleting usage log: {e}")
+            return False

static/assets/css/gpt.css

@@ -0,0 +1,302 @@
+/* Import Google font - Poppins */
+@import url('https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600&display=swap');
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+    font-family: "Poppins", sans-serif;
+}
+
+:root {
+    --text-color: #FFFFFF;
+    --icon-color: #ACACBE;
+    --icon-hover-bg: #5b5e71;
+    --placeholder-color: #dcdcdc;
+    --outgoing-chat-bg: #343541;
+    --incoming-chat-bg: #444654;
+    --outgoing-chat-border: #343541;
+    --incoming-chat-border: #444654;
+}
+
+.light-mode {
+    --text-color: #343541;
+    --icon-color: #a9a9bc;
+    --icon-hover-bg: #f1f1f3;
+    --placeholder-color: #6c6c6c;
+    --outgoing-chat-bg: #FFFFFF;
+    --incoming-chat-bg: #F7F7F8;
+    --outgoing-chat-border: #FFFFFF;
+    --incoming-chat-border: #D9D9E3;
+}
+
+body {
+    background: var(--outgoing-chat-bg);
+}
+
+/* Chats container styling */
+.chat-container {
+    overflow-y: auto;
+    max-height: 100vh;
+    padding-bottom: 150px;
+}
+
+:where(.chat-container, textarea)::-webkit-scrollbar {
+    width: 6px;
+}
+
+:where(.chat-container, textarea)::-webkit-scrollbar-track {
+    background: var(--incoming-chat-bg);
+    border-radius: 25px;
+}
+
+:where(.chat-container, textarea)::-webkit-scrollbar-thumb {
+    background: var(--icon-color);
+    border-radius: 25px;
+}
+
+.default-text {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-direction: column;
+    height: 70vh;
+    padding: 0 10px;
+    text-align: center;
+    color: var(--text-color);
+}
+
+.default-text h1 {
+    font-size: 3.3rem;
+}
+
+.default-text p {
+    margin-top: 10px;
+    font-size: 1.1rem;
+}
+
+.chat-container .chat {
+    padding: 25px 10px;
+    display: flex;
+    justify-content: center;
+    color: var(--text-color);
+}
+
+.chat-container .chat.outgoing {
+    background: var(--outgoing-chat-bg);
+    border: 1px solid var(--outgoing-chat-border);
+}
+
+.chat-container .chat.incoming {
+    background: var(--incoming-chat-bg);
+    border: 1px solid var(--incoming-chat-border);
+}
+
+.chat .chat-content {
+    display: flex;
+    max-width: 1200px;
+    width: 100%;
+    align-items: flex-start;
+    justify-content: space-between;
+}
+
+span.material-symbols-rounded {
+    user-select: none;
+    cursor: pointer;
+}
+
+.chat .chat-content span {
+    cursor: pointer;
+    font-size: 1.3rem;
+    color: var(--icon-color);
+    visibility: hidden;
+}
+
+.chat:hover .chat-content:not(:has(.typing-animation), :has(.error)) span {
+    visibility: visible;
+}
+
+.chat .chat-details {
+    display: flex;
+    align-items: center;
+}
+
+.chat .chat-details img {
+    width: 35px;
+    height: 35px;
+    align-self: flex-start;
+    object-fit: cover;
+    border-radius: 2px;
+}
+
+.chat .chat-details p {
+    white-space: pre-wrap;
+    font-size: 1.05rem;
+    padding: 0 50px 0 25px;
+    color: var(--text-color);
+    word-break: break-word;
+}
+
+.chat .chat-details p.error {
+    color: #e55865;
+}
+
+.chat .typing-animation {
+    padding-left: 25px;
+    display: inline-flex;
+}
+
+.typing-animation .typing-dot {
+    height: 7px;
+    width: 7px;
+    border-radius: 50%;
+    margin: 0 3px;
+    opacity: 0.7;
+    background: var(--text-color);
+    animation: animateDots 1.5s var(--delay) ease-in-out infinite;
+}
+
+.typing-animation .typing-dot:first-child {
+    margin-left: 0;
+}
+
+@keyframes animateDots {
+    0%, 44% {
+        transform: translateY(0px);
+    }
+    28% {
+        opacity: 0.4;
+        transform: translateY(-6px);
+    }
+    44% {
+        opacity: 0.2;
+    }
+}
+
+/* Typing container styling */
+.typing-container {
+    position: fixed;
+    bottom: 0;
+    width: 100%;
+    display: flex;
+    padding: 20px 10px;
+    justify-content: center;
+    background: var(--outgoing-chat-bg);
+    border-top: 1px solid var(--incoming-chat-border);
+}
+
+.typing-container .typing-content {
+    display: flex;
+    max-width: 950px;
+    width: 100%;
+    align-items: flex-end;
+}
+
+.typing-container .typing-textarea {
+    width: 100%;
+    display: flex;
+    position: relative;
+}
+
+.typing-textarea textarea {
+    resize: none;
+    height: 55px;
+    width: 100%;
+    border: none;
+    padding: 15px 45px 15px 20px;
+    color: var(--text-color);
+    font-size: 1rem;
+    border-radius: 4px;
+    max-height: 250px;
+    overflow-y: auto;
+    background: var(--incoming-chat-bg);
+    outline: 1px solid var(--incoming-chat-border);
+}
+
+.typing-textarea textarea::placeholder {
+    color: var(--placeholder-color);
+}
+
+.typing-content span {
+    width: 55px;
+    height: 55px;
+    display: flex;
+    border-radius: 4px;
+    font-size: 1.35rem;
+    align-items: center;
+    justify-content: center;
+    color: var(--icon-color);
+}
+
+.typing-textarea span {
+    position: absolute;
+    right: 0;
+    bottom: 0;
+    visibility: hidden;
+}
+
+.typing-textarea textarea:valid ~ span {
+    visibility: visible;
+}
+
+.typing-controls {
+    display: flex;
+}
+
+.typing-controls span {
+    margin-left: 7px;
+    font-size: 1.4rem;
+    background: var(--incoming-chat-bg);
+    outline: 1px solid var(--incoming-chat-border);
+}
+
+.typing-controls span:hover {
+    background: var(--icon-hover-bg);
+}
+
+/* Reponsive Media Query */
+@media screen and (max-width: 600px) {
+    .default-text h1 {
+        font-size: 2.3rem;
+    }
+
+    :where(.default-text p, textarea, .chat p) {
+        font-size: 0.95rem !important;
+    }
+
+    .chat-container .chat {
+        padding: 20px 10px;
+    }
+
+    .chat-container .chat img {
+        height: 32px;
+        width: 32px;
+    }
+
+    .chat-container .chat p {
+        padding: 0 20px;
+    }
+
+    .chat .chat-content:not(:has(.typing-animation), :has(.error)) span {
+        visibility: visible;
+    }
+
+    .typing-container {
+        padding: 15px 10px;
+    }
+
+    .typing-textarea textarea {
+        height: 45px;
+        padding: 10px 40px 10px 10px;
+    }
+
+    .typing-content span {
+        height: 45px;
+        width: 45px;
+        margin-left: 5px;
+    }
+
+    span.material-symbols-rounded {
+        font-size: 1.25rem !important;
+    }
+}

static/assets/js/gpt.js

@@ -0,0 +1,140 @@
+const chatInput = document.querySelector("#user-input");
+const sendButton = document.querySelector("#send-btn");
+const chatContainer = document.querySelector("#chat-box");
+const themeButton = document.querySelector("#theme-btn");
+const deleteButton = document.querySelector("#delete-btn");
+
+let userText = null;
+
+const loadDataFromLocalstorage = () => {
+    // Load saved chats and theme from local storage and apply/add on the page
+    const themeColor = localStorage.getItem("themeColor");
+
+    document.body.classList.toggle("light-mode", themeColor === "light_mode");
+    themeButton.innerText = document.body.classList.contains("light-mode") ? "dark_mode" : "light_mode";
+
+    const defaultText = `<div class="default-text">
+                            <h1>Poultry Management Assistant</h1>
+                            <p>Start a conversation about poultry management.<br> Your chat history will be displayed here.</p>
+                        </div>`;
+
+    chatContainer.innerHTML = localStorage.getItem("all-chats") || defaultText;
+    chatContainer.scrollTo(0, chatContainer.scrollHeight); // Scroll to bottom of the chat container
+}
+
+const createChatElement = (content, className) => {
+    // Create new div and apply chat, specified class and set html content of div
+    const chatDiv = document.createElement("div");
+    chatDiv.classList.add("chat", className);
+    chatDiv.innerHTML = content;
+    return chatDiv; // Return the created chat div
+}
+
+const getChatResponse = async (incomingChatDiv) => {
+    const API_URL = "/api/chat";
+    const pElement = document.createElement("p");
+
+    // Define the properties and data for the API request
+    const requestOptions = {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            message: userText,
+        })
+    }
+
+    // Send POST request to API, get response and set the response as paragraph element text
+    try {
+        const response = await (await fetch(API_URL, requestOptions)).json();
+        pElement.textContent = response.response.trim();
+    } catch (error) {
+        // Add error class to the paragraph element and set error text
+        pElement.classList.add("error");
+        pElement.textContent = "Oops! Something went wrong while retrieving the response. Please try again.";
+    }
+
+    // Remove the typing animation, append the paragraph element and save the chats to local storage
+    incomingChatDiv.querySelector(".typing-animation").remove();
+    incomingChatDiv.querySelector(".chat-details").appendChild(pElement);
+    localStorage.setItem("all-chats", chatContainer.innerHTML);
+    chatContainer.scrollTo(0, chatContainer.scrollHeight);
+}
+
+const showTypingAnimation = () => {
+    // Display the typing animation and call the getChatResponse function
+    const html = `<div class="chat-content">
+                    <div class="chat-details">
+                        <img src="/static/assets/images/chatbot.jpg" alt="chatbot-img">
+                        <div class="typing-animation">
+                            <div class="typing-dot" style="--delay: 0.2s"></div>
+                            <div class="typing-dot" style="--delay: 0.3s"></div>
+                            <div class="typing-dot" style="--delay: 0.4s"></div>
+                        </div>
+                    </div>
+                    <span onclick="copyResponse(this)" class="material-symbols-rounded">content_copy</span>
+                </div>`;
+    // Create an incoming chat div with typing animation and append it to chat container
+    const incomingChatDiv = createChatElement(html, "incoming");
+    chatContainer.appendChild(incomingChatDiv);
+    chatContainer.scrollTo(0, chatContainer.scrollHeight);
+    getChatResponse(incomingChatDiv);
+}
+
+const handleOutgoingChat = () => {
+    userText = chatInput.value.trim(); // Get chatInput value and remove extra spaces
+    if (!userText) return; // If chatInput is empty return from here
+
+    // Clear the input field and reset its height
+    chatInput.value = "";
+    chatInput.style.height = `${initialInputHeight}px`;
+
+    const html = `<div class="chat-content">
+                    <div class="chat-details">
+                        <img src="/static/assets/images/user.jpg" alt="user-img">
+                        <p>${userText}</p>
+                    </div>
+                </div>`;
+
+    // Create an outgoing chat div with user's message and append it to chat container
+    const outgoingChatDiv = createChatElement(html, "outgoing");
+    chatContainer.querySelector(".default-text")?.remove();
+    chatContainer.appendChild(outgoingChatDiv);
+    chatContainer.scrollTo(0, chatContainer.scrollHeight);
+    setTimeout(showTypingAnimation, 500);
+}
+
+deleteButton.addEventListener("click", () => {
+    // Remove the chats from local storage and call loadDataFromLocalstorage function
+    if (confirm("Are you sure you want to delete all the chats?")) {
+        localStorage.removeItem("all-chats");
+        loadDataFromLocalstorage();
+    }
+});
+
+themeButton.addEventListener("click", () => {
+    // Toggle body's class for the theme mode and save the updated theme to the local storage
+    document.body.classList.toggle("light-mode");
+    localStorage.setItem("themeColor", themeButton.innerText);
+    themeButton.innerText = document.body.classList.contains("light-mode") ? "dark_mode" : "light_mode";
+});
+
+const initialInputHeight = chatInput.scrollHeight;
+
+chatInput.addEventListener("input", () => {
+    // Adjust the height of the input field dynamically based on its content
+    chatInput.style.height = `${initialInputHeight}px`;
+    chatInput.style.height = `${chatInput.scrollHeight}px`;
+});
+
+chatInput.addEventListener("keydown", (e) => {
+    // If the Enter key is pressed without Shift, handle the outgoing chat
+    if (e.key === "Enter" && !e.shiftKey) {
+        e.preventDefault();
+        handleOutgoingChat();
+    }
+});
+
+loadDataFromLocalstorage();
+sendButton.addEventListener("click", handleOutgoingChat);

templates/index.html

@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html dir="ltr" lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta content="width=device-width, initial-scale=1.0" name="viewport">
+    <title>Poultry Management Assistant</title>
+    <!-- Google Fonts Link For Icons -->
+    <link href="https://fonts.googleapis.com/css2?family=Material+Symbols+Rounded:opsz,wght,FILL,[email protected],100..700,0..1,-50..200"
+          rel="stylesheet"/>
+    <link href="/static/assets/css/gpt.css" rel="stylesheet">
+</head>
+<body>
+<!-- Chats container -->
+<div class="chat-container" id="chat-box"></div>
+
+<!-- Typing container -->
+<div class="typing-container">
+    <div class="typing-content">
+        <div class="typing-textarea">
+            <input accept="image/*" id="image-input" style="display: none;" type="file">
+            <textarea id="user-input" placeholder="Enter a prompt here" required spellcheck="false"></textarea>
+            <span class="material-symbols-rounded" id="send-btn">send</span>
+        </div>
+        <div class="typing-controls">
+            <span class="material-symbols-rounded" id="theme-btn">light_mode</span>
+            <span class="material-symbols-rounded" id="delete-btn">delete</span>
+        </div>
+    </div>
+</div>
+
+<script src="/static/assets/js/gpt.js"></script>
+</body>
+</html>