Upload 3 files

Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libpq-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python packages
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create necessary files with proper permissions
+RUN touch database.csv chat_history.csv && \
+    chmod 666 database.csv chat_history.csv
+
+# Create a non-root user
+RUN useradd -m -u 1000 user
+
+# Give full permissions to the app directory
+RUN chmod -R 777 /app
+
+EXPOSE 5000
+
+CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:5000"]

app.py

@@ -0,0 +1,162 @@
+from flask import Flask, request, jsonify, render_template
+from flask_cors import CORS # Import CORS
+from dotenv import load_dotenv
+import os
+import logging
+from datetime import datetime
+import csv
+import json # For logging complex items
+from uuid import uuid4
+
+load_dotenv()
+
+app = Flask(__name__, template_folder='templates', static_folder='static')
+CORS(app) # Enable CORS for all routes and all origins by default
+
+# Configure logging for the mock API
+MOCK_API_LOG_LEVEL = os.getenv("MOCK_API_LOG_LEVEL", "INFO").upper()
+mock_numeric_level = getattr(logging, MOCK_API_LOG_LEVEL, logging.INFO)
+logging.basicConfig(
+    level=mock_numeric_level,
+    format='%(asctime)s - MockOrderAPI - %(levelname)s - %(message)s'
+)
+mock_logger = logging.getLogger(__name__)
+mock_logger.info(f"Mock Order API logging level set to: {MOCK_API_LOG_LEVEL}")
+
+
+MOCK_API_SECRET_KEY = os.getenv('MOCK_API_FLASK_SECRET_KEY', 'a_different_secret_key_for_mock_api')
+if MOCK_API_SECRET_KEY == 'a_different_secret_key_for_mock_api' and not os.getenv('MOCK_API_FLASK_SECRET_KEY'):
+    mock_logger.warning("Using default Flask secret key for Mock API. Set MOCK_API_FLASK_SECRET_KEY in .env if sessions are used.")
+app.secret_key = MOCK_API_SECRET_KEY
+
+ORDERS_CSV_FILE = 'received_orders.csv'
+CSV_HEADER = ['timestamp', 'order_id', 'session_id', 'user_email', 'business_id', 'canonical_user_id', 'items_json_array']
+
+def initialize_orders_csv():
+    if not os.path.exists(ORDERS_CSV_FILE):
+        try:
+            with open(ORDERS_CSV_FILE, 'w', newline='', encoding='utf-8') as f:
+                writer = csv.writer(f)
+                writer.writerow(CSV_HEADER)
+            mock_logger.info(f"Orders CSV file '{ORDERS_CSV_FILE}' created.")
+        except IOError as e:
+            mock_logger.error(f"Failed to create orders CSV file '{ORDERS_CSV_FILE}': {e}", exc_info=True)
+
+@app.route('/')
+def index():
+    """Serves the main dashboard page (index.html)."""
+    return render_template('index.html')
+
+@app.route('/api/v1/orders/list', methods=['GET'])
+def list_orders():
+    initialize_orders_csv()
+    orders = []
+    try:
+        if not os.path.exists(ORDERS_CSV_FILE):
+            mock_logger.warning(f"Attempted to list orders, but '{ORDERS_CSV_FILE}' does not exist.")
+            return jsonify({"status": "success", "orders": [], "message": "No orders file found."}), 200
+
+        with open(ORDERS_CSV_FILE, 'r', newline='', encoding='utf-8') as f:
+            reader = csv.DictReader(f)
+            for row_number, row in enumerate(reader, 1): # Start row_number from 1 for logging
+                # Basic check for expected number of columns based on header
+                if len(row) != len(CSV_HEADER):
+                    mock_logger.warning(f"Row {row_number} in '{ORDERS_CSV_FILE}' has an incorrect number of columns. Expected {len(CSV_HEADER)}, got {len(row)}. Skipping row: {row}")
+                    continue # Skip malformed rows
+
+                try:
+                    items_str = row.get('items_json_array', '[]')
+                    # Handle potential empty strings or malformed JSON before parsing
+                    if not items_str or items_str.isspace():
+                        row['items_json_array'] = []
+                    else:
+                        row['items_json_array'] = json.loads(items_str)
+
+                except json.JSONDecodeError:
+                    mock_logger.warning(f"Could not parse items_json_array for order {row.get('order_id', 'N/A')} in row {row_number}: '{row.get('items_json_array', '')}'")
+                    row['items_json_array'] = [] # Default to empty list on error
+                except TypeError: # Handles if items_json_array is None from DictReader
+                    mock_logger.warning(f"items_json_array was None for order {row.get('order_id', 'N/A')} in row {row_number}. Defaulting to empty list.")
+                    row['items_json_array'] = []
+                
+                orders.append(row)
+        
+        orders.sort(key=lambda x: x.get('timestamp', ''), reverse=True)
+        mock_logger.info(f"Successfully retrieved {len(orders)} orders from CSV.")
+        return jsonify({"status": "success", "orders": orders}), 200
+    except FileNotFoundError:
+        mock_logger.info(f"Orders CSV file '{ORDERS_CSV_FILE}' not found when listing orders.")
+        return jsonify({"status": "success", "orders": [], "message": "No orders recorded yet."}), 200
+    except Exception as e:
+        mock_logger.error(f"Error reading or parsing orders CSV: {e}", exc_info=True)
+        return jsonify({"status": "error", "message": "Failed to retrieve orders."}), 500
+
+
+@app.route('/api/v1/orders/place', methods=['POST'])
+def place_order():
+    initialize_orders_csv()
+    try:
+        order_data = request.json
+        if not order_data:
+            mock_logger.warning("Received empty payload for order placement.")
+            return jsonify({"status": "error", "message": "Empty payload."}), 400
+
+        user_info = order_data.get("user_info", {})
+        order_items = order_data.get("order_items", [])
+
+        if not isinstance(order_items, list) or not order_items:
+            mock_logger.warning(f"Invalid or empty order_items received: {order_items}")
+            return jsonify({"status": "error", "message": "Invalid or empty 'order_items' list is required."}), 400
+
+        mock_logger.info(f"--- ORDER RECEIVED by Mock Order API ---")
+        mock_logger.info(f"Timestamp: {datetime.now().isoformat()}")
+        mock_logger.info(f"User Info: {json.dumps(user_info)}")
+        mock_logger.info("Order Items:")
+        for item in order_items:
+            mock_logger.info(f"  - Product: {item.get('product_name', 'N/A')}, SKU: {item.get('sku', 'N/A')}, Quantity: {item.get('quantity', 'N/A')}, Unit: {item.get('unit', 'N/A')}")
+
+        simulated_order_id = f"MOCK-{uuid4().hex[:8].upper()}"
+
+        try:
+            # Ensure the file has a header if it's empty or just created
+            is_new_file = not os.path.exists(ORDERS_CSV_FILE) or os.path.getsize(ORDERS_CSV_FILE) == 0
+            
+            with open(ORDERS_CSV_FILE, 'a', newline='', encoding='utf-8') as f:
+                writer = csv.writer(f)
+                if is_new_file: # Should be handled by initialize_orders_csv, but as a safeguard
+                    writer.writerow(CSV_HEADER)
+                    mock_logger.info(f"Header written to new/empty {ORDERS_CSV_FILE} before appending order.")
+
+                items_json_str = json.dumps(order_items)
+                writer.writerow([
+                    datetime.now().isoformat(),
+                    simulated_order_id,
+                    user_info.get('session_id', 'N/A'),
+                    user_info.get('email', 'N/A'),
+                    user_info.get('business_id', 'N/A'),
+                    user_info.get('canonical_user_id', 'N/A'),
+                    items_json_str
+                ])
+            mock_logger.info(f"Order {simulated_order_id} successfully written to {ORDERS_CSV_FILE}")
+        except IOError as e_csv:
+            mock_logger.error(f"Failed to write order {simulated_order_id} to CSV: {e_csv}", exc_info=True)
+            return jsonify({"status": "success", "message": "Order received but failed to log locally.", "order_id": simulated_order_id, "warning": "Internal logging error"}), 200
+
+
+        mock_logger.info(f"--- END OF ORDER PROCESSING (Order ID: {simulated_order_id}) ---")
+        return jsonify({"status": "success", "message": "Order received and logged by Mock API.", "order_id": simulated_order_id}), 200
+
+    except Exception as e:
+        mock_logger.error(f"Unexpected error in place_order: {e}", exc_info=True)
+        return jsonify({"status": "error", "message": "An unexpected internal server error occurred."}), 500
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    return jsonify({"status": "healthy", "message": "Mock Order API is running."}), 200
+
+
+if __name__ == '__main__':
+    port = int(os.getenv('MOCK_ORDER_API_PORT', 5002))
+    debug_mode = os.getenv('FLASK_DEBUG', 'False').lower() == 'true' # Example of using FLASK_DEBUG env var
+    mock_logger.info(f"Starting Mock Order API server on 0.0.0.0:{port} (Debug: {debug_mode})")
+    app.run(host='0.0.0.0', port=port, debug=debug_mode)

requirements.txt

@@ -0,0 +1,3 @@
+Flask==3.1.1
+flask_cors==5.0.1
+python-dotenv==1.1.0