Added dummy sqlite DB

.dummyenv

@@ -0,0 +1,2 @@
+# ERP Postgres DB
+ERP_DB_TYPE = "sqlite" # Options: "postgres" or "sqlite"

README.md

@@ -48,6 +48,7 @@ This backend is designed to be consumed by autonomous agents for real-world task
 | `place_order`            | Places a new order                               |
 | `cancel_order`           | Cancels an existing order                        |
 | `get_invoice_details`    | Returns invoice details for an order             |
+| `reset_database`         | Resets the SQLite Database                       |
 | `get_active_disruptions` | Returns geopolitical disruptions between nations |
 
 ---

app.py

@@ -1,186 +1,257 @@
-import gradio as gr
-import psycopg2
-from psycopg2.extras import RealDictCursor
+# erp_server.py
 import os
-from dotenv import load_dotenv
+import sys
+from typing import TypedDict, List, Union
+
+# Add the project root directory to the Python path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
+
+import gradio as gr
 from typing import Dict, Any, List, Optional
+from dotenv import load_dotenv
+from datetime import datetime, date
+import pathlib
+
+# Import both database libraries
+import sqlite3
+try:
+    import psycopg2
+    from psycopg2.extras import RealDictCursor
+    POSTGRES_AVAILABLE = True
+except ImportError:
+    POSTGRES_AVAILABLE = False
+
+# Import SQLite initialization and reset functions
+from data.utils.erp_db_init import init_sqlite_db
+from data.utils.reset_erp_db import reset_erp_db
+
+from mcp.server.fastmcp import FastMCP
 
 load_dotenv()
 
+mcp = FastMCP("ERP Database")
+
+# Helper function to convert SQLite row to dict
+def dict_factory(cursor, row):
+    d = {}
+    for idx, col in enumerate(cursor.description):
+        d[col[0]] = row[idx]
+    return d
+
+# Helper function to handle date serialization for JSON
+def serialize_dates(obj):
+    if isinstance(obj, (date, datetime)):
+        return obj.isoformat()
+    return obj
+
 def get_db_connection():
-    """Get database connection using environment variables."""
-    try:
-        conn = psycopg2.connect(
-            host=os.getenv("POSTGRES_HOST", "localhost"),
-            database=os.getenv("POSTGRES_DB", "erp_db"),
-            user=os.getenv("POSTGRES_USER", "postgres"),
-            password=os.getenv("POSTGRES_PASSWORD", ""),
-            port=os.getenv("POSTGRES_PORT", "5432")
-        )
-        return conn
-    except Exception as e:
-        raise Exception(f"Database connection failed: {str(e)}")
+    """Get database connection based on configuration."""
+    # Default to SQLite unless explicitly set to use PostgreSQL
+    db_type = os.getenv("ERP_DB_TYPE", "sqlite").lower()
+    
+    if db_type == "postgres" and POSTGRES_AVAILABLE:
+        try:
+            conn = psycopg2.connect(
+                host=os.getenv("POSTGRES_HOST", "localhost"),
+                database=os.getenv("POSTGRES_DB", "erp_db"),
+                user=os.getenv("POSTGRES_USER", "postgres"),
+                password=os.getenv("POSTGRES_PASSWORD", ""),
+                port=os.getenv("POSTGRES_PORT", "5432")
+            )
+            return conn, "postgres"
+        except Exception as e:
+            raise Exception(f"PostgreSQL connection failed: {str(e)}")
+    else:
+        try:
+            # Get SQLite database path from environment or use default
+            db_path = os.getenv("SQLITE_DB_PATH", "./data/erp_db.sqlite")
+            
+            # Ensure database is initialized
+            db_dir = pathlib.Path(os.path.dirname(db_path))
+            if not db_dir.exists() or not pathlib.Path(db_path).exists():
+                init_sqlite_db(db_path)
+            
+            conn = sqlite3.connect(db_path)
+            conn.row_factory = dict_factory
+            
+            # Enable foreign keys
+            conn.execute("PRAGMA foreign_keys = ON")
+            
+            return conn, "sqlite"
+        except Exception as e:
+            raise Exception(f"SQLite connection failed: {str(e)}")
 
-def execute_query(query: str, params: str = None):
+@mcp.tool()
+async def execute_query(query: str, params: Optional[List] = None) -> Dict[str, Any]:
     """
     Execute a custom SQL query on the ERP database.
+    Only SELECT statements are allowed for security reasons.
     
     Args:
-        query: SQL query to execute
-        params: Parameters for parameterized queries (as a comma-separated string)
+        query (str): SQL query to execute (must be a SELECT statement)
+        params (List, optional): Parameters for parameterized queries
     
     Returns:
-        Query results or error message
+        dict: Query results or error message
     """
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
+        # Check if it's a SELECT query
+        if not query.strip().upper().startswith('SELECT'):
+            return {
+                "success": False,
+                "error": "Only SELECT statements are allowed for security reasons."
+            }
+            
+        conn, db_type = get_db_connection()
         
-        # Convert string params to list if provided
-        param_list = None
-        if params and params.strip():
-            param_list = [p.strip() for p in params.split(',')]
+        if db_type == "postgres":
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+        else:  # sqlite
+            cursor = conn.cursor()
         
-        if param_list:
-            cursor.execute(query, param_list)
+        if params:
+            cursor.execute(query, params)
         else:
             cursor.execute(query)
         
-        # Check if it's a SELECT query
-        if query.strip().upper().startswith('SELECT'):
-            results = cursor.fetchall()
-            # Convert RealDictRow to regular dict for JSON serialization
+        results = cursor.fetchall()
+        # Convert results to regular dict for JSON serialization
+        if db_type == "postgres":
             results = [dict(row) for row in results]
-            if not results:
-                return str({
-                    "success": True,
-                    "message": "No results found",
-                    "results": []
-                })
-            return str({
-                "success": True,
-                "message": f"Query returned {len(results)} results",
-                "count": len(results),
-                "results": results
-            })
-        else:
-            # For INSERT, UPDATE, DELETE queries
-            conn.commit()
-            return str({
-                "success": True,
-                "message": f"Query executed successfully",
-                "rows_affected": cursor.rowcount
-            })
+        if not results:
+            return "No results found"
+        return results
             
     except Exception as e:
-        return str({
+        return {
             "success": False,
             "error": str(e)
-        })
+        }
     finally:
         if 'conn' in locals():
             conn.close()
 
-def list_erp_tables():
+@mcp.tool()
+async def list_erp_tables() -> Dict[str, Any]:
     """
     List all ERP tables in the database.
     
     Returns:
-        List of ERP table names
-    """
-    query = """
-    SELECT table_name 
-    FROM information_schema.tables 
-    WHERE table_schema = 'public'
-    AND table_name LIKE 'erp_%'
-    ORDER BY table_name;
+        dict: List of ERP table names
     """
-    
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
-        cursor.execute(query)
-        results = cursor.fetchall()
+        conn, db_type = get_db_connection()
+        
+        if db_type == "postgres":
+            query = """
+            SELECT table_name 
+            FROM information_schema.tables 
+            WHERE table_schema = 'public'
+            AND table_name LIKE 'erp_%'
+            ORDER BY table_name;
+            """
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+            cursor.execute(query)
+            results = cursor.fetchall()
+            table_names = [row['table_name'] for row in results]
+        else:  # sqlite
+            query = """
+            SELECT name as table_name
+            FROM sqlite_master
+            WHERE type='table' AND name LIKE 'erp_%'
+            ORDER BY name;
+            """
+            cursor = conn.cursor()
+            cursor.execute(query)
+            results = cursor.fetchall()
+            table_names = [row['table_name'] for row in results]
         
-        table_names = [row['table_name'] for row in results]
         if not table_names:
-            return str({
+            return {
                 "success": False,
                 "message": "No ERP tables found",
                 "tables": []
-            })
-        return str({
+            }
+        return {
             "success": True,
             "message": f"Found {len(table_names)} tables",
             "count": len(table_names),
             "tables": table_names
-        })
+        }
         
     except Exception as e:
-        return str({
+        return {
             "success": False,
             "error": str(e)
-        })
+        }
     finally:
         if 'conn' in locals():
             conn.close()
 
-def get_order_status(order_id: int):
+@mcp.tool()
+async def get_order_status(order_id: int) -> Dict[str, Any]:
     """
     Get the status of an order by order ID.
     
     Args:
-        order_id: The ID of the order to check
+        order_id (int): The ID of the order to check
     
     Returns:
-        Order status information including shipping and destination countries
-    """
-    query = """
-    SELECT o.*, c.name as customer_name, c.email as customer_email,
-           o.shipping_country, o.destination_country
-    FROM erp_orders o
-    JOIN erp_customers c ON o.customer_id = c.customer_id
-    WHERE o.order_id = %s;
+        dict: Order status information including shipping and destination countries
     """
-    
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
+        conn, db_type = get_db_connection()
+        
+        if db_type == "postgres":
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+            param_placeholder = "%s"
+        else:  # sqlite
+            cursor = conn.cursor()
+            param_placeholder = "?"
+        
+        query = f"""
+        SELECT o.*, c.name as customer_name, c.email as customer_email,
+               o.shipping_country, o.destination_country
+        FROM erp_orders o
+        JOIN erp_customers c ON o.customer_id = c.customer_id
+        WHERE o.order_id = {param_placeholder};
+        """
+        
         cursor.execute(query, [order_id])
         order = cursor.fetchone()
         
         if not order:
-            return str({
+            return {
                 "success": False,
                 "message": f"Order with ID {order_id} not found"
-            })
+            }
         
         # Get order items
-        items_query = """
+        items_query = f"""
         SELECT oi.order_item_id, oi.order_id, oi.product_id, oi.quantity, oi.unit_price, oi.subtotal,
                p.product_name, p.sku
         FROM erp_order_items oi
         JOIN erp_products p ON oi.product_id = p.product_id
-        WHERE oi.order_id = %s;
+        WHERE oi.order_id = {param_placeholder};
         """
         cursor.execute(items_query, [order_id])
         items = cursor.fetchall()
         
         # Get order history
-        history_query = """
+        history_query = f"""
         SELECT * FROM erp_order_history
-        WHERE order_id = %s
+        WHERE order_id = {param_placeholder}
         ORDER BY timestamp DESC;
         """
         cursor.execute(history_query, [order_id])
         history = cursor.fetchall()
         
-        order_dict = dict(order)
-        items_list = [dict(item) for item in items]
-        history_list = [dict(entry) for entry in history]
+        order_dict = order if db_type == "sqlite" else dict(order)
+        items_list = items if db_type == "sqlite" else [dict(item) for item in items]
+        history_list = history if db_type == "sqlite" else [dict(entry) for entry in history]
         
         # Return JSON formatted response
-        return str({
+        return {
             "success": True,
             "order": {
                 "order_id": order_id,
@@ -196,90 +267,92 @@ def get_order_status(order_id: int):
                 "items": items_list,
                 "history": history_list
             }
-        })
+        }
         
     except Exception as e:
-        return str({
+        return {
             "success": False,
             "error": str(e)
-        })
+        }
     finally:
         if 'conn' in locals():
             conn.close()
 
-def place_new_order(
+@mcp.tool()
+async def place_new_order(
     customer_id: int,
-    product_ids: str,
-    quantities: str,
+    items: List[Dict[str, Any]],
     shipping_address: str,
     shipping_country: str,
     destination_country: str,
-    previous_order_id: int = None
-):
+    previous_order_id: Optional[int] = None
+) -> Dict[str, Any]:
     """
-    Place a new order in the ERP system.
+    Place a new order in the ERP system, after ensuring there are no global disruptions affecting the shipment.
     
     Args:
-        customer_id: ID of the customer placing the order
-        product_ids: Comma-separated list of product IDs
-        quantities: Comma-separated list of quantities corresponding to product IDs
-        shipping_address: Shipping address for the order
-        shipping_country: Country where the order will be shipped from
-        destination_country: Country where the order will be delivered to
-        previous_order_id: ID of a previous order this is replacing (optional)
+        customer_id (int): ID of the customer placing the order
+        items (List[Dict]): List of items to order, each with product_id and quantity
+        shipping_address (str): Shipping address for the order
+        shipping_country (str): Country where the order will be shipped from
+        destination_country (str): Country where the order will be delivered to
+        previous_order_id (int, optional): ID of a previous order this is replacing
     
     Returns:
-        New order information
+        dict: New order information
     """
     try:
-        # Parse product IDs and quantities
-        product_id_list = [int(pid.strip()) for pid in product_ids.split(',')]
-        quantity_list = [int(qty.strip()) for qty in quantities.split(',')]
-        
-        if len(product_id_list) != len(quantity_list):
-            return str({
-                "success": False,
-                "error": "Number of product IDs must match number of quantities"
-            })
-        
-        # Create items list
-        items = [
-            {"product_id": pid, "quantity": qty} 
-            for pid, qty in zip(product_id_list, quantity_list)
-        ]
-        
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
+        conn, db_type = get_db_connection()
+        
+        if db_type == "postgres":
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+            param_placeholder = "%s"
+            returning_clause = "RETURNING order_id"
+            date_interval = "CURRENT_DATE + INTERVAL '7 days'"
+            due_date_interval = "CURRENT_DATE + INTERVAL '30 days'"
+            concat_op = "||"
+        else:  # sqlite
+            cursor = conn.cursor()
+            param_placeholder = "?"
+            returning_clause = ""
+            date_interval = "date('now', '+7 days')"
+            due_date_interval = "date('now', '+30 days')"
+            concat_op = "||"
         
         # Calculate total amount based on the total items and their prices
         total_amount = 0
         for item in items:
-            product_query = "SELECT price FROM erp_products WHERE product_id = %s;"
+            product_query = f"SELECT price FROM erp_products WHERE product_id = {param_placeholder};"
             cursor.execute(product_query, [item['product_id']])
             product = cursor.fetchone()
             if not product:
-                return str({
+                return {
                     "success": False,
                     "error": f"Product with ID {item['product_id']} not found"
-                })
+                }
             total_amount += product['price'] * item['quantity']
         
         # Insert new order into the erp_orders table for the customer
-        order_query = """
+        order_query = f"""
         INSERT INTO erp_orders (
             customer_id, order_date, total_amount, status, 
             shipping_address, shipping_country, destination_country, previous_order_id,
             estimated_delivery, payment_status
         ) VALUES (
-            %s, CURRENT_DATE, %s, 'Processing', 
-            %s, %s, %s, %s,
-            CURRENT_DATE + INTERVAL '7 days', 'Pending'
-        ) RETURNING order_id;
+            {param_placeholder}, CURRENT_DATE, {param_placeholder}, 'Processing', 
+            {param_placeholder}, {param_placeholder}, {param_placeholder}, {param_placeholder},
+            {date_interval}, 'Pending'
+        ) {returning_clause};
         """
+        
         cursor.execute(order_query, [
             customer_id, total_amount, shipping_address, shipping_country, destination_country, previous_order_id
         ])
-        new_order_id = cursor.fetchone()['order_id']
+        
+        if db_type == "postgres":
+            new_order_id = cursor.fetchone()['order_id']
+        else:  # sqlite
+            new_order_id = cursor.lastrowid
         
         # Insert order items into erp_order_items table for the new order
         for item in items:
@@ -289,11 +362,11 @@ def place_new_order(
             unit_price = product['price']
             subtotal = unit_price * item['quantity']
             
-            item_query = """
+            item_query = f"""
             INSERT INTO erp_order_items (
                 order_id, product_id, quantity, unit_price, subtotal
             ) VALUES (
-                %s, %s, %s, %s, %s
+                {param_placeholder}, {param_placeholder}, {param_placeholder}, {param_placeholder}, {param_placeholder}
             );
             """
             cursor.execute(item_query, [
@@ -302,252 +375,297 @@ def place_new_order(
             ])
             
             # Update product stock
-            update_stock_query = """
+            update_stock_query = f"""
             UPDATE erp_products 
-            SET stock_quantity = stock_quantity - %s 
-            WHERE product_id = %s;
+            SET stock_quantity = stock_quantity - {param_placeholder} 
+            WHERE product_id = {param_placeholder};
             """
             cursor.execute(update_stock_query, [item['quantity'], item['product_id']])
         
         # Create order history entry into the erp_order_history for the new order
-        history_query = """
+        history_query = f"""
         INSERT INTO erp_order_history (
             order_id, timestamp, status_change, notes, updated_by
         ) VALUES (
-            %s, CURRENT_TIMESTAMP, 'Order Created', 'New order placed', 'System'
+            {param_placeholder}, CURRENT_TIMESTAMP, 'Order Created', 'New order placed', 'System'
         );
         """
         cursor.execute(history_query, [new_order_id])
         
         # If this is a replacement order, add a note to the previous order
         if previous_order_id:
-            prev_order_note_query = """
+            prev_order_note_query = f"""
             INSERT INTO erp_order_history (
                 order_id, timestamp, status_change, notes, updated_by
             ) VALUES (
-                %s, CURRENT_TIMESTAMP, 'Replaced', 'Order replaced by order #%s', 'System'
+                {param_placeholder}, CURRENT_TIMESTAMP, 'Replaced', 'Order replaced by order #' {concat_op} {param_placeholder}, 'System'
             );
             """
             cursor.execute(prev_order_note_query, [previous_order_id, new_order_id])
         
         # Generate invoice for the new order
-        invoice_query = """
+        invoice_query = f"""
         INSERT INTO erp_invoices (
             order_id, invoice_date, amount, payment_terms, due_date, is_paid, invoice_number
         ) VALUES (
-            %s, CURRENT_DATE, %s, 'Net 30', CURRENT_DATE + INTERVAL '30 days', FALSE, 'INV-' || %s
-        ) RETURNING invoice_id;
+            {param_placeholder}, CURRENT_DATE, {param_placeholder}, 'Net 30', {due_date_interval}, 0, 'INV-' {concat_op} {param_placeholder}
+        ) {returning_clause};
         """
-        cursor.execute(invoice_query, [new_order_id, total_amount, new_order_id])
-        invoice_id = cursor.fetchone()['invoice_id']
+        cursor.execute(invoice_query, [new_order_id, total_amount, str(new_order_id)])
+        
+        if db_type == "postgres":
+            invoice_id = cursor.fetchone()['invoice_id']
+        else:  # sqlite
+            invoice_id = cursor.lastrowid
         
         conn.commit()
         
         # Get the complete new order details
-        cursor.execute("SELECT * FROM erp_orders WHERE order_id = %s;", [new_order_id])
+        cursor.execute(f"SELECT * FROM erp_orders WHERE order_id = {param_placeholder};", [new_order_id])
         order = cursor.fetchone()
         
-        order_dict = dict(order)
+        order_dict = order
+        
+        # Format date for response
+        estimated_delivery = order_dict.get('estimated_delivery')
+        if estimated_delivery:
+            if isinstance(estimated_delivery, str):
+                estimated_delivery_str = estimated_delivery
+            else:
+                estimated_delivery_str = estimated_delivery.strftime("%Y-%m-%d") if hasattr(estimated_delivery, 'strftime') else str(estimated_delivery)
+        else:
+            estimated_delivery_str = None
         
         # Return JSON formatted response
-        return str({
+        return {
             "success": True,
             "order": {
                 "order_id": new_order_id,
                 "invoice_id": invoice_id,
                 "total_amount": float(total_amount),
                 "status": order_dict['status'],
-                "estimated_delivery": str(order_dict['estimated_delivery']) if order_dict['estimated_delivery'] else None,
+                "estimated_delivery": estimated_delivery_str,
                 "customer_id": customer_id,
                 "shipping_address": shipping_address,
                 "shipping_country": shipping_country,
                 "destination_country": destination_country,
-                "previous_order_id": previous_order_id,
-                "items": [{"product_id": pid, "quantity": qty} for pid, qty in zip(product_id_list, quantity_list)]
+                "previous_order_id": previous_order_id
             }
-        })
+        }
         
     except Exception as e:
         if 'conn' in locals():
             conn.rollback()
-        return str({
+        return {
             "success": False,
             "error": str(e)
-        })
+        }
     finally:
         if 'conn' in locals():
             conn.close()
 
-def cancel_order(order_id: int, reason: str):
+@mcp.tool()
+async def cancel_order(order_id: int, reason: str) -> Dict[str, Any]:
     """
     Cancel an existing order in the ERP system.
     
     Args:
-        order_id: ID of the order to cancel
-        reason: Reason for cancellation
+        order_id (int): ID of the order to cancel
+        reason (str): Reason for cancellation
     
     Returns:
-        Result of the cancellation operation
+        dict: Result of the cancellation operation
     """
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
+        conn, db_type = get_db_connection()
+        
+        if db_type == "postgres":
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+            param_placeholder = "%s"
+        else:  # sqlite
+            cursor = conn.cursor()
+            param_placeholder = "?"
         
         # Check if order exists and can be cancelled
-        check_query = """
-        SELECT status, customer_id FROM erp_orders WHERE order_id = %s;
+        check_query = f"""
+        SELECT status, customer_id FROM erp_orders WHERE order_id = {param_placeholder};
         """
         cursor.execute(check_query, [order_id])
         order = cursor.fetchone()
         
         if not order:
-            return str({
+            return {
                 "success": False,
                 "error": f"Order with ID {order_id} not found"
-            })
+            }
         
         if order['status'] in ['Delivered', 'Cancelled']:
-            return str({
+            return {
                 "success": False,
                 "error": f"Cannot cancel order with status '{order['status']}'"
-            })
+            }
         
         # Get order items to restore stock
-        items_query = """
-        SELECT product_id, quantity FROM erp_order_items WHERE order_id = %s;
+        items_query = f"""
+        SELECT product_id, quantity FROM erp_order_items WHERE order_id = {param_placeholder};
         """
         cursor.execute(items_query, [order_id])
         items = cursor.fetchall()
         
         # Update order status to Cancelled
-        update_query = """
+        update_query = f"""
         UPDATE erp_orders SET status = 'Cancelled', payment_status = 'Cancelled'
-        WHERE order_id = %s;
+        WHERE order_id = {param_placeholder};
         """
         cursor.execute(update_query, [order_id])
         
         # Add entry to order history
-        history_query = """
+        history_query = f"""
         INSERT INTO erp_order_history (
             order_id, timestamp, status_change, notes, updated_by
         ) VALUES (
-            %s, CURRENT_TIMESTAMP, 'Cancelled', %s, 'System'
+            {param_placeholder}, CURRENT_TIMESTAMP, 'Cancelled', {param_placeholder}, 'System'
         );
         """
         cursor.execute(history_query, [order_id, f"Order cancelled: {reason}"])
         
         # Restore product stock quantities
         for item in items:
-            restore_stock_query = """
+            restore_stock_query = f"""
             UPDATE erp_products 
-            SET stock_quantity = stock_quantity + %s 
-            WHERE product_id = %s;
+            SET stock_quantity = stock_quantity + {param_placeholder} 
+            WHERE product_id = {param_placeholder};
             """
             cursor.execute(restore_stock_query, [item['quantity'], item['product_id']])
         
         # Update invoice if exists
-        invoice_query = """
+        invoice_query = f"""
         UPDATE erp_invoices 
-        SET is_paid = FALSE
-        WHERE order_id = %s;
+        SET is_paid = 0
+        WHERE order_id = {param_placeholder};
         """
         cursor.execute(invoice_query, [order_id])
         
         conn.commit()
         
-        return str({
+        return {
             "success": True,
             "message": f"Order #{order_id} has been successfully cancelled",
-            "order_id": order_id,
             "reason": reason,
             "items_restored": len(items)
-        })
+        }
         
     except Exception as e:
         if 'conn' in locals():
             conn.rollback()
-        return str({
+        return {
             "success": False,
             "error": str(e)
-        })
+        }
     finally:
         if 'conn' in locals():
             conn.close()
 
-def get_invoice_details(invoice_id: int = None, order_id: int = None):
+@mcp.tool()
+async def get_invoice_details(invoice_id: Optional[int] = None, order_id: Optional[int] = None) -> Dict[str, Any]:
     """
     Get invoice details by invoice ID or order ID.
     
     Args:
-        invoice_id: ID of the invoice (optional)
-        order_id: ID of the order (optional)
+        invoice_id (int, optional): ID of the invoice
+        order_id (int, optional): ID of the order
     
     Returns:
-        Invoice details including customer and order information
+        dict: Invoice details including customer and order information
     """
     if not invoice_id and not order_id:
-        return str({
+        return {
             "success": False,
             "error": "Either invoice_id or order_id must be provided"
-        })
+        }
     
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
+        conn, db_type = get_db_connection()
+        
+        if db_type == "postgres":
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+            param_placeholder = "%s"
+        else:  # sqlite
+            cursor = conn.cursor()
+            param_placeholder = "?"
         
         if invoice_id:
-            query = """
+            query = f"""
             SELECT i.*, o.order_date, o.status as order_status, 
                    c.name as customer_name, c.email as customer_email, c.address as customer_address
             FROM erp_invoices i
             JOIN erp_orders o ON i.order_id = o.order_id
             JOIN erp_customers c ON o.customer_id = c.customer_id
-            WHERE i.invoice_id = %s;
+            WHERE i.invoice_id = {param_placeholder};
             """
             cursor.execute(query, [invoice_id])
         else:
-            query = """
+            query = f"""
             SELECT i.*, o.order_date, o.status as order_status, 
                    c.name as customer_name, c.email as customer_email, c.address as customer_address
             FROM erp_invoices i
             JOIN erp_orders o ON i.order_id = o.order_id
             JOIN erp_customers c ON o.customer_id = c.customer_id
-            WHERE i.order_id = %s;
+            WHERE i.order_id = {param_placeholder};
             """
             cursor.execute(query, [order_id])
         
         invoice = cursor.fetchone()
         
         if not invoice:
-            return str({
+            return {
                 "success": False,
                 "error": f"Invoice not found for the provided {'invoice_id' if invoice_id else 'order_id'}"
-            })
+            }
         
         # Get order items
-        items_query = """
+        items_query = f"""
         SELECT oi.*, p.product_name, p.sku
         FROM erp_order_items oi
         JOIN erp_products p ON oi.product_id = p.product_id
-        WHERE oi.order_id = %s;
+        WHERE oi.order_id = {param_placeholder};
         """
         cursor.execute(items_query, [invoice['order_id']])
         items = cursor.fetchall()
         
-        invoice_dict = dict(invoice)
-        items_list = [dict(item) for item in items]
+        invoice_dict = invoice
+        items_list = items
+        
+        # Format dates for response
+        order_date = invoice_dict.get('order_date')
+        if order_date:
+            if isinstance(order_date, str):
+                order_date_str = order_date
+            else:
+                order_date_str = order_date.strftime("%Y-%m-%d") if hasattr(order_date, 'strftime') else str(order_date)
+        else:
+            order_date_str = None
+            
+        due_date = invoice_dict.get('due_date')
+        if due_date:
+            if isinstance(due_date, str):
+                due_date_str = due_date
+            else:
+                due_date_str = due_date.strftime("%Y-%m-%d") if hasattr(due_date, 'strftime') else str(due_date)
+        else:
+            due_date_str = None
         
         # Return JSON formatted response
-        return str({
+        return {
             "success": True,
             "invoice": {
                 "invoice_id": invoice_dict['invoice_id'],
                 "invoice_number": invoice_dict.get('invoice_number', ''),
                 "order_id": invoice_dict['order_id'],
-                "order_date": str(invoice_dict['order_date']) if invoice_dict['order_date'] else None,
+                "order_date": order_date_str,
                 "order_status": invoice_dict['order_status'],
                 "amount": float(invoice_dict['amount']),
-                "due_date": str(invoice_dict['due_date']) if invoice_dict['due_date'] else None,
+                "due_date": due_date_str,
                 "payment_status": "Paid" if invoice_dict['is_paid'] else "Unpaid",
                 "customer": {
                     "name": invoice_dict['customer_name'],
@@ -556,17 +674,48 @@ def get_invoice_details(invoice_id: int = None, order_id: int = None):
                 },
                 "items": items_list
             }
-        })
+        }
         
     except Exception as e:
-        return str({
+        return {
             "success": False,
             "error": str(e)
-        })
+        }
     finally:
         if 'conn' in locals():
             conn.close()
 
+@mcp.tool()
+async def reset_database() -> Dict[str, Any]:
+    """
+    Reset the ERP database by deleting it and recreating it with fresh data.
+    
+    Returns:
+        dict: Result of the database reset operation
+    """
+    try:
+        # Get SQLite database path from environment or use default
+        db_path = os.getenv("SQLITE_DB_PATH", "./data/erp_db.sqlite")
+        
+        # Reset the database
+        result = reset_erp_db(db_path)
+        
+        if result:
+            return {
+                "success": True,
+                "message": "Database reset successfully. All tables have been recreated with fresh sample data."
+            }
+        else:
+            return {
+                "success": False,
+                "error": "Failed to reset database. Check server logs for details."
+            }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Error resetting database: {str(e)}"
+        }
+
 # Create Gradio interfaces for each function
 execute_query_interface = gr.Interface(
     fn=execute_query,
@@ -633,6 +782,14 @@ invoice_details_interface = gr.Interface(
     description="Get invoice details by invoice ID or order ID"
 )
 
+reset_database_interface = gr.Interface(
+    fn=reset_database,
+    inputs=[],
+    outputs=gr.Textbox(lines=5),
+    title="Reset Database",
+    description="Reset the ERP database by deleting it and recreating it with fresh data"
+)
+
 # Create a Gradio TabItem for each interface
 demo = gr.TabbedInterface(
     [
@@ -641,7 +798,8 @@ demo = gr.TabbedInterface(
         order_status_interface,
         place_order_interface,
         cancel_order_interface,
-        invoice_details_interface
+        invoice_details_interface,
+        reset_database_interface
     ],
     [
         "Execute Query",
@@ -649,7 +807,8 @@ demo = gr.TabbedInterface(
         "Order Status",
         "Place Order",
         "Cancel Order",
-        "Invoice Details"
+        "Invoice Details",
+        "Reset Database"
     ],
     title="ERP System Tools"
 )

data/utils/erp_db_init.py

@@ -0,0 +1,145 @@
+# erp_db_init.py
+import sqlite3
+import os
+import pathlib
+
+def init_sqlite_db(db_path='./data/erp_db.sqlite'):
+    """Initialize SQLite database with ERP tables."""
+    try:
+        # Create the database directory if it doesn't exist
+        db_dir = pathlib.Path(os.path.dirname(db_path))
+        db_dir.mkdir(exist_ok=True)
+        
+        # Connect to SQLite database (will be created if it doesn't exist)
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+        
+        # Enable foreign keys
+        conn.execute("PRAGMA foreign_keys = ON")
+        
+        # Create customers table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS erp_customers (
+            customer_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            email TEXT NOT NULL UNIQUE,
+            phone TEXT,
+            address TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+        ''')
+        
+        # Create products table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS erp_products (
+            product_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            product_name TEXT NOT NULL,
+            description TEXT,
+            category TEXT,
+            price REAL NOT NULL,
+            stock_quantity INTEGER NOT NULL DEFAULT 0,
+            sku TEXT UNIQUE
+        )
+        ''')
+        
+        # Create orders table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS erp_orders (
+            order_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            customer_id INTEGER,
+            order_date DATE DEFAULT CURRENT_DATE,
+            total_amount REAL NOT NULL,
+            status TEXT NOT NULL DEFAULT 'Processing',
+            previous_order_id INTEGER,
+            estimated_delivery DATE,
+            actual_delivery DATE,
+            payment_status TEXT DEFAULT 'Pending',
+            shipping_address TEXT NOT NULL,
+            shipping_country TEXT,
+            destination_country TEXT,
+            FOREIGN KEY (customer_id) REFERENCES erp_customers (customer_id),
+            FOREIGN KEY (previous_order_id) REFERENCES erp_orders (order_id)
+        )
+        ''')
+        
+        # Create order items table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS erp_order_items (
+            order_item_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            order_id INTEGER,
+            product_id INTEGER,
+            quantity INTEGER NOT NULL,
+            unit_price REAL NOT NULL,
+            subtotal REAL NOT NULL,
+            FOREIGN KEY (order_id) REFERENCES erp_orders (order_id),
+            FOREIGN KEY (product_id) REFERENCES erp_products (product_id)
+        )
+        ''')
+        
+        # Create order history table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS erp_order_history (
+            history_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            order_id INTEGER,
+            timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            status_change TEXT,
+            notes TEXT,
+            updated_by TEXT,
+            FOREIGN KEY (order_id) REFERENCES erp_orders (order_id)
+        )
+        ''')
+        
+        # Create invoices table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS erp_invoices (
+            invoice_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            order_id INTEGER,
+            invoice_date DATE DEFAULT CURRENT_DATE,
+            amount REAL NOT NULL,
+            payment_terms TEXT,
+            due_date DATE,
+            is_paid BOOLEAN DEFAULT 0,
+            invoice_number TEXT UNIQUE,
+            FOREIGN KEY (order_id) REFERENCES erp_orders (order_id)
+        )
+        ''')
+        
+        # Create global disruptions table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS live_global_disruptions (
+            disruption_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            source_country TEXT NOT NULL,
+            destination_country TEXT NOT NULL,
+            disruption_type TEXT NOT NULL,
+            severity INTEGER NOT NULL CHECK (severity >= 1 AND severity <= 5),
+            start_date DATE NOT NULL,
+            expected_end_date DATE,
+            actual_end_date DATE,
+            is_active BOOLEAN DEFAULT 1,
+            description TEXT,
+            impact_hours INTEGER,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            UNIQUE (source_country, destination_country, disruption_type, start_date)
+        )
+        ''')
+        
+        # Create indexes
+        cursor.execute('CREATE INDEX IF NOT EXISTS idx_orders_customer ON erp_orders (customer_id)')
+        cursor.execute('CREATE INDEX IF NOT EXISTS idx_order_items_order ON erp_order_items (order_id)')
+        cursor.execute('CREATE INDEX IF NOT EXISTS idx_order_items_product ON erp_order_items (product_id)')
+        cursor.execute('CREATE INDEX IF NOT EXISTS idx_order_history_order ON erp_order_history (order_id)')
+        cursor.execute('CREATE INDEX IF NOT EXISTS idx_invoices_order ON erp_invoices (order_id)')
+        cursor.execute('CREATE INDEX IF NOT EXISTS idx_global_disruptions_active ON live_global_disruptions (is_active)')
+        cursor.execute('CREATE INDEX IF NOT EXISTS idx_global_disruptions_countries ON live_global_disruptions (source_country, destination_country)')
+        
+        conn.commit()
+        conn.close()
+        
+        return True
+    except Exception as e:
+        print(f"Error initializing SQLite database: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    init_sqlite_db()

data/utils/populate_erp_db.py

@@ -0,0 +1,415 @@
+# populate_erp_db.py
+import sqlite3
+import os
+import pathlib
+import datetime
+import random
+from data.utils.erp_db_init import init_sqlite_db
+
+def populate_erp_db(db_path='./data/erp_db.sqlite'):
+    """Populate SQLite database with sample ERP data."""
+    try:
+        # Ensure database exists
+        if not os.path.exists(db_path):
+            init_sqlite_db(db_path)
+        
+        # Connect to SQLite database
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+        
+        # Sample data for customers
+        customers = [
+            ('John Doe', 'john.doe@example.com', '555-123-4567', '123 Main St, Anytown, USA'),
+            ('Jane Smith', 'jane.smith@example.com', '555-234-5678', '456 Oak Ave, Somewhere, USA'),
+            ('Robert Johnson', 'robert.j@example.com', '555-345-6789', '789 Pine Rd, Nowhere, USA'),
+            ('Emily Davis', 'emily.davis@example.com', '555-456-7890', '101 Maple Dr, Anywhere, USA'),
+            ('Michael Wilson', 'michael.w@example.com', '555-567-8901', '202 Cedar Ln, Everywhere, USA'),
+            ('Sarah Brown', 'sarah.b@example.com', '555-678-9012', '303 Birch Blvd, Somewhere, USA'),
+            ('David Miller', 'david.m@example.com', '555-789-0123', '404 Elm St, Anytown, USA'),
+            ('Jennifer Taylor', 'jennifer.t@example.com', '555-890-1234', '505 Walnut Ave, Nowhere, USA'),
+            ('Christopher Anderson', 'chris.a@example.com', '555-901-2345', '606 Spruce Rd, Anywhere, USA'),
+            ('Lisa Thomas', 'lisa.t@example.com', '555-012-3456', '707 Fir Dr, Everywhere, USA'),
+            ('Daniel Jackson', 'daniel.j@example.com', '555-123-7890', '808 Pine St, Somewhere, USA'),
+            ('Michelle White', 'michelle.w@example.com', '555-234-8901', '909 Oak Rd, Anytown, USA')
+        ]
+        
+        # Sample data for products
+        products = [
+            ('Laptop Pro', 'High-performance laptop for professionals', 'Electronics', 1299.99, 50, 'LP-001'),
+            ('Smartphone X', 'Latest smartphone with advanced features', 'Electronics', 899.99, 100, 'SP-001'),
+            ('Office Chair', 'Ergonomic office chair', 'Furniture', 199.99, 30, 'OC-001'),
+            ('Desk Lamp', 'LED desk lamp with adjustable brightness', 'Home', 49.99, 75, 'DL-001'),
+            ('Coffee Maker', 'Programmable coffee maker', 'Appliances', 89.99, 40, 'CM-001'),
+            ('Wireless Headphones', 'Noise-cancelling wireless headphones', 'Electronics', 149.99, 60, 'WH-001'),
+            ('Tablet Mini', 'Compact tablet for on-the-go use', 'Electronics', 399.99, 45, 'TM-001'),
+            ('External Hard Drive', '2TB external hard drive', 'Electronics', 129.99, 55, 'EH-001'),
+            ('Wireless Mouse', 'Ergonomic wireless mouse', 'Electronics', 29.99, 80, 'WM-001'),
+            ('Bluetooth Speaker', 'Portable Bluetooth speaker', 'Electronics', 79.99, 65, 'BS-001'),
+            ('Monitor 27"', '27-inch 4K monitor', 'Electronics', 349.99, 35, 'MN-001'),
+            ('Keyboard', 'Mechanical gaming keyboard', 'Electronics', 119.99, 70, 'KB-001'),
+            ('Desk', 'Adjustable standing desk', 'Furniture', 299.99, 25, 'DK-001'),
+            ('Bookshelf', 'Modern 5-tier bookshelf', 'Furniture', 149.99, 20, 'BS-002')
+        ]
+        
+        # Insert customers
+        cursor.executemany('''
+        INSERT INTO erp_customers (name, email, phone, address)
+        VALUES (?, ?, ?, ?)
+        ''', customers)
+        
+        # Insert products
+        cursor.executemany('''
+        INSERT INTO erp_products (product_name, description, category, price, stock_quantity, sku)
+        VALUES (?, ?, ?, ?, ?, ?)
+        ''', products)
+        
+        # Get customer IDs for reference
+        cursor.execute('SELECT customer_id FROM erp_customers')
+        customer_ids = [row[0] for row in cursor.fetchall()]
+        
+        # Get product IDs for reference
+        cursor.execute('SELECT product_id, price FROM erp_products')
+        product_data = cursor.fetchall()
+        product_ids = [row[0] for row in product_data]
+        product_prices = {row[0]: row[1] for row in product_data}
+        
+        # Sample data for orders
+        orders = []
+        order_items = []
+        invoices = []
+        order_history = []
+        
+        # Generate 15 orders
+        for i in range(1, 16):
+            # Randomly select a customer
+            customer_id = random.choice(customer_ids)
+            
+            # Get customer address for shipping
+            cursor.execute('SELECT address FROM erp_customers WHERE customer_id = ?', (customer_id,))
+            address = cursor.fetchone()[0]
+            
+            # Generate order date (within the last 60 days)
+            days_ago = random.randint(1, 60)
+            order_date = (datetime.datetime.now() - datetime.timedelta(days=days_ago)).strftime('%Y-%m-%d')
+            
+            # Generate estimated delivery (3-10 days after order)
+            est_delivery = (datetime.datetime.now() - datetime.timedelta(days=days_ago) + 
+                           datetime.timedelta(days=random.randint(3, 10))).strftime('%Y-%m-%d')
+            
+            # Determine if order has been delivered
+            delivered = random.random() > 0.3  # 70% chance of being delivered
+            actual_delivery = None
+            if delivered:
+                # Delivery occurred 0-2 days after estimated delivery
+                delivery_offset = random.randint(-1, 2)  # Can be early or late
+                actual_delivery = (datetime.datetime.now() - datetime.timedelta(days=days_ago) + 
+                                  datetime.timedelta(days=random.randint(3, 10) + delivery_offset)).strftime('%Y-%m-%d')
+            
+            # Determine order status
+            if days_ago <= 1:
+                status = 'Processing'
+            elif days_ago <= 3:
+                status = 'Shipped'
+            elif delivered:
+                status = 'Delivered'
+            else:
+                status = random.choice(['Processing', 'Shipped', 'In Transit'])
+            
+            # Determine payment status
+            payment_status = random.choice(['Paid', 'Pending', 'Paid', 'Paid'])  # 75% chance of being paid
+            
+            # Generate shipping and destination countries
+            shipping_country = random.choice([
+                'USA', 'Canada', 'UK', 'Germany', 'France', 'Australia', 
+                'China', 'Japan', 'India', 'Brazil', 'Mexico', 'South Africa',
+                'Italy', 'Spain', 'Russia', 'South Korea', 'Singapore', 'UAE',
+                'Netherlands', 'Sweden'
+            ])
+            destination_country = shipping_country  # Usually the same
+            
+            # Previous order (for some customers)
+            previous_order_id = None
+            if i > 5 and random.random() > 0.7:  # 30% chance of having a previous order
+                previous_order_id = random.randint(1, i-1)
+            
+            # Add to orders list
+            orders.append((
+                customer_id, order_date, 0,  # Total amount will be updated later
+                status, previous_order_id, est_delivery, actual_delivery,
+                payment_status, address, shipping_country, destination_country
+            ))
+        
+        # Insert orders
+        cursor.executemany('''
+        INSERT INTO erp_orders (
+            customer_id, order_date, total_amount, status, previous_order_id,
+            estimated_delivery, actual_delivery, payment_status, shipping_address,
+            shipping_country, destination_country
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ''', orders)
+        
+        # Get order IDs
+        cursor.execute('SELECT order_id FROM erp_orders')
+        order_ids = [row[0] for row in cursor.fetchall()]
+        
+        # Generate order items for each order
+        for order_id in order_ids:
+            # Each order has 1-5 items
+            num_items = random.randint(1, 5)
+            order_total = 0
+            
+            # Select random products for this order
+            selected_products = random.sample(product_ids, num_items)
+            
+            for product_id in selected_products:
+                quantity = random.randint(1, 3)
+                unit_price = product_prices[product_id]
+                subtotal = quantity * unit_price
+                order_total += subtotal
+                
+                # Add to order items list
+                order_items.append((order_id, product_id, quantity, unit_price, subtotal))
+            
+            # Update order total
+            cursor.execute('UPDATE erp_orders SET total_amount = ? WHERE order_id = ?', (order_total, order_id))
+            
+            # Generate invoice for paid orders
+            cursor.execute('SELECT payment_status FROM erp_orders WHERE order_id = ?', (order_id,))
+            payment_status = cursor.fetchone()[0]
+            
+            if payment_status == 'Paid':
+                invoice_date = (datetime.datetime.now() - datetime.timedelta(days=random.randint(1, 30))).strftime('%Y-%m-%d')
+                due_date = (datetime.datetime.now() - datetime.timedelta(days=random.randint(1, 15))).strftime('%Y-%m-%d')
+                invoice_number = f'INV-{order_id}-{random.randint(1000, 9999)}'
+                
+                invoices.append((order_id, invoice_date, order_total, 'Net 30', due_date, 1, invoice_number))
+            
+            # Generate order history entries
+            # Initial status
+            order_history.append((
+                order_id, 
+                (datetime.datetime.now() - datetime.timedelta(days=random.randint(50, 60))).strftime('%Y-%m-%d %H:%M:%S'),
+                'Order Created',
+                'New order placed',
+                'System'
+            ))
+            
+            # Processing status
+            order_history.append((
+                order_id, 
+                (datetime.datetime.now() - datetime.timedelta(days=random.randint(40, 49))).strftime('%Y-%m-%d %H:%M:%S'),
+                'Processing',
+                'Order is being processed',
+                'System'
+            ))
+            
+            # Additional statuses based on current order status
+            cursor.execute('SELECT status FROM erp_orders WHERE order_id = ?', (order_id,))
+            current_status = cursor.fetchone()[0]
+            
+            if current_status in ['Shipped', 'In Transit', 'Delivered']:
+                order_history.append((
+                    order_id, 
+                    (datetime.datetime.now() - datetime.timedelta(days=random.randint(30, 39))).strftime('%Y-%m-%d %H:%M:%S'),
+                    'Shipped',
+                    'Order has been shipped',
+                    'Shipping Dept'
+                ))
+            
+            if current_status in ['In Transit', 'Delivered']:
+                order_history.append((
+                    order_id, 
+                    (datetime.datetime.now() - datetime.timedelta(days=random.randint(20, 29))).strftime('%Y-%m-%d %H:%M:%S'),
+                    'In Transit',
+                    'Order is in transit',
+                    'Shipping Carrier'
+                ))
+            
+            if current_status == 'Delivered':
+                order_history.append((
+                    order_id, 
+                    (datetime.datetime.now() - datetime.timedelta(days=random.randint(1, 19))).strftime('%Y-%m-%d %H:%M:%S'),
+                    'Delivered',
+                    'Order has been delivered',
+                    'Shipping Carrier'
+                ))
+        
+        # Insert order items
+        cursor.executemany('''
+        INSERT INTO erp_order_items (order_id, product_id, quantity, unit_price, subtotal)
+        VALUES (?, ?, ?, ?, ?)
+        ''', order_items)
+        
+        # Insert invoices
+        cursor.executemany('''
+        INSERT INTO erp_invoices (order_id, invoice_date, amount, payment_terms, due_date, is_paid, invoice_number)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+        ''', invoices)
+        
+        # Insert order history
+        cursor.executemany('''
+        INSERT INTO erp_order_history (order_id, timestamp, status_change, notes, updated_by)
+        VALUES (?, ?, ?, ?, ?)
+        ''', order_history)
+        
+        # Sample data for global disruptions
+        disruption_types = [
+            'Natural Disaster', 'Political Unrest', 'Labor Strike', 
+            'Transportation Issue', 'Customs Delay', 'Weather Event',
+            'Port Congestion', 'Regulatory Change', 'Supply Shortage',
+            'Infrastructure Failure', 'Security Threat', 'Health Crisis'
+        ]
+        
+        countries = [
+            'USA', 'Canada', 'UK', 'Germany', 'France', 'Australia', 
+            'China', 'Japan', 'India', 'Brazil', 'Mexico', 'South Africa',
+            'Italy', 'Spain', 'Russia', 'South Korea', 'Singapore', 'UAE',
+            'Netherlands', 'Sweden'
+        ]
+        
+        global_disruptions = []
+        
+        # Generate 15 global disruptions
+        for i in range(1, 16):
+            # Select random countries for source and destination
+            source_country = random.choice(countries)
+            # Ensure destination is different from source
+            destination_options = [c for c in countries if c != source_country]
+            destination_country = random.choice(destination_options)
+            
+            # Select random disruption type
+            disruption_type = random.choice(disruption_types)
+            
+            # Generate severity (1-5)
+            severity = random.randint(1, 5)
+            
+            # Generate start date (within the last 90 days)
+            days_ago = random.randint(1, 90)
+            start_date = (datetime.datetime.now() - datetime.timedelta(days=days_ago)).strftime('%Y-%m-%d')
+            
+            # Generate expected end date (1-30 days after start)
+            expected_days_duration = random.randint(1, 30)
+            expected_end_date = (datetime.datetime.now() - datetime.timedelta(days=days_ago) + 
+                               datetime.timedelta(days=expected_days_duration)).strftime('%Y-%m-%d')
+            
+            # Determine if disruption has ended
+            is_ended = random.random() > 0.6  # 40% chance of being ended
+            actual_end_date = None
+            if is_ended:
+                # Actual end occurred 0-5 days after/before expected end
+                end_offset = random.randint(-5, 5)
+                actual_end_date = (datetime.datetime.now() - datetime.timedelta(days=days_ago) + 
+                                  datetime.timedelta(days=expected_days_duration + end_offset)).strftime('%Y-%m-%d')
+            
+            # Determine if disruption is active
+            is_active = not is_ended
+            
+            # Generate impact hours based on severity
+            impact_hours = severity * random.randint(10, 48)
+            
+            # Generate description
+            descriptions = {
+                'Natural Disaster': [
+                    f"Severe flooding in {source_country} affecting shipments to {destination_country}",
+                    f"Earthquake in {source_country} disrupting supply chain to {destination_country}",
+                    f"Hurricane impacting shipping routes between {source_country} and {destination_country}"
+                ],
+                'Political Unrest': [
+                    f"Protests in {source_country} affecting exports to {destination_country}",
+                    f"Trade dispute between {source_country} and {destination_country}",
+                    f"Political tensions causing delays in shipments from {source_country} to {destination_country}"
+                ],
+                'Labor Strike': [
+                    f"Port workers strike in {source_country} affecting shipments to {destination_country}",
+                    f"Transportation union strike impacting deliveries between {source_country} and {destination_country}",
+                    f"Warehouse workers strike in {source_country} delaying orders to {destination_country}"
+                ],
+                'Transportation Issue': [
+                    f"Major highway closure between {source_country} and {destination_country}",
+                    f"Shipping container shortage affecting routes from {source_country} to {destination_country}",
+                    f"Fuel shortage in {source_country} impacting deliveries to {destination_country}"
+                ],
+                'Customs Delay': [
+                    f"New customs regulations in {destination_country} causing delays from {source_country}",
+                    f"Increased inspection rates at {destination_country} border for goods from {source_country}",
+                    f"Documentation issues for shipments from {source_country} to {destination_country}"
+                ],
+                'Weather Event': [
+                    f"Severe snowstorm in {source_country} delaying shipments to {destination_country}",
+                    f"Fog at major ports in {source_country} affecting vessels bound for {destination_country}",
+                    f"Extreme heat causing transportation issues between {source_country} and {destination_country}"
+                ],
+                'Port Congestion': [
+                    f"Backlog at {source_country} ports affecting shipments to {destination_country}",
+                    f"Vessel scheduling issues at {source_country} ports for routes to {destination_country}",
+                    f"Limited berthing capacity at {destination_country} ports for vessels from {source_country}"
+                ],
+                'Regulatory Change': [
+                    f"New import regulations in {destination_country} affecting goods from {source_country}",
+                    f"Export restrictions in {source_country} for shipments to {destination_country}",
+                    f"Changed documentation requirements between {source_country} and {destination_country}"
+                ],
+                'Supply Shortage': [
+                    f"Raw material shortage in {source_country} affecting production for {destination_country}",
+                    f"Component shortage impacting products shipped from {source_country} to {destination_country}",
+                    f"Limited availability of goods in {source_country} for export to {destination_country}"
+                ],
+                'Infrastructure Failure': [
+                    f"Bridge collapse on major route between {source_country} and {destination_country}",
+                    f"Power outage in {source_country} affecting production for {destination_country}",
+                    f"IT system failure impacting customs processing between {source_country} and {destination_country}"
+                ],
+                'Security Threat': [
+                    f"Increased piracy risk on shipping routes from {source_country} to {destination_country}",
+                    f"Security concerns at {source_country} borders affecting shipments to {destination_country}",
+                    f"Cybersecurity incident affecting logistics between {source_country} and {destination_country}"
+                ],
+                'Health Crisis': [
+                    f"Disease outbreak in {source_country} affecting workforce for exports to {destination_country}",
+                    f"Quarantine requirements delaying shipments from {source_country} to {destination_country}",
+                    f"Health screening causing delays at {destination_country} border for goods from {source_country}"
+                ]
+            }
+            
+            description = random.choice(descriptions.get(disruption_type, [f"{disruption_type} affecting shipments from {source_country} to {destination_country}"]))
+            
+            # Add to global disruptions list
+            global_disruptions.append((
+                source_country, destination_country, disruption_type, severity,
+                start_date, expected_end_date, actual_end_date, is_active,
+                description, impact_hours
+            ))
+        
+        # Insert global disruptions
+        cursor.executemany('''
+        INSERT INTO live_global_disruptions (
+            source_country, destination_country, disruption_type, severity,
+            start_date, expected_end_date, actual_end_date, is_active,
+            description, impact_hours
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ''', global_disruptions)
+        
+        # Commit changes and close connection
+        conn.commit()
+        conn.close()
+        
+        print(f"Successfully populated ERP database with sample data.")
+        
+        # Print summary of inserted data
+        print(f"Inserted {len(customers)} customers")
+        print(f"Inserted {len(products)} products")
+        print(f"Inserted {len(orders)} orders")
+        print(f"Inserted {len(order_items)} order items")
+        print(f"Inserted {len(invoices)} invoices")
+        print(f"Inserted {len(order_history)} order history entries")
+        print(f"Inserted {len(global_disruptions)} global disruptions")
+        
+        return True
+    except Exception as e:
+        print(f"Error populating SQLite database: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    populate_erp_db()

data/utils/reset_erp_db.py

@@ -0,0 +1,47 @@
+# reset_erp_db.py
+import os
+import pathlib
+from data.utils.erp_db_init import init_sqlite_db
+from data.utils.populate_erp_db import populate_erp_db
+
+def reset_erp_db(db_path='./data/erp_db.sqlite'):
+    """Reset the ERP database by deleting it and recreating it with fresh data."""
+    try:
+        print(f"Resetting ERP database at {db_path}...")
+        
+        # Check if database file exists
+        if os.path.exists(db_path):
+            print(f"Removing existing database file...")
+            os.remove(db_path)
+            print(f"Database file removed.")
+        else:
+            print(f"No existing database file found.")
+        
+        # Create database directory if it doesn't exist
+        db_dir = pathlib.Path(os.path.dirname(db_path))
+        db_dir.mkdir(exist_ok=True)
+        
+        # Initialize the database
+        print(f"Initializing new database...")
+        init_result = init_sqlite_db(db_path)
+        if not init_result:
+            print(f"Failed to initialize database.")
+            return False
+        print(f"Database initialized successfully.")
+        
+        # Populate the database with sample data
+        print(f"Populating database with sample data...")
+        populate_result = populate_erp_db(db_path)
+        if not populate_result:
+            print(f"Failed to populate database.")
+            return False
+        print(f"Database populated successfully.")
+        
+        print(f"Database reset complete.")
+        return True
+    except Exception as e:
+        print(f"Error resetting database: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    reset_erp_db()