Upload 6 files

app.py

@@ -0,0 +1,412 @@
+import gradio as gr
+import data_manager
+import gemini_client
+import re
+import os
+import pandas as pd  # For displaying data in a table
+import datetime
+
+# --- Functions copied/adapted from chatbot.py ---
+
+def extract_order_id(query):
+    """Attempts to extract an order ID (assumed to be a number) from the query."""
+    match = re.search(r'\b\d+\b', query)
+    if match:
+        return int(match.group(0))
+    return None
+
+def format_prompt(query, order_details=None, order_items=None, recent_orders=None):
+    """Formats the prompt for the Gemini API, including context."""
+    prompt = f"You are an e-commerce customer support assistant. Answer the user's query based *only* on the provided information. If the information is insufficient, say so.\n\nUser Query: \"{query}\"\n\n"
+
+    if order_details:
+        prompt += "--- Order Information ---\n"
+        prompt += f"Order ID: {order_details.get('order_id')}\n"
+        prompt += f"Customer: {order_details.get('user_name')} ({order_details.get('email')})\n"
+        prompt += f"Date: {order_details.get('order_date')}\n"
+        prompt += f"Status: {order_details.get('status')}\n"
+        prompt += f"Total: ${order_details.get('total_amount'):.2f}\n"
+
+    if order_items:
+        prompt += "\n--- Items in Order ---\n"
+        for item in order_items:
+            prompt += f"- {item.get('product_name')} (Qty: {item.get('quantity')}, Price/Unit: ${item.get('price_per_unit'):.2f})\n"
+
+    if recent_orders:
+        prompt += "\n--- Recent Orders ---\n"
+        for order in recent_orders:
+             prompt += f"- Order ID: {order.get('order_id')}, Date: {order.get('order_date')}, Status: {order.get('status')}, Total: ${order.get('total_amount'):.2f}\n"
+
+    prompt += "\n---\nAssistant Response:"
+    return prompt
+
+# --- Data Management Functions ---
+
+def get_product_dataframe():
+    """Fetches all products and returns them as a Pandas DataFrame."""
+    products = data_manager.get_all_products()
+    if products:
+        return pd.DataFrame(products)
+    else:
+        return pd.DataFrame({"message": ["No products found"]})  # Empty DataFrame with a message
+
+def get_user_dataframe():
+    """Fetches all users and returns them as a Pandas DataFrame."""
+    users = data_manager.get_all_users()
+    if users:
+        return pd.DataFrame(users)
+    else:
+        return pd.DataFrame({"message": ["No users found"]})
+
+def get_order_dataframe():
+    """Fetches all orders and returns them as a Pandas DataFrame."""
+    orders = data_manager.get_all_orders()
+    if orders:
+        return pd.DataFrame(orders)
+    else:
+        return pd.DataFrame({"message": ["No orders found"]})
+
+def get_order_item_dataframe():
+    """Fetches all order items and returns them as a Pandas DataFrame."""
+    order_items = data_manager.get_all_order_details()
+    if order_items:
+        return pd.DataFrame(order_items)
+    else:
+        return pd.DataFrame({"message": ["No order items found"]})
+
+def add_product_interface(name, description, price, stock):
+    """Adds a product using the data_manager function and returns a message."""
+    try:
+        price = float(price)
+        stock = int(stock)
+        if not all([name, description, price >= 0, stock >= 0]):
+            return "Error: Please fill all fields correctly. Price and stock must be non-negative.", get_product_dataframe()
+
+        product_id = data_manager.add_product(name, description, price, stock)
+        if product_id:
+            return "Product added successfully. Refreshing data...", get_product_dataframe()
+        else:
+            return "Error: Could not add product.", get_product_dataframe()
+    except ValueError:
+        return "Error: Invalid price or stock value.", get_product_dataframe()
+
+def remove_product_interface(product_id):
+    """Removes a product using the data_manager function and returns a message."""
+    try:
+        product_id = int(product_id)
+        if product_id <= 0:
+            return "Error: Product ID must be a positive integer.", get_product_dataframe()
+        removed = data_manager.remove_product(product_id)
+        if removed:
+            return f"Product with ID {product_id} removed successfully.", get_product_dataframe()
+        else:
+            return f"Error: Could not remove product with ID {product_id} (product not found or in use).", get_product_dataframe()
+    except ValueError:
+        return "Error: Invalid product ID.", get_product_dataframe()
+
+def add_user_interface(name, email, address):
+    """Adds a user using the data_manager function."""
+    user_id = data_manager.add_user(name, email, address)
+    if user_id:
+        return f"User added successfully with ID: {user_id}", get_user_dataframe()
+    else:
+        return "Error: Could not add user.", get_user_dataframe()
+
+def add_order_interface(user_id, order_date, status, total_amount):
+    """Adds an order using the data_manager function."""
+    try:
+        user_id = int(user_id)
+        total_amount = float(total_amount)
+        datetime.datetime.strptime(order_date, '%Y-%m-%d') # Validate date format
+        if status not in ['Pending', 'Processing', 'Shipped', 'Delivered', 'Cancelled']:
+            return "Error: Invalid order status.", get_order_dataframe()
+
+        order_id = data_manager.add_order(user_id, order_date, status, total_amount)
+        if order_id:
+            return f"Order added successfully with ID: {order_id}", get_order_dataframe()
+        else:
+            return "Error: Could not add order.", get_order_dataframe()
+    except ValueError:
+        return "Error: Invalid user ID or total amount.", get_order_dataframe()
+    except ValueError:
+        return "Error: Invalid date format. Use YYYY-MM-DD.", get_order_dataframe()
+
+def add_order_item_interface(order_id, product_id, quantity, price_per_unit):
+    """Adds an order item using the data_manager function."""
+    try:
+        order_id = int(order_id)
+        product_id = int(product_id)
+        quantity = int(quantity)
+        price_per_unit = float(price_per_unit)
+
+        order_item_id = data_manager.add_order_item(order_id, product_id, quantity, price_per_unit)
+        if order_item_id:
+            return f"Order item added successfully with ID: {order_item_id}", get_order_item_dataframe()
+        else:
+            return "Error: Could not add order item.", get_order_item_dataframe()
+    except ValueError:
+        return "Error: Invalid order ID, product ID, quantity, or price per unit.", get_order_item_dataframe()
+
+def remove_user_interface(user_id):
+    """Removes a user using the data_manager function and returns a message."""
+    try:
+        user_id = int(user_id)
+        if user_id <= 0:
+            return "Error: User ID must be a positive integer.", get_user_dataframe()
+        removed = data_manager.remove_user(user_id)
+        if removed:
+            return f"User with ID {user_id} removed successfully.", get_user_dataframe()
+        else:
+            return f"Error: Could not remove user with ID {user_id} (user not found or in use).", get_user_dataframe()
+    except ValueError:
+        return "Error: Invalid user ID.", get_user_dataframe()
+
+def remove_order_interface(order_id):
+    """Removes an order using the data_manager function and returns a message."""
+    try:
+        order_id = int(order_id)
+        if order_id <= 0:
+            return "Error: Order ID must be a positive integer.", get_order_dataframe()
+        removed = data_manager.remove_order(order_id)
+        if removed:
+            return f"Order with ID {order_id} removed successfully.", get_order_dataframe()
+        else:
+            return f"Error: Could not remove order with ID {order_id} (order not found or in use).", get_order_dataframe()
+    except ValueError:
+        return "Error: Invalid order ID.", get_order_dataframe()
+
+def remove_order_item_interface(order_id, product_id):
+    """Removes an order item using the data_manager function and returns a message."""
+    try:
+        order_id = int(order_id)
+        product_id = int(product_id)
+        if order_id <= 0 or product_id <= 0:
+            return "Error: IDs must be positive integers.", get_order_item_dataframe()
+        
+        conn = data_manager.get_db_connection()
+        cursor = conn.cursor()
+        try:
+            cursor.execute("DELETE FROM order_items WHERE order_id = ? AND product_id = ?", 
+                         (order_id, product_id))
+            conn.commit()
+            removed = cursor.rowcount > 0
+            conn.close()
+            
+            if removed:
+                return f"Order item (Order: {order_id}, Product: {product_id}) removed successfully.", get_order_item_dataframe()
+            else:
+                return f"Error: Could not remove order item (Order: {order_id}, Product: {product_id}) - not found.", get_order_item_dataframe()
+        except sqlite3.Error as e:
+            conn.rollback()
+            conn.close()
+            return f"Database error: {e}", get_order_item_dataframe()
+    except ValueError:
+        return "Error: Invalid order ID or product ID.", get_order_item_dataframe()
+
+# --- Chatbot Functions ---
+
+def get_chatbot_response(user_email, query):
+    """Handles the chatbot logic for the Gradio interface."""
+    if not user_email:
+        return "Error: Please enter your email address."
+
+    user_info = data_manager.get_user_by_email(user_email)
+    if not user_info:
+        return f"Error: User with email {user_email} not found."
+
+    user_id = user_info['user_id']
+    order_id = extract_order_id(query)
+    order_details = None
+    order_items = None
+    recent_orders = None
+    response_message = ""
+
+    try:
+        # Determine context based on query and extracted info
+        if order_id:
+            order_details = data_manager.get_order_details(order_id)
+            if order_details:
+                # Security check: Ensure the order belongs to the logged-in user
+                if order_details['email'] != user_email:
+                     response_message = f"Order {order_id} does not belong to user {user_email}."
+                     order_details = None  # Clear details if not authorized
+                else:
+                    # Fetch items only if order details are valid and authorized
+                    order_items = data_manager.get_order_items(order_id)
+            else:
+                response_message = f"Order ID {order_id} not found."
+
+        # Check for recent orders query (simple keyword check)
+        elif "recent orders" in query.lower() or "my orders" in query.lower():
+             recent_orders = data_manager.get_user_recent_orders(user_id)
+             if not recent_orders:
+                 response_message = "You have no recent orders."
+
+        # Construct and send prompt if we have relevant context
+        if order_details or recent_orders:
+            prompt = format_prompt(query, order_details, order_items, recent_orders)
+            # print("\nAssistant thinking...") # No console print in Gradio func
+            response = gemini_client.get_gemini_response(prompt)
+            response_message = response
+        elif order_id and not order_details and not response_message:
+             # Already handled the "not found" or "not authorized" message above
+             pass  # response_message already set
+        elif not response_message:  # If no context found and no error message yet
+             response_message = "Please specify an order ID (e.g., 'status for order 123') or ask about 'recent orders'."
+
+        return response_message
+
+    except FileNotFoundError as e:
+        return f"Error: Database not found at {data_manager.DB_PATH}. Please ensure it exists."
+    except Exception as e:
+        # Log the full error for debugging if needed, but return a user-friendly message
+        print(f"An unexpected error occurred: {e}")  # Log to console where Gradio runs
+        return f"An unexpected error occurred. Please try again later."
+
+# --- Database Check ---
+if not os.path.exists(data_manager.DB_PATH):
+    print(f"Database not found at {data_manager.DB_PATH}.")
+    print("Please run 'python generate_data.py' first to create and populate the database.")
+    # Optionally, exit or prevent Gradio launch
+    # exit() # Uncomment to stop if DB is missing
+
+# --- Gradio Interface ---
+with gr.Blocks(title="E-commerce Management") as iface:
+    gr.Markdown("# E-commerce Chatbot and Data Management")
+
+    with gr.Tab("Chatbot"):
+        email_input = gr.Textbox(label="Your Email Address")
+        query_input = gr.Textbox(label="Your Query", placeholder="e.g., 'What is the status of order 1?' or 'Show my recent orders'")
+        chatbot_output = gr.Textbox(label="Assistant Response")
+        chatbot_button = gr.Button("Submit")
+
+        chatbot_button.click(
+            fn=get_chatbot_response,
+            inputs=[email_input, query_input],
+            outputs=chatbot_output
+        )
+
+    with gr.Tab("Data Management"):
+        with gr.Tabs():
+            with gr.Tab("Products"):
+                gr.Markdown("## Product Data")
+                product_table = gr.DataFrame(get_product_dataframe(), interactive=False, label="Current Products")
+
+                with gr.Accordion("Add New Product", open=False):
+                    new_name_input = gr.Textbox(label="Product Name")
+                    new_description_input = gr.Textbox(label="Description")
+                    new_price_input = gr.Number(label="Price")
+                    new_stock_input = gr.Number(label="Stock")
+                    add_product_button = gr.Button("Add Product")
+                    add_product_output = gr.Textbox()
+
+                    add_product_button.click(
+                        fn=add_product_interface,
+                        inputs=[new_name_input, new_description_input, new_price_input, new_stock_input],
+                        outputs=[add_product_output, product_table]
+                    )
+
+                with gr.Accordion("Remove Product", open=False):
+                    remove_id_input = gr.Number(label="Product ID to Remove")
+                    remove_product_button = gr.Button("Remove Product")
+                    remove_product_output = gr.Textbox()
+
+                    remove_product_button.click(
+                        fn=remove_product_interface,
+                        inputs=[remove_id_input],
+                        outputs=[remove_product_output, product_table]
+                    )
+
+            with gr.Tab("Users"):
+                gr.Markdown("## User Data")
+                user_table = gr.DataFrame(get_user_dataframe(), interactive=False, label="Current Users")
+
+                with gr.Accordion("Add User", open=False):
+                    new_user_name_input = gr.Textbox(label="User Name")
+                    new_user_email_input = gr.Textbox(label="Email")
+                    new_user_address_input = gr.Textbox(label="Address")
+                    add_user_button = gr.Button("Add User")
+                    add_user_output = gr.Textbox()
+
+                    add_user_button.click(
+                        fn=add_user_interface,
+                        inputs=[new_user_name_input, new_user_email_input, new_user_address_input],
+                        outputs=[add_user_output, user_table]
+                    )
+
+                with gr.Accordion("Remove User", open=False):
+                    remove_user_id_input = gr.Number(label="User ID to Remove")
+                    remove_user_button = gr.Button("Remove User")
+                    remove_user_output = gr.Textbox()
+
+                    remove_user_button.click(
+                        fn=remove_user_interface,
+                        inputs=[remove_user_id_input],
+                        outputs=[remove_user_output, user_table]
+                    )
+
+            with gr.Tab("Orders"):
+                gr.Markdown("## Order Data")
+                order_table = gr.DataFrame(get_order_dataframe(), interactive=False, label="Current Orders")
+
+                with gr.Accordion("Add Order", open=False):
+                    new_order_user_id_input = gr.Number(label="User ID")
+                    new_order_date_input = gr.Textbox(label="Order Date (YYYY-MM-DD)")
+                    new_order_status_input = gr.Dropdown(label="Status", choices=['Pending', 'Processing', 'Shipped', 'Delivered', 'Cancelled'])
+                    new_order_total_amount_input = gr.Number(label="Total Amount")
+                    add_order_button = gr.Button("Add Order")
+                    add_order_output = gr.Textbox()
+
+                    add_order_button.click(
+                        fn=add_order_interface,
+                        inputs=[new_order_user_id_input, new_order_date_input, new_order_status_input, new_order_total_amount_input],
+                        outputs=[add_order_output, order_table]
+                    )
+
+                with gr.Accordion("Remove Order", open=False):
+                    remove_order_id_input = gr.Number(label="Order ID to Remove")
+                    remove_order_button = gr.Button("Remove Order")
+                    remove_order_output = gr.Textbox()
+
+                    remove_order_button.click(
+                        fn=remove_order_interface,
+                        inputs=[remove_order_id_input],
+                        outputs=[remove_order_output, order_table]
+                    )
+
+            with gr.Tab("Order Items"):
+                gr.Markdown("## Order Item Data")
+                order_item_table = gr.DataFrame(get_order_item_dataframe(), interactive=False, label="Current Order Items")
+
+                with gr.Accordion("Add Order Item", open=False):
+                    new_order_item_order_id_input = gr.Number(label="Order ID")
+                    new_order_item_product_id_input = gr.Number(label="Product ID")
+                    new_order_item_quantity_input = gr.Number(label="Quantity")
+                    new_order_item_price_per_unit_input = gr.Number(label="Price per Unit")
+                    add_order_item_button = gr.Button("Add Order Item")
+                    add_order_item_output = gr.Textbox()
+
+                    add_order_item_button.click(
+                        fn=add_order_item_interface,
+                        inputs=[new_order_item_order_id_input, new_order_item_product_id_input, new_order_item_quantity_input, new_order_item_price_per_unit_input],
+                        outputs=[add_order_item_output, order_item_table]
+                    )
+
+                with gr.Accordion("Remove Order Item", open=False):
+                    remove_order_id_input = gr.Number(label="Order ID")
+                    remove_product_id_input = gr.Number(label="Product ID")
+                    remove_order_item_button = gr.Button("Remove Order Item")
+                    remove_order_item_output = gr.Textbox()
+
+                    remove_order_item_button.click(
+                        fn=remove_order_item_interface,
+                        inputs=[remove_order_id_input, remove_product_id_input],
+                        outputs=[remove_order_item_output, order_item_table]
+                    )
+
+if __name__ == "__main__":
+    if os.path.exists(data_manager.DB_PATH):
+        print("Launching Gradio interface...")
+        iface.launch(share=True)
+    else:
+        print("Gradio interface not launched because the database is missing.")

chatbot.py

@@ -0,0 +1,120 @@
+import data_manager
+import gemini_client
+import re
+import os
+def extract_order_id(query):
+    """Attempts to extract an order ID (assumed to be a number) from the query."""
+    match = re.search(r'\b\d+\b', query)
+    if match:
+        return int(match.group(0))
+    return None
+
+def format_prompt(query, order_details=None, order_items=None, recent_orders=None):
+    """Formats the prompt for the Gemini API, including context."""
+    prompt = f"You are an e-commerce customer support assistant. Answer the user's query based *only* on the provided information. If the information is insufficient, say so.\n\nUser Query: \"{query}\"\n\n"
+
+    if order_details:
+        prompt += "--- Order Information ---\n"
+        prompt += f"Order ID: {order_details.get('order_id')}\n"
+        prompt += f"Customer: {order_details.get('user_name')} ({order_details.get('email')})\n"
+        prompt += f"Date: {order_details.get('order_date')}\n"
+        prompt += f"Status: {order_details.get('status')}\n"
+        prompt += f"Total: ${order_details.get('total_amount'):.2f}\n"
+
+    if order_items:
+        prompt += "\n--- Items in Order ---\n"
+        for item in order_items:
+            prompt += f"- {item.get('product_name')} (Qty: {item.get('quantity')}, Price/Unit: ${item.get('price_per_unit'):.2f})\n"
+
+    if recent_orders:
+        prompt += "\n--- Recent Orders ---\n"
+        for order in recent_orders:
+             prompt += f"- Order ID: {order.get('order_id')}, Date: {order.get('order_date')}, Status: {order.get('status')}, Total: ${order.get('total_amount'):.2f}\n"
+
+    prompt += "\n---\nAssistant Response:"
+    return prompt
+
+def main():
+    """Main loop for the chatbot interaction."""
+    print("Welcome to the E-commerce Chat Assistant!")
+    print("You can ask about order status, items, or recent orders.")
+    print("Example: 'What is the status of order 1?' or 'Show my recent orders for alice@example.com'")
+    print("Type 'quit' to exit.")
+
+    # Basic way to identify user - could be improved with login simulation
+    user_email = input("Please enter your email address to start: ")
+    user_info = data_manager.get_user_by_email(user_email)
+    if not user_info:
+        print(f"User with email {user_email} not found. Exiting.")
+        return
+    print(f"Welcome, {user_info['name']}!")
+    user_id = user_info['user_id']
+
+
+    while True:
+        query = input("\nYour query: ")
+        if query.lower() == 'quit':
+            break
+
+        order_id = extract_order_id(query)
+        order_details = None
+        order_items = None
+        recent_orders = None
+
+        try:
+            # Determine context based on query and extracted info
+            if order_id:
+                order_details = data_manager.get_order_details(order_id)
+                if order_details:
+                    # Security check: Ensure the order belongs to the logged-in user
+                    if order_details['email'] != user_email:
+                         print(f"Order {order_id} does not belong to user {user_email}.")
+                         order_details = None # Clear details if not authorized
+                    else:
+                        # Fetch items only if order details are valid and authorized
+                        order_items = data_manager.get_order_items(order_id)
+                else:
+                    print(f"Order ID {order_id} not found.")
+
+            # Check for recent orders query (simple keyword check)
+            elif "recent orders" in query.lower() or "my orders" in query.lower():
+                 recent_orders = data_manager.get_user_recent_orders(user_id)
+                 if not recent_orders:
+                     print("You have no recent orders.")
+
+
+            # Construct and send prompt if we have relevant context
+            if order_details or recent_orders:
+                prompt = format_prompt(query, order_details, order_items, recent_orders)
+                print("\nAssistant thinking...")
+                response = gemini_client.get_gemini_response(prompt)
+                print(f"\nAssistant: {response}")
+            elif order_id and not order_details:
+                 # Already handled the "not found" or "not authorized" message
+                 pass
+            else:
+                # If no specific context found, try sending the query directly (less reliable)
+                # Or inform the user context is needed
+                # print("Could not determine specific order information. Trying a general query...")
+                # prompt = format_prompt(query) # Send without specific context
+                # response = gemini_client.get_gemini_response(prompt)
+                # print(f"\nAssistant: {response}")
+                 print("Please specify an order ID or ask about 'recent orders'.")
+
+
+        except FileNotFoundError as e:
+            print(f"Error: {e}. Please ensure the database exists.")
+            break
+        except Exception as e:
+            print(f"An unexpected error occurred: {e}")
+
+    print("Goodbye!")
+
+if __name__ == "__main__":
+    # Optional: Run data generation if DB doesn't exist?
+    # For simplicity, we assume generate_data.py is run manually first.
+    if not os.path.exists(data_manager.DB_PATH):
+         print(f"Database not found at {data_manager.DB_PATH}.")
+         print("Please run 'python generate_data.py' first to create and populate the database.")
+    else:
+        main()

data_manager.py

@@ -0,0 +1,335 @@
+import sqlite3
+import os
+
+# Define the path for the database
+DB_DIR = "data"
+DB_PATH = os.path.join(DB_DIR, "ecommerce_data.db")
+
+def get_db_connection():
+    """Establishes a connection to the SQLite database."""
+    if not os.path.exists(DB_PATH):
+        raise FileNotFoundError(f"Database file not found at {DB_PATH}. Run generate_data.py first.")
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row # Return rows as dictionary-like objects
+    return conn
+
+def get_order_details(order_id):
+    """Fetches details for a specific order."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("""
+        SELECT o.order_id, o.order_date, o.status, o.total_amount, u.name as user_name, u.email
+        FROM orders o
+        JOIN users u ON o.user_id = u.user_id
+        WHERE o.order_id = ?
+    """, (order_id,))
+    order = cursor.fetchone()
+    conn.close()
+    return dict(order) if order else None
+
+def get_order_items(order_id):
+    """Fetches all items associated with a specific order."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("""
+        SELECT p.name as product_name, oi.quantity, oi.price_per_unit
+        FROM order_items oi
+        JOIN products p ON oi.product_id = p.product_id
+        WHERE oi.order_id = ?
+    """, (order_id,))
+    items = cursor.fetchall()
+    conn.close()
+    return [dict(item) for item in items]
+
+def get_user_recent_orders(user_id, limit=5):
+    """Fetches the most recent orders for a specific user."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("""
+        SELECT order_id, order_date, status, total_amount
+        FROM orders
+        WHERE user_id = ?
+        ORDER BY order_date DESC
+        LIMIT ?
+    """, (user_id, limit))
+    orders = cursor.fetchall()
+    conn.close()
+    return [dict(order) for order in orders]
+
+def remove_order_details(order_id):
+    """Removes order details from the database for a given order_id."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute("DELETE FROM order_items WHERE order_id = ?", (order_id,))
+        conn.commit()
+        conn.close()
+        return True
+    except sqlite3.Error as e:
+        conn.rollback()
+        conn.close()
+        print(f"Database error removing order details: {e}")
+        return False
+
+def remove_order(order_id):
+    """Removes an order from the database."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute("DELETE FROM orders WHERE order_id = ?", (order_id,))
+        conn.commit()
+        conn.close()
+        return True
+    except sqlite3.Error as e:
+        conn.rollback()
+        conn.close()
+        print(f"Database error removing order: {e}")
+        return False
+
+def remove_user(user_id):
+    """Removes a user from the database."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute("DELETE FROM users WHERE user_id = ?", (user_id,))
+        conn.commit()
+        conn.close()
+        return True
+    except sqlite3.Error as e:
+        conn.rollback()
+        conn.close()
+        print(f"Database error removing user: {e}")
+        return False
+
+
+def add_product(name, description, price, stock):
+    """Adds a new product to the database."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute("""
+            INSERT INTO products (name, description, price, stock)
+            VALUES (?, ?, ?, ?)
+        """, (name, description, price, stock))
+        conn.commit()
+        product_id = cursor.lastrowid
+        conn.close()
+        return product_id # Return the ID of the newly added product
+    except sqlite3.Error as e:
+        conn.rollback() # Roll back changes if error occurs
+        conn.close()
+        print(f"Database error adding product: {e}")
+        return None # Indicate failure
+
+def add_user(name, email, address):
+    """Adds a new user to the database."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute("""
+            INSERT INTO users (name, email, address)
+            VALUES (?, ?, ?)
+        """, (name, email, address))
+        conn.commit()
+        user_id = cursor.lastrowid
+        conn.close()
+        return user_id
+    except sqlite3.Error as e:
+        conn.rollback()
+        conn.close()
+        print(f"Database error adding user: {e}")
+        return None
+
+def add_order(user_id, order_date, status, total_amount):
+     """Adds a new order to the database."""
+     conn = get_db_connection()
+     cursor = conn.cursor()
+     try:
+          cursor.execute("""
+               INSERT INTO orders (user_id, order_date, status, total_amount)
+               VALUES (?, ?, ?, ?)
+          """, (user_id, order_date, status, total_amount))
+          conn.commit()
+          order_id = cursor.lastrowid
+          conn.close()
+          return order_id
+     except sqlite3.Error as e:
+          conn.rollback()
+          conn.close()
+          print(f"Database error adding order: {e}")
+          return None
+
+def add_order_item(order_id, product_id, quantity, price_per_unit):
+     """Adds a new order item to the database."""
+     conn = get_db_connection()
+     cursor = conn.cursor()
+     try:
+          cursor.execute("""
+               INSERT INTO order_items (order_id, product_id, quantity, price_per_unit)
+               VALUES (?, ?, ?, ?)
+          """, (order_id, product_id, quantity, price_per_unit))
+          conn.commit()
+          order_item_id = cursor.lastrowid
+          conn.close()
+          return order_item_id
+     except sqlite3.Error as e:
+          conn.rollback()
+          conn.close()
+          print(f"Database error adding order item: {e}")
+          return None
+
+
+def get_all_order_details():
+    """Fetches all order details from the database."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("SELECT order_id, product_id, quantity, price_per_unit FROM order_items ORDER BY order_id")
+    order_details = cursor.fetchall()
+    conn.close()
+    return [dict(order_detail) for order_detail in order_details]
+
+def get_user_by_email(email):
+    """Fetches user details by email address."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("SELECT user_id, name, email, address FROM users WHERE email = ?", (email,))
+    user = cursor.fetchone()
+    conn.close()
+    return dict(user) if user else None
+
+def get_all_products():
+    """Fetches all products from the database."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("SELECT product_id, name, description, price, stock FROM products ORDER BY product_id")
+    products = cursor.fetchall()
+    conn.close()
+    return [dict(product) for product in products]
+
+# Example usage (optional, for testing)
+if __name__ == "__main__":
+    print("Testing Data Manager...")
+    # Ensure data exists first by running generate_data.py if needed
+    if not os.path.exists(DB_PATH):
+        print("Database not found. Please run generate_data.py first.")
+    else:
+        test_order_id = 1
+        print(f"\n--- Order Details (ID: {test_order_id}) ---")
+        details = get_order_details(test_order_id)
+        if details:
+            print(details)
+            print(f"\n--- Items for Order ID: {test_order_id} ---")
+            items = get_order_items(test_order_id)
+            for item in items:
+                print(item)
+        else:
+            print(f"Order {test_order_id} not found.")
+
+        test_user_id = 1
+        print(f"\n--- Recent Orders for User ID: {test_user_id}) ---")
+        recent_orders = get_user_recent_orders(test_user_id)
+        if recent_orders:
+            for order in recent_orders:
+                print(order)
+        else:
+             print(f"No orders found for user {test_user_id}.")
+
+        test_email = 'alice@example.com'
+        print(f"\n--- User details for Email: {test_email} ---")
+        user = get_user_by_email(test_email)
+        if user:
+            print(user)
+        else:
+            print(f"User with email {test_email} not found.")
+
+        print("\n--- All Products ---")
+        all_products = get_all_products()
+        if all_products:
+            for prod in all_products[:5]: # Print first 5
+                print(prod)
+        else:
+            print("No products found.")
+
+        # Example Add/Remove (Use with caution on real data)
+        # print("\n--- Adding Test Product ---")
+        # new_id = add_product("Test Widget", "A temporary test product", 99.99, 50)
+        # if new_id:
+        #     print(f"Added product with ID: {new_id}")
+        #     print("\n--- Removing Test Product ---")
+        #     removed = remove_product(new_id)
+        #     print(f"Removal successful: {removed}")
+        # else:
+        #     print("Failed to add test product.")
+
+
+def get_all_order_details():
+    """Fetches all order details from the database."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("SELECT order_id, product_id, quantity, price_per_unit FROM order_items ORDER BY order_id")
+    order_details = cursor.fetchall()
+    conn.close()
+    return [dict(order_detail) for order_detail in order_details]
+
+def remove_user(user_id):
+    """Removes a user from the database."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute("DELETE FROM users WHERE user_id = ?", (user_id,))
+        conn.commit()
+        conn.close()
+        return True
+    except sqlite3.Error as e:
+        conn.rollback()
+        conn.close()
+        print(f"Database error removing user: {e}")
+        return False
+
+def remove_order(order_id):
+    """Removes an order from the database."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute("DELETE FROM orders WHERE order_id = ?", (order_id,))
+        conn.commit()
+        conn.close()
+        return True
+    except sqlite3.Error as e:
+        conn.rollback()
+        conn.close()
+        print(f"Database error removing order: {e}")
+        return False
+
+def remove_order_details(order_id):
+    """Removes order details from the database for a given order_id."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute("DELETE FROM order_items WHERE order_id = ?", (order_id,))
+        conn.commit()
+        conn.close()
+        return True
+    except sqlite3.Error as e:
+        conn.rollback()
+        conn.close()
+        print(f"Database error removing order details: {e}")
+        return False
+
+def get_all_users():
+    """Fetches all users from the database."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("SELECT user_id, name, email, address FROM users ORDER BY user_id")
+    users = cursor.fetchall()
+    conn.close()
+    return [dict(user) for user in users]
+
+def get_all_orders():
+    """Fetches all orders from the database."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("SELECT order_id, user_id, order_date, status, total_amount FROM orders ORDER BY order_id")
+    orders = cursor.fetchall()
+    conn.close()
+    return [dict(order) for order in orders]

gemini_client.py

@@ -0,0 +1,57 @@
+import os
+import google.generativeai as genai
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Configure the Gemini API
+api_key = os.getenv("GEMINI_API_KEY")
+if not api_key:
+    raise ValueError("GEMINI_API_KEY not found in .env file or environment variables.")
+
+genai.configure(api_key=api_key)
+
+# Initialize the generative model
+# Using gemini-1.0-pro, check documentation for other available models
+model = genai.GenerativeModel('gemini-2.0-flash')
+
+def get_gemini_response(prompt):
+    """
+    Sends a prompt to the Gemini API and returns the generated text response.
+
+    Args:
+        prompt (str): The complete prompt including context and user query.
+
+    Returns:
+        str: The text response from the Gemini model, or an error message.
+    """
+    try:
+        response = model.generate_content(prompt)
+        # Accessing the text part of the response
+        # Handle potential cases where response might not have 'text' directly
+        if response.parts:
+             # Assuming the first part contains the text response
+             # Adjust if the API response structure differs or has multiple parts
+            return response.parts[0].text
+        elif hasattr(response, 'text'):
+             # Fallback if 'text' attribute exists directly (older versions/different models)
+             return response.text
+        else:
+             # If no text found, return the raw response or an error indicator
+             # Log the full response for debugging if necessary
+             print(f"Unexpected Gemini response structure: {response}")
+             return "Error: Could not extract text from Gemini response."
+
+    except Exception as e:
+        print(f"An error occurred while calling the Gemini API: {e}")
+        # Consider more specific error handling based on potential API errors
+        return f"Error communicating with AI assistant: {e}"
+
+# Example usage (optional, for testing)
+if __name__ == "__main__":
+    print("Testing Gemini Client...")
+    test_prompt = "Explain what an e-commerce order status 'Shipped' means in simple terms."
+    print(f"\nSending prompt: {test_prompt}")
+    response_text = get_gemini_response(test_prompt)
+    print(f"\nGemini Response:\n{response_text}")

generate_data.py

@@ -0,0 +1,145 @@
+import sqlite3
+import os
+import datetime
+import random
+
+# Define the path for the database
+DB_DIR = "data"
+DB_PATH = os.path.join(DB_DIR, "ecommerce_data.db")
+
+def create_database():
+    """Creates the SQLite database and tables if they don't exist."""
+    # Ensure the data directory exists
+    os.makedirs(DB_DIR, exist_ok=True)
+
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+
+    # Create users table
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS users (
+        user_id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        email TEXT UNIQUE NOT NULL,
+        address TEXT
+    );
+    """)
+
+    # Create products table
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS products (
+        product_id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        description TEXT,
+        price REAL NOT NULL CHECK(price > 0),
+        stock INTEGER NOT NULL DEFAULT 0 CHECK(stock >= 0)
+    );
+    """)
+
+    # Create orders table
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS orders (
+        order_id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id INTEGER NOT NULL,
+        order_date TEXT NOT NULL,
+        status TEXT NOT NULL CHECK(status IN ('Pending', 'Processing', 'Shipped', 'Delivered', 'Cancelled')),
+        total_amount REAL NOT NULL CHECK(total_amount >= 0),
+        FOREIGN KEY (user_id) REFERENCES users(user_id)
+    );
+    """)
+
+    # Create order_items table (linking orders and products)
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS order_items (
+        order_item_id INTEGER PRIMARY KEY AUTOINCREMENT,
+        order_id INTEGER NOT NULL,
+        product_id INTEGER NOT NULL,
+        quantity INTEGER NOT NULL CHECK(quantity > 0),
+        price_per_unit REAL NOT NULL CHECK(price_per_unit > 0),
+        FOREIGN KEY (order_id) REFERENCES orders(order_id),
+        FOREIGN KEY (product_id) REFERENCES products(product_id)
+    );
+    """)
+
+    conn.commit()
+    conn.close()
+    print(f"Database created/verified at {DB_PATH}")
+
+def populate_data():
+    """Populates the database with sample data if tables are empty."""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+
+    try:
+        # Check if tables are already populated
+        cursor.execute("SELECT COUNT(*) FROM users")
+        if cursor.fetchone()[0] > 0:
+            print("Database already contains data. Skipping population.")
+            return
+
+        # Sample Users
+        users_data = [
+            ('Alice Wonderland', 'alice@example.com', '123 Fantasy Lane'),
+            ('Bob The Builder', 'bob@example.com', '456 Construction Ave'),
+            ('Charlie Chaplin', 'charlie@example.com', '789 Silent Film St')
+        ]
+        cursor.executemany("INSERT INTO users (name, email, address) VALUES (?, ?, ?)", users_data)
+        print(f"Inserted {len(users_data)} users.")
+
+        # Sample Products
+        products_data = [
+            ('Laptop Pro', 'High-end laptop for professionals', 1200.00, 100),
+            ('Wireless Mouse', 'Ergonomic wireless mouse', 25.50, 500),
+            ('Mechanical Keyboard', 'RGB Mechanical Keyboard', 75.00, 200),
+            ('USB-C Hub', '7-in-1 USB-C Hub', 40.00, 300),
+            ('Monitor 27"', '27 inch 4K Monitor', 300.00, 150)
+        ]
+        cursor.executemany("INSERT INTO products (name, description, price, stock) VALUES (?, ?, ?, ?)", products_data)
+        print(f"Inserted {len(products_data)} products.")
+
+        # Sample Orders and Order Items
+        order_statuses = ['Pending', 'Processing', 'Shipped', 'Delivered', 'Cancelled']
+        user_ids = [row[0] for row in cursor.execute("SELECT user_id FROM users").fetchall()]
+        product_info = {row[0]: row[1] for row in cursor.execute("SELECT product_id, price FROM products").fetchall()}
+        product_ids = list(product_info.keys())
+
+        for i in range(5): # Create 5 sample orders
+            user_id = random.choice(user_ids)
+            order_date = (datetime.datetime.now() - datetime.timedelta(days=random.randint(1, 30))).strftime('%Y-%m-%d %H:%M:%S')
+            status = random.choice(order_statuses)
+            
+            # Insert order first with a placeholder total
+            cursor.execute("INSERT INTO orders (user_id, order_date, status, total_amount) VALUES (?, ?, ?, ?)",
+                           (user_id, order_date, status, 0.0))
+            order_id = cursor.lastrowid
+            
+            order_total = 0.0
+            num_items = random.randint(1, 3)
+            items_in_order = random.sample(product_ids, num_items)
+
+            order_items_data = []
+            for product_id in items_in_order:
+                quantity = random.randint(1, 2)
+                price_per_unit = product_info[product_id]
+                order_items_data.append((order_id, product_id, quantity, price_per_unit))
+                order_total += quantity * price_per_unit
+            
+            cursor.executemany("INSERT INTO order_items (order_id, product_id, quantity, price_per_unit) VALUES (?, ?, ?, ?)", order_items_data)
+            
+            # Update order total
+            cursor.execute("UPDATE orders SET total_amount = ? WHERE order_id = ?", (round(order_total, 2), order_id))
+
+        print(f"Inserted 5 sample orders with items.")
+
+        conn.commit()
+
+    except sqlite3.Error as e:
+        print(f"An error occurred: {e}")
+        conn.rollback()
+    finally:
+        conn.close()
+
+if __name__ == "__main__":
+    create_database()
+    populate_data()
+    print("Data generation complete.")

requirements.txt

@@ -0,0 +1,3 @@
+google-generativeai
+python-dotenv
+gradio