Update menu.py

menu.py

@@ -1,38 +1,40 @@
 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_)
+from salesforce import get_salesforce_connection
+
+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')
+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()
+    with open(PLACEHOLDER_PATH, 'wb') as f:
+        f.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}"
+            return f"https://biryanihub-dev-ed.develop.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()
+        with open(PLACEHOLDER_PATH, 'wb') as f:
+            f.close()
         print(f"Created missing placeholder video at {PLACEHOLDER_PATH}")
     
     return f"/static/{PLACEHOLDER_VIDEO}"
@@ -42,11 +44,11 @@ def menu():
     selected_category = request.args.get("category", "All")
     user_email = session.get('user_email')
 
+    # Handle user authentication
     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:
@@ -58,105 +60,106 @@ def menu():
 
     try:
         # Fetch user referral and reward points
-        user_query = f"SELECT Referral_c, Reward_Pointsc FROM Customer_Loginc WHERE Email_c = '{user_email}'"
+        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']:
+        if not user_result.get('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_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']
+        cart_item_count = cart_count_result.get('totalSize', 0)
 
-        # Query to fetch Menu_Item_c records including Video1c, Ingredientsinfoc, NutritionalInfoc, Allergens_c
+        # Fetch all Menu_Item__c records
         menu_query = """
-            SELECT Name, Price_c, Descriptionc, Image1c, Image2_c, 
-                   Veg_NonVeg_c, Sectionc, Total_Orderedc, Video1_c, 
-                   Ingredientsinfo_c, NutritionalInfoc, Allergens_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 []
+        menu_result = sf.query_all(menu_query)  # Fetch all records
+        food_items = menu_result.get('records', [])
 
-        # Process items and add video paths, ingredients, nutritional info, and allergens
+        # Process menu items
         for item in food_items:
-            item['Ingredientsinfo_c'] = item.get('Ingredientsinfo_c', 'Not Available')
-            item['NutritionalInfo_c'] = item.get('NutritionalInfo_c', 'Not Available')
-            item['Allergens_c'] = item.get('Allergens_c', 'Not Available')
-            item['Video1_c'] = get_valid_video_path(item['Name'], item.get('Video1_c'))
-
-        # Query to fetch Custom_Dish__c records
+            item['Total_Ordered__c'] = item.get('Total_Ordered__c', 0) or 0
+            item['Video1__c'] = get_valid_video_path(item['Name'], item.get('Video1__c'))
+            item['Section__c'] = item.get('Section__c', "Others")
+            item['Description__c'] = item.get('Description__c', "No description available")
+            # Placeholder for missing fields until created in Salesforce
+            item['IngredientsInfo__c'] = item.get('IngredientsInfo__c', "Not specified")
+            item['NutritionalInfo__c'] = item.get('NutritionalInfo__c', "Not available")
+            item['Allergens__c'] = item.get('Allergens__c', "None listed")
+
+        # Fetch all Custom_Dish__c records
         custom_dish_query = """
-            SELECT Name, Price_c, Descriptionc, Image1c, Image2_c, 
-                   Veg_NonVeg_c, Sectionc, 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_dish_result = sf.query_all(custom_dish_query)
         custom_dishes = custom_dish_result.get('records', [])
 
-        # Process custom dishes and add video paths
+        # Process custom dishes
         for item in custom_dishes:
-            item['Ingredientsinfo__c'] = 'Custom Dish Ingredients'
-            item['NutritionalInfo__c'] = 'Custom Dish Nutritional Info'
-            item['Allergens__c'] = 'Custom Dish Allergens'
+            item['Total_Ordered__c'] = item.get('Total_Ordered__c', 0) or 0
             item['Video1__c'] = get_valid_video_path(item['Name'])
-
-        # Merge both Menu_Item_c and Custom_Dish_c records
+            item['Section__c'] = item.get('Section__c', "Customized dish")
+            item['Description__c'] = item.get('Description__c', "No description available")
+            # Placeholder for missing fields until created in Salesforce
+            item['IngredientsInfo__c'] = item.get('IngredientsInfo__c', "Not specified")
+            item['NutritionalInfo__c'] = item.get('NutritionalInfo__c', "Not available")
+            item['Allergens__c'] = item.get('Allergens__c', "None listed")
+
+        # Merge all 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)
-        
+        best_sellers = sorted(all_items, key=lambda x: x['Total_Ordered__c'], 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]
 
-        best_sellers = best_sellers[:4]
-        if best_sellers:
-            ordered_menu["Best Sellers"] = best_sellers
-
-        # Organize other sections
+        # Organize items into sections
         added_item_names = set()
         for item in all_items:
-            section = item.get("Section__c", "Others")
+            section = item['Section__c']
             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"]:
+            veg_nonveg = item.get("Veg_NonVeg__c", "both")
+            if selected_category == "Veg" and veg_nonveg not in ["Veg", "both"]:
                 continue
-            if selected_category == "Non veg" and item.get("Veg_NonVeg__c") not in ["Non veg", "both"]:
+            if selected_category == "Non veg" and veg_nonveg not in ["Non veg", "both"]:
                 continue
 
             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 fetching menu data: {str(e)}")
+        # Fallback data with all required fields
         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]
-        
+        best_sellers = [
+            {"Name": "Chicken Biryani", "Price__c": 12.99, "Description__c": "Spicy chicken with rice", "Image1__c": "/static/placeholder.jpg", "Video1__c": get_valid_video_path("Chicken Biryani"), "Total_Ordered__c": 100, "Veg_NonVeg__c": "Non veg", "Section__c": "Best Sellers", "IngredientsInfo__c": "Chicken, rice, spices", "NutritionalInfo__c": "600 cal, 30g protein", "Allergens__c": "None"},
+            {"Name": "Paneer Butter Masala", "Price__c": 11.99, "Description__c": "Creamy paneer curry", "Image1__c": "/static/placeholder.jpg", "Video1__c": get_valid_video_path("Paneer Butter Masala"), "Total_Ordered__c": 90, "Veg_NonVeg__c": "Veg", "Section__c": "Best Sellers", "IngredientsInfo__c": "Paneer, cream, tomatoes", "NutritionalInfo__c": "700 cal, 20g protein", "Allergens__c": "Dairy"},
+            {"Name": "Veg Manchurian", "Price__c": 9.99, "Description__c": "Indo-Chinese veggie dish", "Image1__c": "/static/placeholder.jpg", "Video1__c": get_valid_video_path("Veg Manchurian"), "Total_Ordered__c": 80, "Veg_NonVeg__c": "Veg", "Section__c": "Best Sellers", "IngredientsInfo__c": "Vegetables, soy sauce", "NutritionalInfo__c": "400 cal, 10g protein", "Allergens__c": "Soy"},
+            {"Name": "Prawn Fry", "Price__c": 14.99, "Description__c": "Crispy fried prawns", "Image1__c": "/static/placeholder.jpg", "Video1__c": get_valid_video_path("Prawn Fry"), "Total_Ordered__c": 70, "Veg_NonVeg__c": "Non veg", "Section__c": "Best Sellers", "IngredientsInfo__c": "Prawns, spices", "NutritionalInfo__c": "500 cal, 25g protein", "Allergens__c": "Shellfish"}
+        ]
+        ordered_menu["Best Sellers"] = best_sellers
         categories = ["All", "Veg", "Non veg"]
         referral_code = 'N/A'
         reward_points = 0
@@ -173,21 +176,22 @@ def menu():
         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')  
+    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, Optionsc, Max_Selectionsc, Extra_Chargec, Extra_Charge_Amount_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}'
         """
-        result = sf.query(query)
+        result = sf.query_all(query)
         addons = result.get('records', [])
 
         if not addons:
@@ -196,14 +200,10 @@ def get_addons():
         formatted_addons = []
         for addon in addons:
             options = addon.get("Options__c", "")
-            if options:
-                options = options.split(", ")
-            else:
-                options = []
-
+            options = options.split(", ") if options else []
             formatted_addons.append({
-                "name": addon["Name"],
-                "type": addon["Customization_Type__c"],
+                "name": addon.get("Name", ""),
+                "type": addon.get("Customization_Type__c", ""),
                 "options": options,
                 "max_selections": addon.get("Max_Selections__c", 1),
                 "extra_charge": addon.get("Extra_Charge__c", False),
@@ -221,41 +221,39 @@ def add_to_cart():
     try:
         data = request.json
         item_name = data.get('itemName', '').strip()
-        item_price = data.get('itemPrice')
-        item_image = data.get('itemImage')
+        item_price = float(data.get('itemPrice', 0))
+        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)
+        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:
-            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 not item_name or not item_price or not customer_email:
+            return jsonify({"success": False, "error": "Item name, price, and user email are required."}), 400
 
         query = f"""
-            SELECT Id, Quantity_c, Add_Onsc, Add_Ons_Pricec, Instructions_c 
+            SELECT Id, Quantity__c, Add_Ons__c, Add_Ons_Price__c, Instructions__c, 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])
+        addons_price = sum(float(addon.get('price', 0)) for addon in addons)
+        new_addons = "; ".join([f"{addon['name']} (${addon['price']})" for addon in addons]) if addons else "None"
 
         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', "")
+            cart_item = cart_items[0]
+            cart_item_id = cart_item['Id']
+            existing_quantity = int(cart_item.get('Quantity__c', 0))
+            existing_addons = cart_item.get('Add_Ons__c', "None")
+            existing_addons_price = float(cart_item.get('Add_Ons_Price__c', 0))
+            existing_instructions = cart_item.get('Instructions__c', "")
 
             combined_addons = existing_addons if existing_addons != "None" else ""
-            if new_addons:
+            if new_addons != "None":
                 combined_addons = f"{combined_addons}; {new_addons}".strip("; ")
 
             combined_instructions = existing_instructions
@@ -267,29 +265,26 @@ def add_to_cart():
                 float(addon.split("($")[1][:-1]) for addon in combined_addons_list if "($" in addon
             )
 
+            total_price = (existing_quantity + quantity) * item_price + combined_addons_price
+
             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,
+                "Price__c": total_price,
                 "Category__c": category,
                 "Section__c": section
             })
         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,
+                "Add_Ons__c": new_addons,
                 "Image1__c": item_image,
                 "Customer_Email__c": customer_email,
                 "Instructions__c": instructions,
@@ -299,9 +294,8 @@ def add_to_cart():
 
         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 ValueError as e:
+        return jsonify({"success": False, "error": f"Invalid data format: {str(e)}"}), 400
     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
+        return jsonify({"success": False, "error": "An error occurred while adding the item to the cart."}), 500