Update menu.py

menu.py

@@ -1,454 +1,311 @@
 from flask import Blueprint, render_template, request, session, jsonify, redirect, url_for
 from salesforce import get_salesforce_connection
 import os
-import re
-import logging
-from urllib.parse import quote
-from datetime import datetime, timedelta
-
-# Initialize logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
 
 menu_blueprint = Blueprint('menu', __name__)
 
 # Initialize Salesforce connection
 sf = get_salesforce_connection()
 
-# Constants
-STATIC_DIR = os.path.join(os.path.dirname(__file__), '..', 'static')
+# Constants for video handling
+STATIC_DIR = os.path.join(os.path.dirname(__file__), 'static')
 PLACEHOLDER_VIDEO = 'placeholder.mp4'
-PLACEHOLDER_IMAGE = 'placeholder.jpg'
-PLACEHOLDER_VIDEO_PATH = os.path.join(STATIC_DIR, PLACEHOLDER_VIDEO)
-PLACEHOLDER_IMAGE_PATH = os.path.join(STATIC_DIR, PLACEHOLDER_IMAGE)
-SECTION_ORDER = ["Best Sellers", "Starters", "Biryanis", "Curries", "Breads", 
-                "Customized Dish", "Appetizer", "Desserts", "Soft Drinks"]
-MAX_BEST_SELLERS = 4
-DEFAULT_VIDEO_URL = "https://yourdomain.my.salesforce.com/sfc/servlet.shepherd/version/download/"
-
-# Custom Jinja2 filter
-def slugify(text):
-    """Convert text to a slug format (lowercase, replace spaces with hyphens)"""
-    if not text:
-        return ""
-    text = text.lower()
-    text = re.sub(r'[^\w\s-]', '', text)  # Remove non-alphanumeric chars
-    text = re.sub(r'[\s-]+', '-', text)   # Replace spaces and multiple hyphens with single hyphen
-    return text
-
-# Register the filter with the blueprint
-@menu_blueprint.app_template_filter('slugify')
-def slugify_filter(s):
-    return slugify(s)
-
-def initialize_placeholders():
-    """Create placeholder files if they don't exist"""
-    try:
-        if not os.path.exists(PLACEHOLDER_VIDEO_PATH):
-            with open(PLACEHOLDER_VIDEO_PATH, 'wb') as f:
-                f.write(b'')  # Empty file
-            logger.info(f"Created placeholder video at {PLACEHOLDER_VIDEO_PATH}")
-        
-        if not os.path.exists(PLACEHOLDER_IMAGE_PATH):
-            with open(PLACEHOLDER_IMAGE_PATH, 'wb') as f:
-                f.write(b'')  # Empty file
-            logger.info(f"Created placeholder image at {PLACEHOLDER_IMAGE_PATH}")
-    except Exception as e:
-        logger.error(f"Error creating placeholder files: {str(e)}")
+PLACEHOLDER_PATH = os.path.join(STATIC_DIR, PLACEHOLDER_VIDEO)
+SECTION_ORDER = ["Best Sellers", "Starters", "Biryanis", "Curries", "Breads", "Customized dish", "Apetizer", "Desserts", "Soft Drinks"]
 
-initialize_placeholders()
+# Create placeholder video at startup if it doesn't exist
+if not os.path.exists(PLACEHOLDER_PATH):
+    open(PLACEHOLDER_PATH, 'wb').close()
+    print(f"Created placeholder video at {PLACEHOLDER_PATH}")
 
-def get_valid_media_path(media_url=None, media_type='video'):
+def get_valid_video_path(item_name, video_url=None):
     """
-    Get valid media path with placeholder fallback
-    Args:
-        media_url: URL or ID from Salesforce
-        media_type: 'video' or 'image'
-    Returns:
-        Valid URL for the media
+    Get valid video path for item with placeholder fallback
+    Priority: 1. Video1__c from Salesforce 2. placeholder.mp4
     """
-    # Default placeholders
-    default_path = f"/static/{PLACEHOLDER_VIDEO if media_type == 'video' else PLACEHOLDER_IMAGE}"
-    
-    if not media_url:
-        return default_path
-    
-    # Handle Salesforce File ID (starts with '069')
-    if media_url.startswith('069'):
-        return f"{DEFAULT_VIDEO_URL}{media_url}"
-    
-    # Handle complete URLs
-    if media_url.startswith(('http://', 'https://')):
-        return media_url
+    # First try: Video1__c from Salesforce if provided
+    if video_url:
+        # If it's a complete URL (http/https)
+        if video_url.startswith(('http://', 'https://')):
+            return video_url
+        # If it's a relative path (/videos/xxx.mp4)
+        elif video_url.startswith('/'):
+            return video_url
+        # If it's a Salesforce File ID (starts with '069')
+        elif video_url.startswith('069'):
+            return f"https://yourdomain.my.salesforce.com/sfc/servlet.shepherd/version/download/{video_url}"
     
-    # Handle relative paths
-    if media_url.startswith('/'):
-        return media_url
+    # Final fallback: placeholder.mp4
+    if not os.path.exists(PLACEHOLDER_PATH):
+        open(PLACEHOLDER_PATH, 'wb').close()
+        print(f"Created missing placeholder video at {PLACEHOLDER_PATH}")
     
-    return default_path
+    return f"/static/{PLACEHOLDER_VIDEO}"
 
-def validate_user_session():
-    """Validate and return user session data or redirect to login"""
+@menu_blueprint.route("/menu", methods=["GET", "POST"])
+def menu():
+    selected_category = request.args.get("category", "All")
     user_email = session.get('user_email')
-    user_name = session.get('user_name')
-    
+
     if not user_email:
-        user_email = request.args.get('email')
-        user_name = request.args.get('name')
-        
+        user_email = request.args.get("email")
+        user_name = request.args.get("name")
+
         if user_email:
             session['user_email'] = user_email
             session['user_name'] = user_name
         else:
-            return None, None, redirect(url_for("login"))
-    
+            return redirect(url_for("login"))
+    else:
+        user_name = session.get('user_name')
+
     first_letter = user_name[0].upper() if user_name else "A"
-    return user_email, first_letter, None
 
-def get_user_details(sf_connection, email):
-    """Fetch user details from Salesforce"""
     try:
-        query = f"""
-            SELECT Id, Referral__c, Reward_Points__c 
-            FROM Customer_Login__c 
-            WHERE Email__c = '{email}'
-        """
-        result = sf_connection.query(query)
-        
-        if not result['records']:
-            return None
-        
-        return {
-            'referral_code': result['records'][0].get('Referral__c', 'N/A'),
-            'reward_points': result['records'][0].get('Reward_Points__c', 0)
-        }
-    except Exception as e:
-        logger.error(f"Error fetching user details: {str(e)}")
-        return None
+        # Fetch user referral and reward points
+        user_query = f"SELECT Referral__c, Reward_Points__c FROM Customer_Login__c WHERE Email__c = '{user_email}'"
+        user_result = sf.query(user_query)
 
-def get_cart_count(sf_connection, email):
-    """Get cart item count for user"""
-    try:
-        query = f"SELECT COUNT() FROM Cart_Item__c WHERE Customer_Email__c = '{email}'"
-        result = sf_connection.query(query)
-        return result['totalSize']
-    except Exception as e:
-        logger.error(f"Error fetching cart count: {str(e)}")
-        return 0
+        if not user_result['records']:
+            return redirect(url_for('login'))
 
-def fetch_menu_items(sf_connection, selected_category):
-    """Fetch and process menu items from Salesforce"""
-    try:
-        # Query for standard menu items
+        referral_code = user_result['records'][0].get('Referral__c', 'N/A')
+        reward_points = user_result['records'][0].get('Reward_Points__c', 0)
+
+        # Get cart item count
+        cart_query = f"SELECT COUNT() FROM Cart_Item__c WHERE Customer_Email__c = '{user_email}'"
+        cart_count_result = sf.query(cart_query)
+        cart_item_count = cart_count_result['totalSize']
+
+        # Query to fetch Menu_Item__c records including Video1__c
         menu_query = """
-            SELECT Id, Name, Price__c, Description__c, Image1__c, Image2__c, 
-                   Veg_NonVeg__c, Section__c, Total_Ordered__c, Video1__c,
-                   Is_Available__c, Spice_Level__c, Preparation_Time__c
+            SELECT Name, Price__c, Description__c, Image1__c, Image2__c, 
+                   Veg_NonVeg__c, Section__c, Total_Ordered__c, Video1__c
             FROM Menu_Item__c
-            WHERE Is_Available__c = true
         """
-        menu_result = sf_connection.query(menu_query)
-        food_items = menu_result.get('records', [])
-        
-        # Query for custom dishes (last 7 days)
+        result = sf.query(menu_query)
+        food_items = result['records'] if 'records' in result else []
+
+        # Process items and add video paths
+        for item in food_items:
+            if 'Total_Ordered__c' not in item or item['Total_Ordered__c'] is None:
+                item['Total_Ordered__c'] = 0
+            item['Video1__c'] = get_valid_video_path(item['Name'], item.get('Video1__c'))
+
+        # Query to fetch Custom_Dish__c records
         custom_dish_query = """
-            SELECT Id, Name, Price__c, Description__c, Image1__c, Image2__c, 
-                   Veg_NonVeg__c, Section__c, Total_Ordered__c, Is_Available__c
+            SELECT Name, Price__c, Description__c, Image1__c, Image2__c, 
+                   Veg_NonVeg__c, Section__c, Total_Ordered__c
             FROM Custom_Dish__c
-            WHERE CreatedDate >= LAST_N_DAYS:7 AND Is_Available__c = true
+            WHERE CreatedDate >= LAST_N_DAYS:7
         """
-        custom_dish_result = sf_connection.query(custom_dish_query)
+        custom_dish_result = sf.query(custom_dish_query)
         custom_dishes = custom_dish_result.get('records', [])
+
+        # Process custom dishes and add video paths
+        for item in custom_dishes:
+            if 'Total_Ordered__c' not in item or item['Total_Ordered__c'] is None:
+                item['Total_Ordered__c'] = 0
+            item['Video1__c'] = get_valid_video_path(item['Name'])
+
+        # Merge both Menu_Item__c and Custom_Dish__c records
+        all_items = food_items + custom_dishes
+        ordered_menu = {section: [] for section in SECTION_ORDER}
+
+        # Process best sellers
+        best_sellers = sorted(all_items, key=lambda x: x.get("Total_Ordered__c", 0), reverse=True)
         
-        # Process and merge items
-        all_items = []
-        
-        for item in food_items + custom_dishes:
-            processed_item = {
-                'id': item.get('Id'),
-                'name': item.get('Name', 'Unnamed Item'),
-                'price': item.get('Price__c', 0),
-                'description': item.get('Description__c', 'No description available'),
-                'image1': get_valid_media_path(item.get('Image1__c'), 'image'),
-                'image2': get_valid_media_path(item.get('Image2__c'), 'image'),
-                'video': get_valid_media_path(item.get('Video1__c'), 'video'),
-                'veg_non_veg': item.get('Veg_NonVeg__c', 'Unknown'),
-                'section': item.get('Section__c', 'Others'),
-                'total_ordered': item.get('Total_Ordered__c', 0),
-                'is_available': item.get('Is_Available__c', True),
-                'spice_level': item.get('Spice_Level__c', 'Medium'),
-                'prep_time': item.get('Preparation_Time__c', 20)
-            }
-            
-            # Apply category filter
-            if selected_category == "Veg" and processed_item['veg_non_veg'] not in ["Veg", "both"]:
+        if selected_category == "Veg":
+            best_sellers = [item for item in best_sellers if item.get("Veg_NonVeg__c") in ["Veg", "both"]]
+        elif selected_category == "Non veg":
+            best_sellers = [item for item in best_sellers if item.get("Veg_NonVeg__c") in ["Non veg", "both"]]
+
+        best_sellers = best_sellers[:4]
+        if best_sellers:
+            ordered_menu["Best Sellers"] = best_sellers
+
+        # Organize other sections
+        added_item_names = set()
+        for item in all_items:
+            section = item.get("Section__c", "Others")
+            if section not in ordered_menu:
+                ordered_menu[section] = []
+
+            if item['Name'] in added_item_names:
+                continue
+
+            if selected_category == "Veg" and item.get("Veg_NonVeg__c") not in ["Veg", "both"]:
                 continue
-            if selected_category == "Non veg" and processed_item['veg_non_veg'] not in ["Non veg", "both"]:
+            if selected_category == "Non veg" and item.get("Veg_NonVeg__c") not in ["Non veg", "both"]:
                 continue
-                
-            all_items.append(processed_item)
-        
-        return all_items
-        
-    except Exception as e:
-        logger.error(f"Error fetching menu items: {str(e)}")
-        return []
 
-def organize_menu_items(items, selected_category):
-    """Organize menu items into sections"""
-    ordered_menu = {section: [] for section in SECTION_ORDER}
-    added_item_ids = set()
-    
-    # Process best sellers
-    best_sellers = sorted(
-        [item for item in items if item['total_ordered'] > 0],
-        key=lambda x: x['total_ordered'], 
-        reverse=True
-    )[:MAX_BEST_SELLERS]
-    
-    if best_sellers:
-        ordered_menu["Best Sellers"] = best_sellers
-        added_item_ids.update(item['id'] for item in best_sellers)
-    
-    # Organize other sections
-    for item in items:
-        if item['id'] in added_item_ids:
-            continue
-            
-        section = item['section']
-        if section not in ordered_menu:
-            section = "Others"  # Fallback section
-            
-        ordered_menu[section].append(item)
-        added_item_ids.add(item['id'])
-    
-    # Remove empty sections
-    return {section: items for section, items in ordered_menu.items() if items}
+            ordered_menu[section].append(item)
+            added_item_names.add(item['Name'])
 
-@menu_blueprint.route("/menu", methods=["GET"])
-def menu():
-    # Validate session
-    user_email, first_letter, redirect_response = validate_user_session()
-    if redirect_response:
-        return redirect_response
-    
-    selected_category = request.args.get("category", "All")
-    
-    try:
-        # Get user details
-        user_details = get_user_details(sf, user_email)
-        if not user_details:
-            return redirect(url_for('login'))
-        
-        # Get cart count
-        cart_item_count = get_cart_count(sf, user_email)
-        
-        # Fetch and organize menu items
-        all_items = fetch_menu_items(sf, selected_category)
-        ordered_menu = organize_menu_items(all_items, selected_category)
-        
-        # Prepare categories
+        ordered_menu = {section: items for section, items in ordered_menu.items() if items}
         categories = ["All", "Veg", "Non veg"]
-        
-        return render_template(
-            "menu.html",
-            ordered_menu=ordered_menu,
-            categories=categories,
-            selected_category=selected_category,
-            referral_code=user_details['referral_code'],
-            reward_points=user_details['reward_points'],
-            user_name=session.get('user_name'),
-            first_letter=first_letter,
-            cart_item_count=cart_item_count
-        )
-        
+
     except Exception as e:
-        logger.error(f"Error in menu route: {str(e)}")
-        # Fallback data
-        return render_template(
-            "menu.html",
-            ordered_menu={},
-            categories=["All", "Veg", "Non veg"],
-            selected_category=selected_category,
-            referral_code='N/A',
-            reward_points=0,
-            user_name=session.get('user_name'),
-            first_letter=first_letter,
-            cart_item_count=0,
-            error_message="We're experiencing technical difficulties. Please try again later."
-        )
+        print(f"Error fetching menu data: {str(e)}")
+        # Fallback data with video support
+        ordered_menu = {section: [] for section in SECTION_ORDER}
+        best_sellers = ["Chicken Biryani", "Paneer Butter Masala", "Veg Manchurian", "Prawn Fry"]
+        ordered_menu["Best Sellers"] = [{
+            "Name": name,
+            "Price__c": "12.99",
+            "Description__c": f"Popular {name}",
+            "Image1__c": "/static/placeholder.jpg",
+            "Video1__c": get_valid_video_path(name),
+            "Total_Ordered__c": 100,
+            "Veg_NonVeg__c": "Veg" if "Paneer" in name or "Veg" in name else "Non veg"
+        } for name in best_sellers]
+        
+        categories = ["All", "Veg", "Non veg"]
+        referral_code = 'N/A'
+        reward_points = 0
+        cart_item_count = 0
+
+    return render_template(
+        "menu.html",
+        ordered_menu=ordered_menu,
+        categories=categories,
+        selected_category=selected_category,
+        referral_code=referral_code,
+        reward_points=reward_points,
+        user_name=user_name,
+        first_letter=first_letter,
+        cart_item_count=cart_item_count
+    )
 
 @menu_blueprint.route('/api/addons', methods=['GET'])
 def get_addons():
+    item_name = request.args.get('item_name')  
+    item_section = request.args.get('item_section')  
+
+    if not item_name or not item_section:
+        return jsonify({"success": False, "error": "Item name and section are required."}), 400
+
     try:
-        item_name = request.args.get('item_name', '').strip()
-        item_section = request.args.get('item_section', '').strip()
-        
-        if not item_name or not item_section:
-            return jsonify({
-                "success": False, 
-                "error": "Item name and section are required."
-            }), 400
-        
-        # Query customization options
         query = f"""
-            SELECT Id, Name, Customization_Type__c, Options__c, 
-                   Max_Selections__c, Extra_Charge__c, Extra_Charge_Amount__c,
-                   Is_Active__c
+            SELECT Name, Customization_Type__c, Options__c, Max_Selections__c, Extra_Charge__c, Extra_Charge_Amount__c
             FROM Customization_Options__c
             WHERE Section__c = '{item_section}'
-            AND Is_Active__c = true
-            ORDER BY Display_Order__c NULLS LAST
         """
         result = sf.query(query)
         addons = result.get('records', [])
-        
+
         if not addons:
-            return jsonify({
-                "success": False, 
-                "error": "No customization options found."
-            }), 404
-        
-        # Format response
+            return jsonify({"success": False, "error": "No customization options found for the given section."}), 404
+
         formatted_addons = []
         for addon in addons:
             options = addon.get("Options__c", "")
-            options = [opt.strip() for opt in options.split(",")] if options else []
-            
+            if options:
+                options = options.split(", ")
+            else:
+                options = []
+
             formatted_addons.append({
-                "id": addon.get("Id"),
-                "name": addon.get("Name"),
-                "type": addon.get("Customization_Type__c", "checkbox"),
+                "name": addon["Name"],
+                "type": addon["Customization_Type__c"],
                 "options": options,
                 "max_selections": addon.get("Max_Selections__c", 1),
                 "extra_charge": addon.get("Extra_Charge__c", False),
-                "extra_charge_amount": float(addon.get("Extra_Charge_Amount__c", 0))
+                "extra_charge_amount": addon.get("Extra_Charge_Amount__c", 0)
             })
-        
-        return jsonify({
-            "success": True, 
-            "addons": formatted_addons
-        })
-        
+
+        return jsonify({"success": True, "addons": formatted_addons})
+
     except Exception as e:
-        logger.error(f"Error in get_addons: {str(e)}")
-        return jsonify({
-            "success": False, 
-            "error": "An error occurred while fetching options."
-        }), 500
+        print(f"Error fetching addons: {str(e)}")
+        return jsonify({"success": False, "error": "An error occurred while fetching customization options."}), 500
 
 @menu_blueprint.route('/cart/add', methods=['POST'])
 def add_to_cart():
     try:
-        # Validate session
-        if 'user_email' not in session:
-            return jsonify({
-                "success": False, 
-                "error": "Authentication required."
-            }), 401
-        
-        # Validate input
-        data = request.get_json()
-        if not data:
-            return jsonify({
-                "success": False, 
-                "error": "Invalid JSON data."
-            }), 400
-        
-        required_fields = ['itemName', 'itemPrice', 'itemImage', 'section']
-        for field in required_fields:
-            if field not in data or not data[field]:
-                return jsonify({
-                    "success": False, 
-                    "error": f"Missing required field: {field}"
-                }), 400
-        
-        # Prepare data
-        item_data = {
-            'name': data['itemName'].strip(),
-            'price': float(data['itemPrice']),
-            'image': data['itemImage'].strip(),
-            'section': data['section'].strip(),
-            'category': data.get('category', ''),
-            'addons': data.get('addons', []),
-            'instructions': data.get('instructions', '').strip(),
-            'quantity': int(data.get('quantity', 1)),
-            'customer_email': session['user_email']
-        }
-        
-        # Calculate addons
-        addons_price = sum(float(addon.get('price', 0)) for addon in item_data['addons'])
-        addons_string = "; ".join(
-            f"{addon.get('name', '')} (${addon.get('price', 0):.2f})" 
-            for addon in item_data['addons']
-        ) if item_data['addons'] else "None"
-        
-        total_price = (item_data['price'] * item_data['quantity']) + addons_price
-        
-        # Check if item already exists in cart
+        data = request.json
+        item_name = data.get('itemName', '').strip()
+        item_price = data.get('itemPrice')
+        item_image = data.get('itemImage')
+        addons = data.get('addons', [])
+        instructions = data.get('instructions', '')
+        category = data.get('category')
+        section = data.get('section')
+        quantity = data.get('quantity', 1)
+        customer_email = session.get('user_email')
+
+        if not item_name or not item_price:
+            return jsonify({"success": False, "error": "Item name and price are required."}), 400
+
+        if not customer_email:
+            return jsonify({"success": False, "error": "User email is required."}), 400
+
         query = f"""
             SELECT Id, Quantity__c, Add_Ons__c, Add_Ons_Price__c, Instructions__c 
             FROM Cart_Item__c
-            WHERE Customer_Email__c = '{item_data['customer_email']}'
-            AND Name = '{item_data['name']}'
-            LIMIT 1
+            WHERE Customer_Email__c = '{customer_email}' AND Name = '{item_name}'
         """
         result = sf.query(query)
-        existing_items = result.get('records', [])
-        
-        if existing_items:
-            # Update existing item
-            existing_item = existing_items[0]
-            new_quantity = existing_item['Quantity__c'] + item_data['quantity']
-            
-            # Merge addons
-            existing_addons = existing_item.get('Add_Ons__c', "None")
-            merged_addons = existing_addons if existing_addons == "None" else f"{existing_addons}; {addons_string}"
-            
-            # Merge instructions
-            existing_instructions = existing_item.get('Instructions__c', "")
-            merged_instructions = existing_instructions if not item_data['instructions'] else \
-                f"{existing_instructions} | {item_data['instructions']}".strip(" | ")
-            
-            # Update in Salesforce
-            sf.Cart_Item__c.update(existing_item['Id'], {
-                "Quantity__c": new_quantity,
-                "Add_Ons__c": merged_addons,
-                "Add_Ons_Price__c": addons_price + existing_item.get('Add_Ons_Price__c', 0),
-                "Instructions__c": merged_instructions,
-                "Price__c": total_price + existing_item.get('Price__c', 0)
+        cart_items = result.get("records", [])
+
+        addons_price = sum(addon['price'] for addon in addons)
+        new_addons = "; ".join([f"{addon['name']} (${addon['price']})" for addon in addons])
+
+        if cart_items:
+            cart_item_id = cart_items[0]['Id']
+            existing_quantity = cart_items[0]['Quantity__c']
+            existing_addons = cart_items[0].get('Add_Ons__c', "None")
+            existing_addons_price = cart_items[0].get('Add_Ons_Price__c', 0)
+            existing_instructions = cart_items[0].get('Instructions__c', "")
+
+            combined_addons = existing_addons if existing_addons != "None" else ""
+            if new_addons:
+                combined_addons = f"{combined_addons}; {new_addons}".strip("; ")
+
+            combined_instructions = existing_instructions
+            if instructions:
+                combined_instructions = f"{combined_instructions} | {instructions}".strip(" | ")
+
+            combined_addons_list = combined_addons.split("; ")
+            combined_addons_price = sum(
+                float(addon.split("($")[1][:-1]) for addon in combined_addons_list if "($" in addon
+            )
+
+            sf.Cart_Item__c.update(cart_item_id, {
+                "Quantity__c": existing_quantity + quantity,
+                "Add_Ons__c": combined_addons,
+                "Add_Ons_Price__c": combined_addons_price,
+                "Instructions__c": combined_instructions,
+                "Price__c": (existing_quantity + quantity) * item_price + combined_addons_price,
+                "Category__c": category,
+                "Section__c": section
             })
         else:
-            # Create new cart item
+            addons_string = "None"
+            if addons:
+                addons_string = new_addons
+
+            total_price = item_price * quantity + addons_price
+
             sf.Cart_Item__c.create({
-                "Name": item_data['name'],
+                "Name": item_name,
                 "Price__c": total_price,
-                "Base_Price__c": item_data['price'],
-                "Quantity__c": item_data['quantity'],
+                "Base_Price__c": item_price,
+                "Quantity__c": quantity,
                 "Add_Ons_Price__c": addons_price,
                 "Add_Ons__c": addons_string,
-                "Image1__c": item_data['image'],
-                "Customer_Email__c": item_data['customer_email'],
-                "Instructions__c": item_data['instructions'],
-                "Category__c": item_data['category'],
-                "Section__c": item_data['section']
+                "Image1__c": item_image,
+                "Customer_Email__c": customer_email,
+                "Instructions__c": instructions,
+                "Category__c": category,
+                "Section__c": section
             })
-        
-        return jsonify({
-            "success": True,
-            "message": "Item added to cart successfully."
-        })
-        
-    except ValueError as e:
-        logger.error(f"Value error in add_to_cart: {str(e)}")
-        return jsonify({
-            "success": False, 
-            "error": "Invalid price or quantity format."
-        }), 400
-        
+
+        return jsonify({"success": True, "message": "Item added to cart successfully."})
+
+    except KeyError as e:
+        return jsonify({"success": False, "error": f"Missing required field: {str(e)}"}), 400
+
     except Exception as e:
-        logger.error(f"Error in add_to_cart: {str(e)}")
-        return jsonify({
-            "success": False, 
-            "error": "An error occurred while adding to cart."
-        }), 500
+        print(f"Error adding item to cart: {str(e)}")
+        return jsonify({"success": False, "error": "An error occurred while adding the item to the cart."}), 500