Update app.py

app.py

@@ -1,4 +1,5 @@
 from flask import Flask, render_template, request, jsonify, redirect, url_for, session
+from flask import Flask, request, session, redirect, url_for, render_template
 from flask_session import Session  # Import the Session class
 from flask.sessions import SecureCookieSessionInterface  # Import the class
 from salesforce import get_salesforce_connection
@@ -7,6 +8,7 @@ from simple_salesforce import Salesforce
 
 import salesforce_api as sf
 
+
 # Initialize Flask app and Salesforce connection
 print("Starting app...")
 app = Flask(__name__)
@@ -120,15 +122,26 @@ def order_history():
     except Exception as e:
         print(f"Error fetching order history: {str(e)}")
         return render_template("order_history.html", orders=[], error=str(e))
+from flask import session, redirect, request, url_for, make_response
 
 @app.route("/logout")
 def logout():
-    session.clear()  # Clear the session
-    session.modified = True  # Explicitly mark session as modified
-    # Optionally, delete the session cookie explicitly
+    # Clear session variables
+    session.pop('name', None)
+    session.pop('email', None)
+    session.pop('rewardPoints', None)
+    session.pop('coupon', None)
+
+    # Create the redirect response
     response = redirect("https://biryanihub-dev-ed.develop.my.salesforce-sites.com/PublicLogin")
-    response.delete_cookie('session')  # Adjust this depending on the session cookie name
-    return response  # Redirect to Salesforce login page
+
+    # Add headers to prevent caching (optional, but helpful)
+    response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
+    response.headers['Pragma'] = 'no-cache'
+    response.headers['Expires'] = '0'
+
+    # Return the response with the added headers
+    return response
 
 @app.route("/signup", methods=["GET", "POST"])
 def signup():
@@ -209,6 +222,8 @@ def signup():
     return render_template("signup.html")
 
 
+
+
 @app.route("/login", methods=["GET", "POST"])
 def login():
     if request.method == "POST":
@@ -284,3 +299,478 @@ def login():
             return render_template("login.html", error=f"Error: {str(e)}")
 
     return render_template("login.html")
+
+
+    return render_template("menu.html", user_name=user_name)
+@app.route("/menu", methods=["GET", "POST"])
+def menu():
+    selected_category = request.args.get("category", "All")
+    user_id = session.get('user_id')
+    user_email = session.get('user_email')  # Fetch the user's email
+    print(f"Session check in /menu: user_id={user_id}, user_email={user_email}")
+    
+    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  # If needed
+
+            print(f"✅ User session set: {user_email}, {user_name}")
+        else:
+            print("❌ No email in URL, redirecting to login.")
+            return redirect(url_for("login"))
+
+    print(f"Session check in /menu: user_email={user_email}")
+
+    
+    try:
+        # Fetch the user's Referral__c and Reward_Points__c
+        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']:
+            print("❌ User not found!")
+            return redirect(url_for('login'))
+
+        referral_code = user_result['records'][0].get('Referral__c', 'N/A')  # Default to 'N/A' if empty
+        reward_points = user_result['records'][0].get('Reward_Points__c', 0)  # Default to 0 if empty
+
+        # Query to fetch menu items
+        menu_query = """
+            SELECT Name, Price__c, Description__c, Image1__c, Image2__c, Veg_NonVeg__c, Section__c 
+            FROM Menu_Item__c
+        """
+        result = sf.query(menu_query)
+        food_items = result['records'] if 'records' in result else []
+
+        # Extract valid categories dynamically
+        valid_categories = {"All", "Veg", "Non-Veg"}  # Ensuring consistency
+        extracted_categories = {item.get("Veg_NonVeg__c", "").strip().capitalize() for item in food_items if item.get("Veg_NonVeg__c")}
+        
+        # Ensure "Non-Veg" is included correctly
+        cleaned_categories = {"Veg" if cat.lower() == "veg" else "Non-Veg" if "non" in cat.lower() else cat for cat in extracted_categories}
+        categories = valid_categories.intersection(cleaned_categories)  # Keep only expected categories
+
+        # Filtering logic
+        if selected_category == "Veg":
+            food_items = [item for item in food_items if item.get("Veg_NonVeg__c", "").lower() == "veg"]
+        elif selected_category == "Non-Veg":
+            food_items = [item for item in food_items if "non" in item.get("Veg_NonVeg__c", "").lower()]
+
+        # "All" does not filter anything, it shows everything by default
+
+    except Exception as e:
+        print(f"❌ Error fetching menu data: {str(e)}")
+        food_items = []
+        categories = {"All", "Veg", "Non-Veg"}  # Default categories on error
+        referral_code = 'N/A'
+        reward_points = 0
+
+    # Render the menu page with the fetched data
+    return render_template(
+        "menu.html",
+        food_items=food_items,
+        categories=sorted(categories),  # Sort categories alphabetically if needed
+        selected_category=selected_category,
+        referral_code=referral_code,
+        reward_points=reward_points
+    )
+
+
+
+
+
+@app.route("/cart", methods=["GET"])
+def cart():
+    email = session.get('user_email')  # Get logged-in user's email
+    if not email:
+        return redirect(url_for("login"))
+
+    try:
+        # Query cart items
+        result = sf.query(f"""
+            SELECT Name, Price__c, Quantity__c, Add_Ons__c, Add_Ons_Price__c, Image1__c, Instructions__c
+            FROM Cart_Item__c
+            WHERE Customer_Email__c = '{email}'
+        """)
+        cart_items = result.get("records", [])
+
+        # Subtotal should be the sum of all item prices in the cart
+        subtotal = sum(item['Price__c'] for item in cart_items)
+
+        # Fetch reward points
+        customer_result = sf.query(f"""
+            SELECT Reward_Points__c 
+            FROM Customer_Login__c
+            WHERE Email__c = '{email}'
+        """)
+        reward_points = customer_result['records'][0].get('Reward_Points__c', 0) if customer_result['records'] else 0
+
+        # Fetch coupons for the user
+        coupon_result = sf.query(f"""
+            SELECT Coupon_Code__c FROM Referral_Coupon__c WHERE Referral_Email__c = '{email}'
+        """)
+
+        # Extract and split coupons into a list
+        if coupon_result["records"]:
+            raw_coupons = coupon_result["records"][0].get("Coupon_Code__c", "")
+            coupons = raw_coupons.split("\n") if raw_coupons else []
+        else:
+            coupons = []
+
+        return render_template(
+            "cart.html",
+            cart_items=cart_items,
+            subtotal=subtotal,
+            reward_points=reward_points,
+            customer_email=email,
+            coupons=coupons  # Send coupons to template
+        )
+
+    except Exception as e:
+        print(f"Error fetching cart items: {e}")
+        return render_template("cart.html", cart_items=[], subtotal=0, reward_points=0, coupons=[])
+
+
+
+@app.route('/cart/add', methods=['POST'])
+def add_to_cart():
+    data = request.json  # Extract JSON payload from frontend
+    item_name = data.get('itemName').strip()  # Item name
+    item_price = data.get('itemPrice')  # Base price of the item
+    item_image = data.get('itemImage')  # Item image
+    addons = data.get('addons', [])  # Add-ons array
+    instructions = data.get('instructions', '')  # Special instructions
+    customer_email = session.get('user_email')  # Get logged-in user's email
+
+    if not item_name or not item_price:
+        return jsonify({"success": False, "error": "Item name and price are required."})
+
+    try:
+        # Query the cart to check if the item already exists
+        query = f"""
+            SELECT Id, Quantity__c, Add_Ons__c, Add_Ons_Price__c, Instructions__c FROM Cart_Item__c
+            WHERE Customer_Email__c = '{customer_email}' AND Name = '{item_name}'
+        """
+        result = sf.query(query)
+        cart_items = result.get("records", [])
+
+        # Calculate the price of the new add-ons
+        addons_price = sum(addon['price'] for addon in addons)  # New add-ons price
+        new_addons = "; ".join([f"{addon['name']} (${addon['price']})" for addon in addons])  # Format new add-ons
+
+        if cart_items:
+            # If the item already exists in the cart, update it
+            cart_item_id = cart_items[0]['Id']
+            existing_quantity = cart_items[0]['Quantity__c']
+            existing_addons = cart_items[0].get('Add_Ons__c', "None")  # Previous add-ons
+            existing_addons_price = cart_items[0].get('Add_Ons_Price__c', 0)  # Previous add-ons price
+            existing_instructions = cart_items[0].get('Instructions__c', "")  # Previous instructions
+
+            # Combine the existing and new add-ons
+            combined_addons = existing_addons if existing_addons != "None" else ""
+            if new_addons:
+                combined_addons = f"{combined_addons}; {new_addons}".strip("; ")
+
+            # Combine the existing and new instructions
+            combined_instructions = existing_instructions
+            if instructions:
+                combined_instructions = f"{combined_instructions} | {instructions}".strip(" | ")
+
+            # Recalculate the total add-ons 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 item in the cart
+            sf.Cart_Item__c.update(cart_item_id, {
+                "Quantity__c": existing_quantity + 1,  # Increase quantity by 1
+                "Add_Ons__c": combined_addons,  # Update add-ons list
+                "Add_Ons_Price__c": combined_addons_price,  # Update add-ons price
+                "Instructions__c": combined_instructions,  # Update instructions
+                "Price__c": (existing_quantity + 1) * item_price + combined_addons_price,  # Update total price
+            })
+        else:
+            # If the item does not exist in the cart, create a new one
+            addons_string = "None"
+            if addons:
+                addons_string = new_addons  # Use the formatted add-ons string
+
+            total_price = item_price + addons_price  # Base price + add-ons price
+
+            # Create a new cart item
+            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_Price__c": addons_price,  # Total add-ons price
+                "Add_Ons__c": addons_string,  # Add-ons with names and prices
+                "Image1__c": item_image,  # Item image URL
+                "Customer_Email__c": customer_email,  # Associated customer's email
+                "Instructions__c": instructions  # Save instructions
+            })
+
+        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', 1)  # Quantity to add (default is 1)
+    addons = data.get('addons', [])  # Add-ons for the item (optional)
+
+    # Validate inputs
+    if not email or not item_name:
+        return jsonify({"success": False, "error": "Email and item name are required."}), 400
+
+    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:
+        customer_email = session.get('user_email')
+        if not customer_email:
+            return jsonify({'success': False, 'message': 'User email not found. Please log in again.'}), 400
+        query = f"""
+            SELECT Id FROM Cart_Item__c 
+            WHERE Customer_Email__c = '{customer_email}' AND Name = '{item_name}'
+        """
+        result = sf.query(query)
+        if result['totalSize'] == 0:
+            return jsonify({'success': False, 'message': 'Item not found in cart.'}), 400
+        cart_item_id = result['records'][0]['Id']
+        sf.Cart_Item__c.delete(cart_item_id)
+        return jsonify({'success': True, 'message': f"'{item_name}' removed successfully!"}), 200
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        return jsonify({'success': False, 'message': f"An error occurred: {str(e)}"}), 500
+
+@app.route('/api/addons', methods=['GET'])
+def get_addons():
+    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:
+        # 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
+    email = data.get('email')
+    item_name = data.get('item_name')
+    try:
+        # Convert quantity to an integer
+        quantity = int(data.get('quantity'))
+    except (ValueError, TypeError):
+        return jsonify({"success": False, "error": "Invalid quantity provided."}), 400
+
+    # Validate inputs
+    if not email or not item_name or quantity is None:
+        return jsonify({"success": False, "error": "Email, item name, and quantity are required."}), 400
+
+    try:
+        # Query the cart item in Salesforce
+        cart_items = sf.query(
+            f"SELECT Id, Quantity__c, Price__c, Base_Price__c, Add_Ons_Price__c FROM Cart_Item__c "
+            f"WHERE Customer_Email__c = '{email}' AND Name = '{item_name}'"
+        )['records']
+
+        if not cart_items:
+            return jsonify({"success": False, "error": "Cart item not found."}), 404
+
+        # Retrieve the first matching record
+        cart_item_id = cart_items[0]['Id']
+        base_price = cart_items[0]['Base_Price__c']
+        addons_price = cart_items[0].get('Add_Ons_Price__c', 0)
+
+        # Calculate the new item price
+        new_item_price = (base_price * quantity) + addons_price
+
+        # Update the record in Salesforce
+        sf.Cart_Item__c.update(cart_item_id, {
+            "Quantity__c": quantity,
+            "Price__c": new_item_price,  # Update base price
+        })
+
+        # Recalculate the subtotal for all items in the cart
+        cart_items = sf.query(f"""
+            SELECT Price__c, Add_Ons_Price__c 
+            FROM Cart_Item__c 
+            WHERE Customer_Email__c = '{email}'
+        """)['records']
+        new_subtotal = sum(item['Price__c'] for item in cart_items) 
+
+        # Return updated item price and subtotal
+        return jsonify({"success": True, "new_item_price": new_item_price, "subtotal": new_subtotal})
+        print(f"New item price: {new_item_price}, New subtotal: {new_subtotal}")
+        return jsonify({"success": True, "new_item_price": new_item_price, "subtotal": new_subtotal})
+
+    except Exception as e:
+        print(f"Error updating quantity: {str(e)}")
+        return jsonify({"success": False, "error": str(e)}), 500
+@app.route("/checkout", methods=["POST"])
+def checkout():
+    email = session.get('user_email')
+    user_id = session.get('user_name')
+
+    if not email or not user_id:
+        return jsonify({"success": False, "message": "User not logged in"})
+
+    try:
+        data = request.json
+        selected_coupon = data.get("selectedCoupon", "").strip()
+
+        # Fetch cart items
+        result = sf.query(f"""
+            SELECT Id, Name, Price__c, Add_Ons_Price__c, Quantity__c, Add_Ons__c, Instructions__c, Image1__c
+            FROM Cart_Item__c
+            WHERE Customer_Email__c = '{email}'
+        """)
+        cart_items = result.get("records", [])
+
+        if not cart_items:
+            return jsonify({"success": False, "message": "Cart is empty"})
+
+        total_price = sum(item['Price__c'] for item in cart_items)
+        discount = 0
+        # Fetch the user's existing coupons
+        coupon_query = sf.query(f"""
+            SELECT Id, Coupon_Code__c FROM Referral_Coupon__c WHERE Referral_Email__c = '{email}'
+        """)
+
+        has_coupons = bool(coupon_query["records"])  # Check if user has any coupons
+
+        if selected_coupon:
+            # Case 3: User selected a valid coupon → Apply discount & remove coupon
+            discount = total_price * 0.10  # 10% discount
+            referral_coupon_id = coupon_query["records"][0]["Id"]
+            existing_coupons = coupon_query["records"][0]["Coupon_Code__c"].split("\n")
+
+            # Remove only the selected coupon
+            updated_coupons = [coupon for coupon in existing_coupons if coupon.strip() != selected_coupon]
+
+            # Convert list back to a string with newlines
+            updated_coupons_str = "\n".join(updated_coupons).strip()
+
+            # Update the Referral_Coupon__c record with the remaining coupons
+            sf.Referral_Coupon__c.update(referral_coupon_id, {
+                "Coupon_Code__c": updated_coupons_str
+            })
+        else:
+            # Case 1 & Case 2: User has no coupons or has coupons but didn’t select one → Add 10% to reward points
+            reward_points_to_add = total_price * 0.10
+
+            # Fetch current reward points
+            customer_record = sf.query(f"""
+                SELECT Id, Reward_Points__c FROM Customer_Login__c
+                WHERE Email__c = '{email}'
+            """)
+            customer = customer_record.get("records", [])[0] if customer_record else None
+
+            if customer:
+                current_reward_points = customer.get("Reward_Points__c") or 0
+                new_reward_points = current_reward_points + reward_points_to_add
+
+                print(f"Updating reward points: Current = {current_reward_points}, Adding = {reward_points_to_add}, New = {new_reward_points}")
+
+                # Update reward points in Salesforce
+                sf.Customer_Login__c.update(customer["Id"], {
+                    "Reward_Points__c": new_reward_points
+                })
+                print(f"Successfully updated reward points for {email}")
+
+        
+
+        total_bill = total_price - discount
+
+        # ✅ Store **all details** including Add-Ons, Instructions, Price, and Image
+        order_details = "\n".join(
+            f"{item['Name']} x{item['Quantity__c']} | Add-Ons: {item.get('Add_Ons__c', 'None')} | "
+            f"Instructions: {item.get('Instructions__c', 'None')} | "
+            f"Price: ${item['Price__c']} | Image: {item['Image1__c']}"
+            for item in cart_items
+        )
+
+        # Store the order details in Order__c
+        order_data = {
+            "Customer_Name__c": user_id,
+            "Customer_Email__c": email,
+            "Total_Amount__c": total_price,
+            "Discount__c": discount,
+            "Total_Bill__c": total_bill,
+            "Order_Status__c": "Pending",
+            "Order_Details__c": order_details  # ✅ Now includes **all details**
+        }
+
+        sf.Order__c.create(order_data)
+
+        # ✅ Delete cart items after order is placed
+        for item in cart_items:
+            sf.Cart_Item__c.delete(item["Id"])
+
+        return jsonify({"success": True, "message": "Order placed successfully!"})
+
+    except Exception as e:
+        print(f"Error during checkout: {str(e)}")
+        return jsonify({"success": False, "error": str(e)})
+
+@app.route("/order", methods=["GET"])
+def order_summary():
+    email = session.get('user_email')  # Fetch logged-in user's email
+    if not email:
+        return redirect(url_for("login"))
+
+    try:
+        # Fetch the most recent order for the user
+        result = sf.query(f"""
+            SELECT Id, Customer_Name__c, Customer_Email__c, Total_Amount__c, Order_Details__c, Order_Status__c, Discount__c, Total_Bill__c
+            FROM Order__c
+            WHERE Customer_Email__c = '{email}'
+            ORDER BY CreatedDate DESC
+            LIMIT 1
+        """)
+        order = result.get("records", [])[0] if result.get("records") else None
+
+        if not order:
+            return render_template("order.html", order=None)
+
+        return render_template("order.html", order=order)
+    except Exception as e:
+        print(f"Error fetching order details: {str(e)}")
+        return render_template("order.html", order=None, error=str(e))
+
+if __name__ == "__main__":
+    app.run(debug=True, host="0.0.0.0", port=7860)