Update menu.py

menu.py

@@ -1,29 +1,35 @@
 from flask import Blueprint, render_template, request, session, jsonify, redirect, url_for
-from salesforce import get_salesforce_connection
 import os
+from salesforce import get_salesforce_connection  # Assuming this is your Salesforce connector
+import logging
+
+# Setup logging for debugging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
 
 menu_blueprint = Blueprint('menu', __name__)
 
 # Initialize Salesforce connection
-sf = get_salesforce_connection()
+try:
+    sf = get_salesforce_connection()
+except Exception as e:
+    logger.error(f"Failed to initialize Salesforce connection: {str(e)}")
+    sf = None
 
-# Constants for video handling
+# Constants
 STATIC_DIR = os.path.join(os.path.dirname(__file__), 'static')
 PLACEHOLDER_VIDEO = 'placeholder.mp4'
 PLACEHOLDER_PATH = os.path.join(STATIC_DIR, PLACEHOLDER_VIDEO)
 SECTION_ORDER = ["Best Sellers", "Starters", "Biryanis", "Curries", "Breads", "Customized dish", "Apetizer", "Desserts", "Soft Drinks"]
 
-# Create placeholder video at startup if it doesn't exist
+# Ensure static directory and placeholder exist
+os.makedirs(STATIC_DIR, exist_ok=True)
 if not os.path.exists(PLACEHOLDER_PATH):
-    os.makedirs(STATIC_DIR, exist_ok=True)  # Ensure static directory exists
     open(PLACEHOLDER_PATH, 'wb').close()
-    print(f"Created placeholder video at {PLACEHOLDER_PATH}")
+    logger.info(f"Created placeholder video at {PLACEHOLDER_PATH}")
 
 def get_valid_video_path(item_name, video_url=None):
-    """
-    Get valid video path for item with placeholder fallback
-    Priority: 1. Video1__c from Salesforce 2. placeholder.mp4
-    """
+    """Return a valid video URL with fallback to placeholder."""
     if video_url:
         if video_url.startswith(('http://', 'https://')):
             return video_url
@@ -31,11 +37,6 @@ def get_valid_video_path(item_name, video_url=None):
             return video_url
         elif video_url.startswith('069'):
             return f"https://yourdomain.my.salesforce.com/sfc/servlet.shepherd/version/download/{video_url}"
-    
-    if not os.path.exists(PLACEHOLDER_PATH):
-        open(PLACEHOLDER_PATH, 'wb').close()
-        print(f"Recreated missing placeholder video at {PLACEHOLDER_PATH}")
-    
     return f"/static/{PLACEHOLDER_VIDEO}"
 
 @menu_blueprint.route("/menu", methods=["GET", "POST"])
@@ -46,119 +47,125 @@ def menu():
     if not user_email:
         user_email = request.args.get("email")
         user_name = request.args.get("name")
-        if user_email:
+        if user_email and user_name:
             session['user_email'] = user_email
             session['user_name'] = user_name
         else:
+            logger.warning("No user email in session or args, redirecting to login")
             return redirect(url_for("login"))
     else:
         user_name = session.get('user_name')
 
     first_letter = user_name[0].upper() if user_name else "A"
-
-    try:
-        # 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)
-        if not user_result['records']:
-            return redirect(url_for('login'))
-        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
-        menu_query = """
-            SELECT Name, Price__c, Description__c, Image1__c, Image2__c, 
-                   Veg_NonVeg__c, Section__c, Total_Ordered__c, Video1__c,
-                   Ingredients__c, NutritionalInfo__c, Allergens__c
-            FROM Menu_Item__c
-        """
-        result = sf.query(menu_query)
-        food_items = result.get('records', [])
-
-        # Process menu items
-        for item in food_items:
-            item['Total_Ordered__c'] = item.get('Total_Ordered__c', 0)
-            item['Video1__c'] = get_valid_video_path(item['Name'], item.get('Video1__c'))
-            item['Ingredients__c'] = item.get('Ingredients__c', '')
-            item['NutritionalInfo__c'] = item.get('NutritionalInfo__c', '')
-            item['Allergens__c'] = item.get('Allergens__c', '')
-
-        # Query to fetch Custom_Dish__c records
-        custom_dish_query = """
-            SELECT Name, Price__c, Description__c, Image1__c, Image2__c, 
-                   Veg_NonVeg__c, Section__c, Total_Ordered__c,
-                   Ingredients__c, NutritionalInfo__c, Allergens__c
-            FROM Custom_Dish__c
-            WHERE CreatedDate >= LAST_N_DAYS:7
-        """
-        custom_dish_result = sf.query(custom_dish_query)
-        custom_dishes = custom_dish_result.get('records', [])
-
-        # Process custom dishes
-        for item in custom_dishes:
-            item['Total_Ordered__c'] = item.get('Total_Ordered__c', 0)
-            item['Video1__c'] = get_valid_video_path(item['Name'])
-            item['Ingredients__c'] = item.get('Ingredients__c', '')
-            item['NutritionalInfo__c'] = item.get('NutritionalInfo__c', '')
-            item['Allergens__c'] = item.get('Allergens__c', '')
-
-        # Merge items
-        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)
-        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 item.get("Veg_NonVeg__c") not in ["Non veg", "both"]:
-                continue
-            ordered_menu[section].append(item)
-            added_item_names.add(item['Name'])
-
-        ordered_menu = {k: v for k, v in ordered_menu.items() if v}
-        categories = ["All", "Veg", "Non veg"]
-
-    except Exception as e:
-        print(f"Error fetching menu data: {str(e)}")
-        ordered_menu = {section: [] for section in SECTION_ORDER}
+    ordered_menu = {section: [] for section in SECTION_ORDER}
+    categories = ["All", "Veg", "Non veg"]
+    referral_code = 'N/A'
+    reward_points = 0
+    cart_item_count = 0
+
+    if sf:
+        try:
+            # Fetch user data
+            user_query = f"SELECT Referral__c, Reward_Points__c FROM Customer_Login__c WHERE Email__c = '{user_email}'"
+            user_result = sf.query(user_query)
+            if not user_result.get('records'):
+                logger.warning(f"No user found for email: {user_email}")
+                return redirect(url_for('login'))
+            user_record = user_result['records'][0]
+            referral_code = user_record.get('Referral__c', 'N/A')
+            reward_points = user_record.get('Reward_Points__c', 0)
+
+            # Cart 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.get('totalSize', 0)
+
+            # Fetch Menu_Item__c
+            menu_query = """
+                SELECT Name, Price__c, Description__c, Image1__c, Image2__c, 
+                       Veg_NonVeg__c, Section__c, Total_Ordered__c, Video1__c,
+                       Ingredients__c, NutritionalInfo__c, Allergens__c
+                FROM Menu_Item__c
+            """
+            menu_result = sf.query(menu_query)
+            food_items = menu_result.get('records', [])
+            logger.debug(f"Fetched {len(food_items)} menu items")
+
+            # Process menu items
+            for item in food_items:
+                item['Total_Ordered__c'] = item.get('Total_Ordered__c', 0)
+                item['Video1__c'] = get_valid_video_path(item['Name'], item.get('Video1__c'))
+                item['Ingredients__c'] = item.get('Ingredients__c', '')
+                item['NutritionalInfo__c'] = item.get('NutritionalInfo__c', '')
+                item['Allergens__c'] = item.get('Allergens__c', '')
+
+            # Fetch Custom_Dish__c
+            custom_query = """
+                SELECT Name, Price__c, Description__c, Image1__c, Image2__c, 
+                       Veg_NonVeg__c, Section__c, Total_Ordered__c,
+                       Ingredients__c, NutritionalInfo__c, Allergens__c
+                FROM Custom_Dish__c
+                WHERE CreatedDate >= LAST_N_DAYS:7
+            """
+            custom_result = sf.query(custom_query)
+            custom_dishes = custom_result.get('records', [])
+            logger.debug(f"Fetched {len(custom_dishes)} custom dishes")
+
+            # Process custom dishes
+            for item in custom_dishes:
+                item['Total_Ordered__c'] = item.get('Total_Ordered__c', 0)
+                item['Video1__c'] = get_valid_video_path(item['Name'])
+                item['Ingredients__c'] = item.get('Ingredients__c', '')
+                item['NutritionalInfo__c'] = item.get('NutritionalInfo__c', '')
+                item['Allergens__c'] = item.get('Allergens__c', '')
+
+            # Combine and organize items
+            all_items = food_items + custom_dishes
+            best_sellers = sorted(all_items, key=lambda x: x.get("Total_Ordered__c", 0), reverse=True)
+            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"]]
+            ordered_menu["Best Sellers"] = best_sellers[:4]
+
+            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 item.get("Veg_NonVeg__c") not in ["Non veg", "both"]:
+                    continue
+                ordered_menu[section].append(item)
+                added_item_names.add(item['Name'])
+
+            ordered_menu = {k: v for k, v in ordered_menu.items() if v}
+            logger.debug(f"Final ordered_menu: {ordered_menu.keys()}")
+
+        except Exception as e:
+            logger.error(f"Error in menu processing: {str(e)}")
+
+    # Fallback data if Salesforce fails or no items
+    if not ordered_menu["Best Sellers"]:
+        logger.warning("No items fetched, using fallback data")
         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",
+            "Image2__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",
             "Ingredients__c": f"Sample ingredients for {name}",
             "NutritionalInfo__c": "Calories: 500, Protein: 20g",
-            "Allergens__c": "Contains nuts, dairy"
+            "Allergens__c": "Contains nuts, dairy",
+            "Section__c": "Best Sellers"
         } 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",
@@ -177,107 +184,72 @@ 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
+        return jsonify({"success": False, "error": "Item name and section required"}), 400
     try:
-        query = f"""
-            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}'
-        """
+        query = f"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}'"
         result = sf.query(query)
         addons = result.get('records', [])
-        if not addons:
-            return jsonify({"success": False, "error": "No customization options found."}), 404
-        formatted_addons = []
-        for addon in addons:
-            options = addon.get("Options__c", "").split(", ") if addon.get("Options__c") else []
-            formatted_addons.append({
-                "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": addon.get("Extra_Charge_Amount__c", 0)
-            })
+        formatted_addons = [{
+            "name": addon["Name"],
+            "type": addon.get("Customization_Type__c", ""),
+            "options": addon.get("Options__c", "").split(", ") if addon.get("Options__c") else [],
+            "max_selections": addon.get("Max_Selections__c", 1),
+            "extra_charge": addon.get("Extra_Charge__c", False),
+            "extra_charge_amount": addon.get("Extra_Charge_Amount__c", 0)
+        } for addon in addons]
         return jsonify({"success": True, "addons": formatted_addons})
     except Exception as e:
-        print(f"Error fetching addons: {str(e)}")
-        return jsonify({"success": False, "error": "An error occurred while fetching addons."}), 500
+        logger.error(f"Error fetching addons: {str(e)}")
+        return jsonify({"success": False, "error": "Failed to fetch addons"}), 500
 
 @menu_blueprint.route('/cart/add', methods=['POST'])
 def add_to_cart():
     try:
-        data = request.json
-        item_name = data.get('itemName', '').strip()
+        data = request.get_json()
+        item_name = data.get('itemName', '')
         item_price = float(data.get('itemPrice', 0))
-        item_image = data.get('itemImage')
+        item_image = data.get('itemImage', '/static/placeholder.jpg')
         addons = data.get('addons', [])
         instructions = data.get('instructions', '')
-        category = data.get('category')
-        section = data.get('section')
+        category = data.get('category', '')
+        section = data.get('section', '')
         quantity = int(data.get('quantity', 1))
         customer_email = session.get('user_email')
-        
-        if not item_name or not item_price or not customer_email:
-            return jsonify({"success": False, "error": "Missing required fields."}), 400
 
-        query = f"""
-            SELECT Id, Quantity__c, Add_Ons__c, Add_Ons_Price__c, Instructions__c 
-            FROM Cart_Item__c
-            WHERE Customer_Email__c = '{customer_email}' AND Name = '{item_name}'
-        """
-        result = sf.query(query)
-        cart_items = result.get("records", [])
+        if not item_name or not customer_email:
+            return jsonify({"success": False, "error": "Missing item name or user email"}), 400
 
         addons_price = sum(float(addon['price']) for addon in addons)
-        new_addons = "; ".join([f"{addon['name']} (${addon['price']})" for addon in addons]) if addons else "None"
+        addons_str = "; ".join([f"{addon['name']} (${addon['price']})" for addon in addons]) if addons else "None"
+        total_price = item_price * quantity + addons_price
 
-        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 and new_addons != "None":
-                combined_addons = f"{combined_addons}; {new_addons}".strip("; ")
-            combined_instructions = f"{existing_instructions} | {instructions}".strip(" | ") if instructions else existing_instructions
-            
-            combined_addons_list = combined_addons.split("; ")
-            combined_addons_price = sum(float(a.split("($")[1][:-1]) for a in combined_addons_list if "($" in a)
-            
-            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
+        query = f"SELECT Id, Quantity__c FROM Cart_Item__c WHERE Customer_Email__c = '{customer_email}' AND Name = '{item_name}'"
+        result = sf.query(query)
+        if result.get('records'):
+            cart_item = result['records'][0]
+            sf.Cart_Item__c.update(cart_item['Id'], {
+                "Quantity__c": cart_item['Quantity__c'] + quantity,
+                "Price__c": (cart_item['Quantity__c'] + quantity) * item_price + addons_price
             })
         else:
-            total_price = item_price * quantity + addons_price
             sf.Cart_Item__c.create({
                 "Name": item_name,
                 "Price__c": total_price,
                 "Base_Price__c": item_price,
                 "Quantity__c": quantity,
                 "Add_Ons_Price__c": addons_price,
-                "Add_Ons__c": new_addons,
+                "Add_Ons__c": addons_str,
                 "Image1__c": item_image,
                 "Customer_Email__c": customer_email,
                 "Instructions__c": instructions,
                 "Category__c": category,
                 "Section__c": section
             })
-        
+
         cart_query = f"SELECT Quantity__c FROM Cart_Item__c WHERE Customer_Email__c = '{customer_email}'"
         cart_result = sf.query(cart_query)
         cart = [{"quantity": item["Quantity__c"]} for item in cart_result.get("records", [])]
-        
-        return jsonify({"success": True, "message": "Item added to cart.", "cart": cart})
-
+        return jsonify({"success": True, "cart": cart})
     except Exception as e:
-        print(f"Error adding to cart: {str(e)}")
-        return jsonify({"success": False, "error": "Failed to add item to cart."}), 500
+        logger.error(f"Error adding to cart: {str(e)}")
+        return jsonify({"success": False, "error": "Failed to add to cart"}), 500