Update app.py

app.py

@@ -78,125 +78,154 @@ def login():
             return render_template("login.html", error=f"Error: {str(e)}")
 
     return render_template("login.html")
-
 @app.route("/menu", methods=["GET", "POST"])
 def menu():
     selected_category = request.args.get("category", "All")
     user_id = session.get('user_id')
-    print(f"Cookies on /menu: {request.cookies}")  # Debug: Check cookies sent
+    print(f"Cookies on /menu: {request.cookies}")
     print(f"Session check in /menu: user_id={user_id}")
-
+    
+    # Get the selected category from the query parameter, default is "All"
+    selected_category = request.args.get("category", "All")
+    print(f"Selected category: {selected_category}")
     if not user_id:
         print("Session missing, redirecting to login.")
         return redirect(url_for('login'))
     
+
     try:
-        query = "SELECT Name, Price__c, Image1__c, Image2__c, Category__c, Description__c FROM Menu_Item__c"
+        query = """
+            SELECT Name, Price__c, Description__c, Image1__c, Image2__c, Veg_NonVeg__c, Section__c 
+            FROM Menu_Item__c
+        """
+        # Query to fetch menu items
         result = sf.query(query)
+
+        # Fetch all food items from the query result
         food_items = result['records'] if 'records' in result else []
-        categories = {item['Category__c'] for item in food_items if 'Category__c' in item}
-        if selected_category != "All":
-            food_items = [item for item in food_items if item.get("Category__c") == selected_category]
+
+        # Dynamically determine categories based on the fetched data
+        categories = {item.get("Veg_NonVeg__c").capitalize() for item in food_items if item.get("Veg_NonVeg__c")}
+        categories = {"Veg", "Non-Veg"}  # Explicitly overwrite to ensure valid categories only
+
+        # Filter food items based on the selected category
+        if selected_category == "Veg":
+            food_items = [item for item in food_items if item.get("Veg_NonVeg__c") in ["Veg", "both"]]
+        elif selected_category == "Non-Veg":
+            food_items = [item for item in food_items if item.get("Veg_NonVeg__c") in ["Non veg", "both"]]
+
     except Exception as e:
         print(f"Error fetching menu data: {str(e)}")
         food_items = []
-        categories = []
-    return render_template("menu.html", food_items=food_items, categories=categories, selected_category=selected_category)
+        categories = {"All", "Veg", "Non-Veg"}  # Default categories on error
 
+    # Render the menu page with the filtered data
+    return render_template(
+        "menu.html",
+        food_items=food_items,
+        categories=sorted(categories),  # Sort categories alphabetically if needed
+        selected_category=selected_category,
 
+    )
 @app.route("/cart", methods=["GET"])
 def cart():
-    email = session.get('user_email') # Get logged-in user's email
+    email = session.get('user_email')  # Get logged-in user's email
     if not email:
-        return redirect(url_for("login")) # Redirect to login if not logged in
+        return redirect(url_for("login"))  # Redirect to login if not logged in
+
     try:
+        # Query cart items
         result = sf.query(f"""
             SELECT Name, Price__c, Quantity__c, Add_Ons__c, Image1__c
             FROM Cart_Item__c
             WHERE Customer_Email__c = '{email}'
         """)
         cart_items = result.get("records", [])
-        subtotal = sum(item['Quantity__c'] * item['Price__c'] for item in cart_items)
+
+        # Calculate the subtotal, including add-ons prices
+        subtotal = sum(item['Price__c'] * item['Quantity__c'] for item in cart_items)
+
+        # Ensure add-ons are processed properly
+        for item in cart_items:
+            item['Add_Ons__c'] = item.get('Add_Ons__c', "None")  # Default to "None" if no add-ons
+
     except Exception as e:
         print(f"Error fetching cart items: {e}")
         cart_items = []
         subtotal = 0
-        
-    return render_template("cart.html", cart_items=cart_items, subtotal=subtotal)
 
+    return render_template("cart.html", cart_items=cart_items, subtotal=subtotal)
 
 
 @app.route('/cart/add', methods=['POST'])
 def add_to_cart():
-    data = request.json
+    data = request.json  # Extract JSON payload
     item_name = data.get('itemName').strip()
-    item_price = data.get('itemPrice')
+    item_price = data.get('itemPrice')  # Base price of the item
     item_image = data.get('itemImage')
-    addons = data.get('addons', [])
-    customer_email = session.get('user_email')  # Get logged-in user's email from session
+    addons = data.get('addons', [])  # Extract add-ons array
+    customer_email = session.get('user_email')  # Get the logged-in user's email
 
     if not item_name or not item_price:
         return jsonify({"success": False, "error": "Item name and price are required."})
 
+    # Convert add-ons array to a formatted string and calculate the add-ons total price
+    addons_string = "None"
+    addons_total_price = 0
+    if addons:
+        addons_details = [f"{addon['name']} (${addon['price']})" for addon in addons]
+        addons_total_price = sum(addon['price'] for addon in addons)
+        addons_string = "; ".join(addons_details)
+
+    # Calculate the total price (item price + add-ons)
+    total_price = item_price + addons_total_price
+
     try:
-         # Check if the item already exists in the cart for this custpmer
-         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['totalSize'] > 0:
-            # Update quantity if the item exists
-            cart_item = result['records'][0]
-            sf.Cart_Item__c.update(cart_item['Id'], {
-                "Quantity__c": cart_item['Quantity__c'] + 1
-            })
-         else:
-             # Add a new item if it doesn't exist
-             sf.Cart_Item__c.create({
-                 "Name": item_name,
-            "Price__c": item_price,
-            "Quantity__c": 1,
-            "Add_Ons__c": ";".join(addons) if addons else None,
-            "Image1__c": item_image,
-            "Customer_Email__c": customer_email,  # Associate with the logged-in user
-                 
-             })
-             return jsonify({"success": True, "message": "Item added/updated successfully."})
+        # Save the cart item in Salesforce
+        sf.Cart_Item__c.create({
+            "Name": item_name,  # Item name
+            "Price__c": total_price,  # Total price (item + add-ons)
+            "Base_Price__c": item_price,  # Base price without add-ons
+            "Quantity__c": 1,  # Default quantity is 1
+            "Add_Ons__c": addons_string,  # Add-ons with name and price
+            "Image1__c": item_image,  # Item image URL
+            "Customer_Email__c": customer_email,  # Associated customer's email
+        })
+        return jsonify({"success": True, "message": "Item added to cart successfully."})
     except Exception as e:
+        print(f"Error adding item to cart: {str(e)}")
         return jsonify({"success": False, "error": str(e)})
 
+
+
 @app.route("/cart/add_item", methods=["POST"])
 def add_item_to_cart():
     data = request.json  # Extract JSON data from the request
     email = data.get('email')  # Customer email
     item_name = data.get('item_name')  # Item name
-    quantity = data.get('quantity', 0)  # Quantity to add (default is 1) // default value is 1
-
-    try:
-        # Check if the item already exists in the cart for this customer
-        cart_items = sf.query(
-            f"SELECT Id, Quantity__c FROM Cart_Item__c WHERE Customer_Email__c = '{email}' AND Item_Name__c = '{item_name}'"
-        )['records']
+    quantity = data.get('quantity', 1)  # Quantity to add (default is 1)
+    addons = data.get('addons', [])  # Add-ons for the item (optional)
 
-        if cart_items:
-            # If the item already exists, update its quantity
-            cart_item = cart_items[0]
-            new_quantity = cart_item['Quantity__c'] + quantity
-            sf.Cart_Item__c.update(cart_item['Id'], {"Quantity__c": new_quantity})
-            return jsonify({"success": True, "message": "Item quantity updated successfully."})
-        else:
-            # If the item does not exist, add it to the cart
-            sf.Cart_Item__c.create({
-                "Customer_Email__c": email,
-                "Item_Name__c": item_name,
-                "Quantity__c": quantity
-            })
+    # Validate inputs
+    if not email or not item_name:
+        return jsonify({"success": False, "error": "Email and item name are required."}), 400
 
-        return jsonify({"success": True, "message": "Item added/updated successfully."})
+    try:
+        # Add a new item to the cart with the provided details
+        sf.Cart_Item__c.create({
+            "Customer_Email__c": email,  # Associate the cart item with the customer's email
+            "Item_Name__c": item_name,  # Item name
+            "Quantity__c": quantity,  # Quantity to add
+            "Add_Ons__c": addons_string
+        })
+
+        return jsonify({"success": True, "message": "Item added to cart successfully."})
     except Exception as e:
+        print(f"Error adding item to cart: {str(e)}")  # Log the error for debugging
         return jsonify({"success": False, "error": str(e)}), 500
 
 
+
 @app.route('/cart/remove/<item_name>', methods=['POST'])
 def remove_cart_item(item_name):
     try:
@@ -219,18 +248,23 @@ def remove_cart_item(item_name):
 
 @app.route('/api/addons', methods=['GET'])
 def get_addons():
-    item_name = request.args.get('item_name')
+    item_name = request.args.get('item_name')  # Fetch the requested item name
     if not item_name:
         return jsonify({"success": False, "error": "Item name is required."})
 
     try:
-        query = f"SELECT Name, Price__c FROM Add_Ons__c"
+        # Fetch add-ons related to the item (update query as needed)
+        query = f"""
+            SELECT Name, Price__c 
+            FROM Add_Ons__c 
+        """
         addons = sf.query(query)['records']
         return jsonify({"success": True, "addons": addons})
     except Exception as e:
         print(f"Error fetching add-ons: {e}")
         return jsonify({"success": False, "error": "Unable to fetch add-ons. Please try again later."})
 
+
 @app.route("/cart/update_quantity", methods=["POST"])
 def update_quantity():
     data = request.json  # Extract JSON data from the request
@@ -269,16 +303,22 @@ def checkout():
     user_id = session.get('user_id')
     if not email or not user_id:
         return jsonify({"success": False, "message": "User not logged in"})
+
     try:
+        # Fetch cart items for the user
         result = sf.query(f"""
             SELECT Id, Name, Price__c, Quantity__c, Add_Ons__c
             FROM Cart_Item__c
             WHERE Customer_Email__c = '{email}'
         """)
-        cart_items = result["records"]
+        cart_items = result.get("records", [])
         if not cart_items:
             return jsonify({"success": False, "message": "Cart is empty"})
-        total_price = sum(item['Quantity__c'] * item['Price__c'] for item in cart_items)
+
+        # Calculate the total price of the order
+        total_price = sum(item['Price__c'] * item['Quantity__c'] for item in cart_items)
+
+        # Create the order in Salesforce
         order_data = {
             "Customer_Name__c": user_id,
             "Customer_Email__c": email,
@@ -288,15 +328,19 @@ def checkout():
                 [f"{item['Name']} (Qty: {item['Quantity__c']})" for item in cart_items]
             ),
             "Add_Ons__c": "\n".join(
-                [f"{item['Add_Ons__c']}" if item['Add_Ons__c'] else "None" for item in cart_items]
+                [item['Add_Ons__c'] if item.get('Add_Ons__c') else "None" for item in cart_items]
             ),
         }
         sf.Order__c.create(order_data)
+
+        # Clear the cart after placing the order
         for item in cart_items:
             sf.Cart_Item__c.delete(item["Id"])
+
         return jsonify({"success": True, "message": "Order placed successfully!"})
     except Exception as e:
         return jsonify({"success": False, "error": str(e)})
 
+
 if __name__ == "__main__":
     app.run(debug=False, host="0.0.0.0", port=7860)