Update menu.py

menu.py

@@ -7,181 +7,173 @@ menu_blueprint = Blueprint('menu', __name__)
 # Initialize Salesforce connection
 sf = get_salesforce_connection()
 
-# Constants
+# 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", "Appetizer", "Desserts", 
-    "Soft Drinks"
-]
+SECTION_ORDER = ["Best Sellers", "Starters", "Biryanis", "Curries", "Breads", "Customized dish", "Apetizer", "Desserts", "Soft Drinks"]
 
-# Create placeholder video if missing
+# 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):
-    """Handle video paths with proper fallback logic"""
+    """
+    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}"
 
-def get_available_fields():
-    """Check which custom fields exist in Salesforce"""
-    try:
-        desc = sf.Menu_Item__c.describe()
-        existing_fields = {field['name'] for field in desc['fields']}
-        
-        return {
-            'base': [
-                'Name', 'Price__c', 'Description__c', 'Image1__c', 'Image2__c',
-                'Veg_NonVeg__c', 'Section__c', 'Total_Ordered__c', 'Video1__c'
-            ],
-            'nutrition': [
-                f for f in ['IngredientsInfo__c', 'Nutritional_Info__c', 'Allergens__c'] 
-                if f in existing_fields
-            ]
-        }
-    except Exception as e:
-        print(f"Error checking Salesforce fields: {str(e)}")
-        return {
-            'base': ['Name', 'Price__c', 'Description__c', 'Image1__c', 'Veg_NonVeg__c', 'Section__c'],
-            'nutrition': []
-        }
-
 @menu_blueprint.route("/menu", methods=["GET", "POST"])
 def menu():
-    # Authentication and session handling
     selected_category = request.args.get("category", "All")
-    user_email = session.get('user_email') or request.args.get("email")
-    user_name = session.get('user_name') or request.args.get("name")
+    user_email = session.get('user_email')
 
     if not user_email:
-        return redirect(url_for("login"))
-    
-    if not session.get('user_email'):
-        session['user_email'] = user_email
-        session['user_name'] = user_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 redirect(url_for("login"))
+    else:
+        user_name = session.get('user_name')
 
     first_letter = user_name[0].upper() if user_name else "A"
 
     try:
-        # Check available fields in Salesforce
-        available_fields = get_available_fields()
-        all_fields = available_fields['base'] + available_fields['nutrition']
-        
-        # Fetch user data
-        user_data = sf.query(f"""
-            SELECT Referral__c, Reward_Points__c 
-            FROM Customer_Login__c 
-            WHERE Email__c = '{user_email}'
-        """).get('records', [{}])[0]
-        
-        if not user_data:
+        # 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_data.get('Referral__c', 'N/A')
-        reward_points = user_data.get('Reward_Points__c', 0)
-
-        # Get cart count
-        cart_item_count = sf.query(f"""
-            SELECT COUNT() 
-            FROM Cart_Item__c 
-            WHERE Customer_Email__c = '{user_email}'
-        """)['totalSize']
-
-        # Fetch menu items with available fields
-        menu_items = sf.query(f"""
-            SELECT {', '.join(all_fields)} 
-            FROM Menu_Item__c
-        """).get('records', [])
-
-        # Process items with nutrition data
-        for item in menu_items:
-            # Required fields
+        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']
+
+        # First try basic query with essential fields
+        base_fields = [
+            "Name", "Price__c", "Description__c", "Image1__c", "Image2__c",
+            "Veg_NonVeg__c", "Section__c", "Total_Ordered__c", "Video1__c"
+        ]
+        
+        # Try to include nutrition fields if they exist
+        try:
+            describe_result = sf.Menu_Item__c.describe()
+            available_fields = [field['name'] for field in describe_result['fields']]
+            
+            nutrition_fields = []
+            if 'IngredientsInfo__c' in available_fields:
+                nutrition_fields.append('IngredientsInfo__c')
+            if 'Nutritional_Info__c' in available_fields:
+                nutrition_fields.append('Nutritional_Info__c')
+            if 'Allergens__c' in available_fields:
+                nutrition_fields.append('Allergens__c')
+                
+            query_fields = base_fields + nutrition_fields
+        except Exception as e:
+            print(f"Error checking for nutrition fields: {str(e)}")
+            query_fields = base_fields
+
+        # Build and execute the query
+        menu_query = f"SELECT {', '.join(query_fields)} FROM Menu_Item__c"
+        result = sf.query(menu_query)
+        food_items = result['records'] if 'records' in result else []
+
+        # Process items with fallback values
+        for item in food_items:
+            # Ensure required fields have values
             item['Total_Ordered__c'] = item.get('Total_Ordered__c', 0)
             item['Video1__c'] = get_valid_video_path(item['Name'], item.get('Video1__c'))
             
-            # Nutrition fields with clear fallbacks
-            item['IngredientsInfo__c'] = item.get('IngredientsInfo__c', 
-                'Ingredients information not available' if 'IngredientsInfo__c' in available_fields['nutrition']
-                else 'Ingredients data not configured')
-                
-            item['Nutritional_Info__c'] = item.get('Nutritional_Info__c',
-                'Nutritional information not available' if 'Nutritional_Info__c' in available_fields['nutrition']
-                else 'Nutritional data not configured')
-                
-            item['Allergens__c'] = item.get('Allergens__c',
-                'Allergen information not available' if 'Allergens__c' in available_fields['nutrition']
-                else 'Allergen data not configured')
-
-        # Filter by category
-        category_filter = {
-            "Veg": ["Veg", "both"],
-            "Non veg": ["Non veg", "both"],
-            "All": ["Veg", "Non veg", "both"]
-        }.get(selected_category, ["Veg", "Non veg", "both"])
-
-        filtered_items = [
-            item for item in menu_items 
-            if item.get("Veg_NonVeg__c") in category_filter
-        ]
+            # Add fallback values for nutrition fields
+            item['IngredientsInfo__c'] = item.get('IngredientsInfo__c', 'Ingredients information not available')
+            item['Nutritional_Info__c'] = item.get('Nutritional_Info__c', 'Nutritional information not available')
+            item['Allergens__c'] = item.get('Allergens__c', 'Allergen information not available')
 
-        # Get best sellers (top 4 most ordered)
-        best_sellers = sorted(
-            filtered_items,
-            key=lambda x: x.get("Total_Ordered__c", 0),
-            reverse=True
-        )[:4]
+        # Process best sellers
+        best_sellers = sorted(food_items, key=lambda x: x.get("Total_Ordered__c", 0), reverse=True)
+        
+        # Apply category filter
+        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"]]
 
-        # Organize by sections
+        best_sellers = best_sellers[:4]
         ordered_menu = {section: [] for section in SECTION_ORDER}
+        
         if best_sellers:
             ordered_menu["Best Sellers"] = best_sellers
 
-        added_items = set()
-        for item in filtered_items:
+        # Organize items by section
+        added_item_names = set()
+        for item in food_items:
             section = item.get("Section__c", "Others")
-            if item['Name'] not in added_items:
-                ordered_menu.setdefault(section, []).append(item)
-                added_items.add(item['Name'])
+            if section not in ordered_menu:
+                ordered_menu[section] = []
+
+            if item['Name'] in added_item_names:
+                continue
+
+            # Apply category filter to all items
+            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
 
-        # Clean empty sections
-        ordered_menu = {k: v for k, v in ordered_menu.items() if v}
+            ordered_menu[section].append(item)
+            added_item_names.add(item['Name'])
+
+        # Remove empty sections
+        ordered_menu = {section: items for section, items in ordered_menu.items() if items}
+        categories = ["All", "Veg", "Non veg"]
 
     except Exception as e:
-        print(f"Error in menu route: {str(e)}")
-        # Comprehensive fallback data
-        ordered_menu = {
-            "Best Sellers": [
-                {
-                    "Name": "Chicken Biryani",
-                    "Price__c": 14.99,
-                    "Description__c": "Fragrant basmati rice with chicken and spices",
-                    "Image1__c": "/static/placeholder.jpg",
-                    "Veg_NonVeg__c": "Non veg",
-                    "IngredientsInfo__c": "Chicken, basmati rice, yogurt, spices",
-                    "Nutritional_Info__c": "Calories: 850, Protein: 45g",
-                    "Allergens__c": "Dairy (yogurt)"
-                },
-                {
-                    "Name": "Paneer Tikka",
-                    "Price__c": 12.99,
-                    "Description__c": "Grilled cottage cheese with spices",
-                    "Image1__c": "/static/placeholder.jpg",
-                    "Veg_NonVeg__c": "Veg",
-                    "IngredientsInfo__c": "Paneer, bell peppers, spices",
-                    "Nutritional_Info__c": "Calories: 420, Protein: 22g",
-                    "Allergens__c": "Dairy (paneer)"
-                }
-            ]
-        }
+        print(f"Error fetching menu data: {str(e)}")
+        # Fallback data
+        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",
+            "IngredientsInfo__c": "Ingredients information not available",
+            "Nutritional_Info__c": "Nutritional information not available",
+            "Allergens__c": "Allergen information not available"
+        } for name in best_sellers]
+        
+        categories = ["All", "Veg", "Non veg"]
         referral_code = 'N/A'
         reward_points = 0
         cart_item_count = 0
@@ -189,109 +181,144 @@ def menu():
     return render_template(
         "menu.html",
         ordered_menu=ordered_menu,
-        categories=["All", "Veg", "Non veg"],
+        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,
-        show_nutrition=bool(available_fields['nutrition'])
+        cart_item_count=cart_item_count
     )
 
 @menu_blueprint.route('/api/addons', methods=['GET'])
 def get_addons():
-    try:
-        item_section = request.args.get('item_section')
-        if not item_section:
-            return jsonify({"success": False, "error": "Section is required"}), 400
+    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
 
-        addons = sf.query(f"""
-            SELECT Name, Customization_Type__c, Options__c, 
-                   Max_Selections__c, Extra_Charge__c, Extra_Charge_Amount__c
+    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}'
-        """).get('records', [])
+        """
+        result = sf.query(query)
+        addons = result.get('records', [])
+
+        if not addons:
+            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", "")
+            if options:
+                options = options.split(", ")
+            else:
+                options = []
+
             formatted_addons.append({
                 "name": addon["Name"],
                 "type": addon["Customization_Type__c"],
-                "options": addon.get("Options__c", "").split(", ") if addon.get("Options__c") else [],
+                "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})
 
     except Exception as e:
         print(f"Error fetching addons: {str(e)}")
-        return jsonify({"success": False, "error": str(e)}), 500
+        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:
         data = request.json
-        required_fields = ['itemName', 'itemPrice', 'category', 'section']
-        if not all(field in data for field in required_fields):
-            return jsonify({"success": False, "error": "Missing required fields"}), 400
-
-        if not session.get('user_email'):
-            return jsonify({"success": False, "error": "Not authenticated"}), 401
-
-        # Prepare cart item data
-        cart_data = {
-            "Name": data['itemName'].strip(),
-            "Price__c": float(data['itemPrice']),
-            "Base_Price__c": float(data['itemPrice']),
-            "Quantity__c": int(data.get('quantity', 1)),
-            "Customer_Email__c": session['user_email'],
-            "Category__c": data['category'],
-            "Section__c": data['section'],
-            "Image1__c": data.get('itemImage'),
-            "Instructions__c": data.get('instructions', '')[:255]
-        }
-
-        # Handle addons
+        item_name = data.get('itemName', '').strip()
+        item_price = data.get('itemPrice')
+        item_image = data.get('itemImage')
         addons = data.get('addons', [])
-        if addons:
-            addons_price = sum(float(a['price']) for a in addons)
-            addons_str = "; ".join(f"{a['name']} (${a['price']})" for a in addons)
-            cart_data.update({
-                "Add_Ons__c": addons_str,
-                "Add_Ons_Price__c": addons_price,
-                "Price__c": float(data['itemPrice']) * int(data.get('quantity', 1)) + addons_price
-            })
+        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
 
-        # Check if item already in cart
-        existing = sf.query(f"""
-            SELECT Id, Quantity__c, Add_Ons__c, Add_Ons_Price__c
+        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 Name = '{cart_data["Name"]}' 
-            AND Customer_Email__c = '{session['user_email']}'
-        """).get('records', [])
-
-        if existing:
-            # Update existing item
-            existing = existing[0]
-            new_quantity = existing['Quantity__c'] + cart_data['Quantity__c']
-            new_addons = f"{existing.get('Add_Ons__c', '')}; {cart_data.get('Add_Ons__c', '')}".strip("; ")
-            new_addons_price = existing.get('Add_Ons_Price__c', 0) + cart_data.get('Add_Ons_Price__c', 0)
-            
-            sf.Cart_Item__c.update(existing['Id'], {
-                "Quantity__c": new_quantity,
-                "Add_Ons__c": new_addons,
-                "Add_Ons_Price__c": new_addons_price,
-                "Price__c": (cart_data['Base_Price__c'] * new_quantity) + new_addons_price
+            WHERE Customer_Email__c = '{customer_email}' AND Name = '{item_name}'
+        """
+        result = sf.query(query)
+        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
-            sf.Cart_Item__c.create(cart_data)
+            addons_string = "None"
+            if addons:
+                addons_string = new_addons
+
+            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": addons_string,
+                "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."})
 
-        return jsonify({"success": True, "message": "Added to cart"})
+    except KeyError as e:
+        return jsonify({"success": False, "error": f"Missing required field: {str(e)}"}), 400
 
     except Exception as e:
-        print(f"Error adding to cart: {str(e)}")
-        return jsonify({"success": False, "error": str(e)}), 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