Update menu.py

menu.py

@@ -1,11 +1,47 @@
-from flask import Blueprint, render_template, request, session, jsonify  # Added jsonify import
+from flask import Blueprint, render_template, request, session, jsonify, redirect, url_for
 from salesforce import get_salesforce_connection
+import os
 
 menu_blueprint = Blueprint('menu', __name__)
 
 # Initialize Salesforce connection
 sf = get_salesforce_connection()
 
+# Constants for video handling
+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
+if not os.path.exists(PLACEHOLDER_PATH):
+    open(PLACEHOLDER_PATH, 'wb').close()
+    print(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
+    """
+    # 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}"
+    
+    # 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 f"/static/{PLACEHOLDER_VIDEO}"
+
 @menu_blueprint.route("/menu", methods=["GET", "POST"])
 def menu():
     selected_category = request.args.get("category", "All")
@@ -17,13 +53,12 @@ def menu():
 
         if user_email:
             session['user_email'] = user_email
-            session['user_name'] = user_name  # Store name in session
+            session['user_name'] = user_name
         else:
             return redirect(url_for("login"))
     else:
-        user_name = session.get('user_name')  # Get name from session if it's already stored
+        user_name = session.get('user_name')
 
-    # Get the first letter of the user's name (make it uppercase for consistency)
     first_letter = user_name[0].upper() if user_name else "A"
 
     try:
@@ -37,87 +72,93 @@ def menu():
         referral_code = user_result['records'][0].get('Referral__c', 'N/A')
         reward_points = user_result['records'][0].get('Reward_Points__c', 0)
 
-        # Query to fetch Menu_Item__c records including Total_Ordered__c for best sellers
+        # Query to fetch Menu_Item__c records including Video1__c
         menu_query = """
-            SELECT Name, Price__c, Description__c, Image1__c, Image2__c, Veg_NonVeg__c, Section__c, Total_Ordered__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
         """
         result = sf.query(menu_query)
         food_items = result['records'] if 'records' in result else []
 
-        # Ensure Total_Ordered__c has a valid value
+        # 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  # Default value
+                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 created within the last 7 days with Total_Ordered__c > 10
+        # 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 
+            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
         """
         custom_dish_result = sf.query(custom_dish_query)
-        custom_dishes = custom_dish_result['records'] if 'records' in custom_dish_result else []
+        custom_dishes = custom_dish_result.get('records', [])
 
-        # Merge both Menu_Item__c and Custom_Dish__c records into the ordered menu
-        all_items = food_items + custom_dishes
+        # 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'])
 
-        # Define the order of sections, adding "Best Sellers" at the top
-        section_order = ["Best Sellers", "Starters", "Biryanis", "Curries", "Breads", "Customized dish", "Apetizer", "Desserts", "Soft Drinks"]
-        ordered_menu = {section: [] for section in section_order}
+        # Merge both Menu_Item__c and Custom_Dish__c records
+        all_items = food_items + custom_dishes
+        ordered_menu = {section: [] for section in SECTION_ORDER}
 
-        # Sort items by Total_Ordered__c in descending order and pick top 4 as best sellers
+        # 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"]]
 
-        # Take only the top 4 best sellers after filtering
         best_sellers = best_sellers[:4]
-
-        # Ensure "Best Sellers" is added only if there are items after filtering
         if best_sellers:
             ordered_menu["Best Sellers"] = best_sellers
 
-        # Create a set to track item names already added to prevent duplicates
+        # Organize other sections
         added_item_names = set()
-
-        # Filter and organize menu items based on category and section (to avoid duplicates)
         for item in all_items:
-            section = item.get("Section__c", "Others")  # Default to "Others" if missing
+            section = item.get("Section__c", "Others")
             if section not in ordered_menu:
                 ordered_menu[section] = []
 
-            # Skip item if it's already been added to avoid duplicates
             if item['Name'] in added_item_names:
                 continue
 
-            # Apply category filters
             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'])  # Add item to the set of added items
-            print(f"Added item to {section}: {item['Name']}")  # Debugging
+            added_item_names.add(item['Name'])
 
-        # Remove empty sections
         ordered_menu = {section: items for section, items in ordered_menu.items() if items}
-        print(f"Final ordered menu: {ordered_menu.keys()}")  # Debugging
-
         categories = ["All", "Veg", "Non veg"]
 
     except Exception as e:
         print(f"Error fetching menu data: {str(e)}")
-        ordered_menu = {}
+        # 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
 
-    # Pass the user's first letter (first_letter) to the template
     return render_template(
         "menu.html",
         ordered_menu=ordered_menu,
@@ -125,20 +166,19 @@ def menu():
         selected_category=selected_category,
         referral_code=referral_code,
         reward_points=reward_points,
-        user_name=user_name,  # Pass name to the template
-        first_letter=first_letter  # Pass first letter to the template
+        user_name=user_name,
+        first_letter=first_letter
     )
+
 @menu_blueprint.route('/api/addons', methods=['GET'])
 def get_addons():
     item_name = request.args.get('item_name')  
     item_section = request.args.get('item_section')  
 
-    # Check if both item_name and item_section are provided
     if not item_name or not item_section:
         return jsonify({"success": False, "error": "Item name and section are required."}), 400
 
     try:
-        # Fetch customization options from Salesforce based on the section
         query = f"""
             SELECT Name, Customization_Type__c, Options__c, Max_Selections__c, Extra_Charge__c, Extra_Charge_Amount__c
             FROM Customization_Options__c
@@ -147,19 +187,16 @@ def get_addons():
         result = sf.query(query)
         addons = result.get('records', [])
 
-        # Check if we found any addons
         if not addons:
             return jsonify({"success": False, "error": "No customization options found for the given section."}), 404
 
-        # Format data for frontend
         formatted_addons = []
         for addon in addons:
-            # Ensure 'Options__c' exists and is not None
             options = addon.get("Options__c", "")
-            if options:  # If options are available, split them
-                options = options.split(", ")  # Convert comma-separated options into a list
+            if options:
+                options = options.split(", ")
             else:
-                options = []  # If no options, default to an empty list
+                options = []
 
             formatted_addons.append({
                 "name": addon["Name"],
@@ -173,14 +210,12 @@ def get_addons():
         return jsonify({"success": True, "addons": formatted_addons})
 
     except Exception as e:
-        # Log the exception for debugging
-        app.logger.error(f"Error fetching addons: {str(e)}")
+        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:
-        # Get data from request
         data = request.json
         item_name = data.get('itemName', '').strip()
         item_price = data.get('itemPrice')
@@ -189,17 +224,15 @@ def add_to_cart():
         instructions = data.get('instructions', '')
         category = data.get('category')
         section = data.get('section')
-        quantity = data.get('quantity', 1)  # Get the quantity field from the request
+        quantity = data.get('quantity', 1)
         customer_email = session.get('user_email')
 
-        # Basic validation for required fields
         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 to check if the item is already in the cart
         query = f"""
             SELECT Id, Quantity__c, Add_Ons__c, Add_Ons_Price__c, Instructions__c 
             FROM Cart_Item__c
@@ -208,11 +241,9 @@ def add_to_cart():
         result = sf.query(query)
         cart_items = result.get("records", [])
 
-        # Calculate the total price for the addons
         addons_price = sum(addon['price'] for addon in addons)
         new_addons = "; ".join([f"{addon['name']} (${addon['price']})" for addon in addons])
 
-        # If the item is already in the cart, update it
         if cart_items:
             cart_item_id = cart_items[0]['Id']
             existing_quantity = cart_items[0]['Quantity__c']
@@ -220,25 +251,21 @@ def add_to_cart():
             existing_addons_price = cart_items[0].get('Add_Ons_Price__c', 0)
             existing_instructions = cart_items[0].get('Instructions__c', "")
 
-            # Combine the new addons with the existing ones
             combined_addons = existing_addons if existing_addons != "None" else ""
             if new_addons:
                 combined_addons = f"{combined_addons}; {new_addons}".strip("; ")
 
-            # Combine existing instructions with new instructions
             combined_instructions = existing_instructions
             if instructions:
                 combined_instructions = f"{combined_instructions} | {instructions}".strip(" | ")
 
-            # Calculate total addons price
             combined_addons_list = combined_addons.split("; ")
             combined_addons_price = sum(
                 float(addon.split("($")[1][:-1]) for addon in combined_addons_list if "($" in addon
             )
 
-            # Update the cart item in Salesforce (updating quantity)
             sf.Cart_Item__c.update(cart_item_id, {
-                "Quantity__c": existing_quantity + quantity,  # Add the selected quantity
+                "Quantity__c": existing_quantity + quantity,
                 "Add_Ons__c": combined_addons,
                 "Add_Ons_Price__c": combined_addons_price,
                 "Instructions__c": combined_instructions,
@@ -247,19 +274,17 @@ def add_to_cart():
                 "Section__c": section
             })
         else:
-            # If the item is not already in the cart, create a new entry
             addons_string = "None"
             if addons:
                 addons_string = new_addons
 
-            total_price = item_price * quantity + addons_price  # Multiply by the quantity
+            total_price = item_price * quantity + addons_price
 
-            # Create new cart item in Salesforce
             sf.Cart_Item__c.create({
                 "Name": item_name,
                 "Price__c": total_price,
                 "Base_Price__c": item_price,
-                "Quantity__c": quantity,  # Use the selected quantity
+                "Quantity__c": quantity,
                 "Add_Ons_Price__c": addons_price,
                 "Add_Ons__c": addons_string,
                 "Image1__c": item_image,
@@ -272,14 +297,8 @@ def add_to_cart():
         return jsonify({"success": True, "message": "Item added to cart successfully."})
 
     except KeyError as e:
-        # Handle missing expected keys in request data
         return jsonify({"success": False, "error": f"Missing required field: {str(e)}"}), 400
 
     except Exception as e:
-        # Log the error for debugging and return a general error message
         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
-
-
-
-
+        return jsonify({"success": False, "error": "An error occurred while adding the item to the cart."}), 500