Update menu.py

menu.py

@@ -7,173 +7,181 @@ menu_blueprint = Blueprint('menu', __name__)
 # Initialize Salesforce connection
 sf = get_salesforce_connection()
 
-# 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"]
+SECTION_ORDER = [
+    "Best Sellers", "Starters", "Biryanis", "Curries", 
+    "Breads", "Customized dish", "Appetizer", "Desserts", 
+    "Soft Drinks"
+]
 
-# Create placeholder video at startup if it doesn't exist
+# Create placeholder video if missing
 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
+    """Handle video paths with proper fallback logic"""
     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')
+    user_email = session.get('user_email') or request.args.get("email")
+    user_name = session.get('user_name') or request.args.get("name")
 
     if not user_email:
-        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')
+        return redirect(url_for("login"))
+    
+    if not session.get('user_email'):
+        session['user_email'] = user_email
+        session['user_name'] = 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']:
+        # 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:
             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']
-
-        # 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
+        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
             item['Total_Ordered__c'] = item.get('Total_Ordered__c', 0)
             item['Video1__c'] = get_valid_video_path(item['Name'], item.get('Video1__c'))
             
-            # 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')
+            # 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
+        ]
 
-        # 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"]]
+        # Get best sellers (top 4 most ordered)
+        best_sellers = sorted(
+            filtered_items,
+            key=lambda x: x.get("Total_Ordered__c", 0),
+            reverse=True
+        )[:4]
 
-        best_sellers = best_sellers[:4]
+        # Organize by sections
         ordered_menu = {section: [] for section in SECTION_ORDER}
-        
         if best_sellers:
             ordered_menu["Best Sellers"] = best_sellers
 
-        # Organize items by section
-        added_item_names = set()
-        for item in food_items:
+        added_items = set()
+        for item in filtered_items:
             section = item.get("Section__c", "Others")
-            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
+            if item['Name'] not in added_items:
+                ordered_menu.setdefault(section, []).append(item)
+                added_items.add(item['Name'])
 
-            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"]
+        # Clean empty sections
+        ordered_menu = {k: v for k, v in ordered_menu.items() if v}
 
     except Exception as e:
-        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"]
+        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)"
+                }
+            ]
+        }
         referral_code = 'N/A'
         reward_points = 0
         cart_item_count = 0
@@ -181,144 +189,109 @@ def menu():
     return render_template(
         "menu.html",
         ordered_menu=ordered_menu,
-        categories=categories,
+        categories=["All", "Veg", "Non veg"],
         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
+        cart_item_count=cart_item_count,
+        show_nutrition=bool(available_fields['nutrition'])
     )
 
 @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:
-        query = f"""
-            SELECT Name, Customization_Type__c, Options__c, Max_Selections__c, Extra_Charge__c, Extra_Charge_Amount__c
+        item_section = request.args.get('item_section')
+        if not item_section:
+            return jsonify({"success": False, "error": "Section is required"}), 400
+
+        addons = sf.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 for the given section."}), 404
+        """).get('records', [])
 
         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": options,
+                "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)
+                "extra_charge_amount": float(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": "An error occurred while fetching customization options."}), 500
+        return jsonify({"success": False, "error": str(e)}), 500
 
 @menu_blueprint.route('/cart/add', methods=['POST'])
 def add_to_cart():
     try:
         data = request.json
-        item_name = data.get('itemName', '').strip()
-        item_price = data.get('itemPrice')
-        item_image = data.get('itemImage')
+        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
         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
+        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
+            })
 
-        query = f"""
-            SELECT Id, Quantity__c, Add_Ons__c, Add_Ons_Price__c, Instructions__c 
+        # Check if item already in cart
+        existing = sf.query(f"""
+            SELECT Id, Quantity__c, Add_Ons__c, Add_Ons_Price__c
             FROM Cart_Item__c
-            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
+            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
             })
         else:
-            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."})
+            # Create new cart item
+            sf.Cart_Item__c.create(cart_data)
 
-    except KeyError as e:
-        return jsonify({"success": False, "error": f"Missing required field: {str(e)}"}), 400
+        return jsonify({"success": True, "message": "Added to cart"})
 
     except Exception as e:
-        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
+        print(f"Error adding to cart: {str(e)}")
+        return jsonify({"success": False, "error": str(e)}), 500