Create app.py

app.py

@@ -0,0 +1,1243 @@
+from flask import Flask, render_template, request, jsonify, redirect, url_for, session
+from flask_session import Session  # Import the Session class
+from flask.sessions import SecureCookieSessionInterface  # Import the class
+from salesforce import get_salesforce_connection
+from datetime import timedelta
+import os
+
+# Initialize Flask app and Salesforce connection
+print("Starting app...")
+app = Flask(__name__)
+print("Flask app initialized.")
+
+# Add debug logs in Salesforce connection setup
+sf = get_salesforce_connection()
+print("Salesforce connection established.")
+
+# Set the secret key to handle sessions securely
+app.secret_key = os.getenv("SECRET_KEY", "xEr0cwgsiatzrzaeFewYrVA1O")  # Replace with a secure key
+
+# Configure the session type
+app.config["SESSION_TYPE"] = "filesystem"  # Use filesystem for session storage
+#app.config["SESSION_COOKIE_NAME"] = "my_session"  # Optional: Change session cookie name
+app.config["SESSION_COOKIE_SECURE"] = True  # Ensure cookies are sent over HTTPS
+app.config["SESSION_COOKIE_SAMESITE"] = "None"  # Allow cross-site cookies
+
+# Initialize the session
+Session(app)  # Correctly initialize the Session object
+print("Session interface configured.")
+
+# Ensure secure session handling for environments like Hugging Face
+app.session_interface = SecureCookieSessionInterface()
+print("Session interface configured.")
+import random
+import string
+
+def generate_referral_code(length=8):
+    # Generates a random referral code with uppercase, lowercase letters, and digits
+    characters = string.ascii_letters + string.digits  # A-Z, a-z, 0-9
+    referral_code = ''.join(random.choice(characters) for _ in range(length))
+    return referral_code
+
+@app.route("/")
+def home():
+    # Fetch user details from URL parameters
+    user_email = request.args.get("email")
+    user_name = request.args.get("name")
+    table_number = request.args.get("table")  # Capture table number
+
+    if user_email and user_name:
+        session["user_email"] = user_email
+        session["user_name"] = user_name
+        session["table_number"] = table_number  # Store table number in session
+        print(f"User logged in: {user_email} - {user_name} - Table: {table_number}")
+
+        # Ensure session is saved before redirecting
+        session.modified = True
+        return redirect(url_for("menu"))  # Redirect to menu directly
+
+    return render_template("index.html")
+
+
+
+from datetime import datetime
+
+def generate_coupon_code(length=10):
+    """Generates a random alphanumeric coupon code"""
+    characters = string.ascii_uppercase + string.digits  # A-Z, 0-9
+    return ''.join(random.choice(characters) for _ in range(length))
+@app.route("/generate_custom_dish", methods=["POST"])
+def generate_custom_dish():
+    try:
+        data = request.form
+        dish_name = data.get("name")
+        description = data.get("description")
+        item_image_url = "https://huggingface.co/spaces/nagasurendra/BiryaniHubflask30/resolve/main/static/customized.jpg"
+        item_image_url2 = "https://huggingface.co/spaces/nagasurendra/BiryaniHubflask30/resolve/main/static/customized1.jpg"
+
+        if not dish_name or not description:
+            return jsonify({"success": False, "error": "Both fields are required"}), 400
+
+        # Generate a random price for the custom dish
+        price = random.randint(10, 30)  # Example logic for price setting
+
+        # Determine Veg/Non-Veg
+        veg_keywords = ["paneer", "vegetable", "mushroom", "cheese"]
+        non_veg_keywords = ["chicken", "mutton", "fish", "egg"]
+        
+        category = "Veg" if any(word in description.lower() for word in veg_keywords) else \
+                   "Non veg" if any(word in description.lower() for word in non_veg_keywords) else \
+                   "both"
+
+        # Query to check if the dish already exists in Salesforce (Custom_Dish__c object)
+        existing_dish_query = f"SELECT Id, Name, Price__c, Image1__c, Image2__c, Description__c, Veg_NonVeg__c FROM Custom_Dish__c WHERE Name = '{dish_name}'"
+        existing_dish_result = sf.query(existing_dish_query)
+
+        if existing_dish_result['totalSize'] > 0:
+            # If the dish exists, use the existing details
+            existing_dish = existing_dish_result['records'][0]
+            price = existing_dish['Price__c']
+            item_image_url = existing_dish['Image1__c']
+            item_image_url2 = existing_dish['Image2__c']
+            category = existing_dish['Veg_NonVeg__c']
+        else:
+            # If the dish does not exist, create a new custom dish
+            custom_dish = {
+                'Name': dish_name,
+                'Price__c': price,
+                'Image1__c': item_image_url,
+                'Image2__c': item_image_url2,
+                'Description__c': description,
+                'Veg_NonVeg__c': category,
+                'Section__c': 'Customized dish',
+                'Total_Ordered__c': 0
+            }
+
+            # Insert the custom dish into Salesforce (Custom_Dish__c object)
+            result = sf.Custom_Dish__c.create(custom_dish)
+
+            if not result.get('success'):
+                return jsonify({"success": False, "error": "Failed to create custom dish in Salesforce"}), 500
+
+        # After ensuring the dish exists, check if it's already in the Cart_Item__c
+        email = session.get('user_email')  # Assuming you have the user's email in session
+        
+        # Query to check if the custom dish already exists in the cart for the logged-in user
+        cart_item_query = f"SELECT Id, Quantity__c, Price__c, Base_Price__c FROM Cart_Item__c WHERE Customer_Email__c = '{email}' AND Name = '{dish_name}'"
+        cart_item_result = sf.query(cart_item_query)
+
+        if cart_item_result['totalSize'] > 0:
+            # If the custom dish is already in the cart, update the quantity and price
+            cart_item = cart_item_result['records'][0]
+            new_quantity = cart_item['Quantity__c'] + 1  # Increase quantity by 1
+            new_price = price * new_quantity  # Update price based on new quantity
+            
+            # Update the cart item in Salesforce
+            updated_cart_item = {
+                'Quantity__c': new_quantity,
+                'Price__c': new_price
+            }
+            
+            cart_item_update = sf.Cart_Item__c.update(cart_item['Id'], updated_cart_item)
+
+        else:
+            # If the custom dish is not in the cart, create a new cart item
+            cart_item = {
+                'Name': dish_name,
+                'Price__c': price,
+                'Base_Price__c': price,
+                'Image1__c': item_image_url,
+                'Quantity__c': 1,  # Default quantity is 1
+                'Add_Ons__c': '',  # Set Add_ons__c to empty
+                'Add_Ons_Price__c': 0,  # Set Add_ons_Price__c to 0
+                'Customer_Email__c': email  # Associate the custom dish with the logged-in user
+            }
+
+            # Insert the custom dish as a Cart_Item__c record in Salesforce
+            cart_result = sf.Cart_Item__c.create(cart_item)
+
+        # Redirect to the cart page after successfully adding or updating the cart item
+        return redirect(url_for("cart"))
+
+    except Exception as e:
+        return jsonify({"success": False, "error": str(e)}), 500
+
+@app.route("/customer_details", methods=["GET"])
+def customer_details():
+    email = session.get('user_email')  # Get logged-in user's email
+    if not email:
+        return redirect(url_for("login"))
+
+    try:
+        # Fetch customer details from Salesforce based on the email
+        customer_record = sf.query(f"""
+            SELECT Id, Name, Email__c, Phone_Number__c, Referral__c, Reward_Points__c
+            FROM Customer_Login__c
+            WHERE Email__c = '{email}'
+            LIMIT 1
+        """)
+
+        if not customer_record.get("records"):
+            flash("Customer not found", "danger")
+            return redirect(url_for("login"))
+
+        customer = customer_record["records"][0]
+
+        # Prepare the data to return to the frontend
+        customer_data = {
+            "name": customer.get("Name", ""),
+            "email": customer.get("Email__c", ""),
+            "phone": customer.get("Phone_Number__c", ""),
+            "referral_code": customer.get("Referral__c", ""),
+            "reward_points": customer.get("Reward_Points__c", 0)
+        }
+
+        return render_template("customer_details.html", customer=customer_data)
+
+    except Exception as e:
+        flash(f"Error fetching customer details: {str(e)}", "danger")
+        return redirect(url_for("login"))
+
+@app.route("/update_profile", methods=["POST"])
+def update_profile():
+    email = session.get('user_email')  # Get logged-in user's email
+    if not email:
+        return jsonify({'status': 'error', 'message': 'User not logged in'})
+
+    try:
+        # Fetch user details from Salesforce
+        result = sf.query(f"""
+            SELECT Id, Name, Email__c, Phone_Number__c, Referral__c, Reward_Points__c
+            FROM Customer_Login__c
+            WHERE Email__c = '{email}'
+        """)
+
+        if not result['records']:
+            return jsonify({'status': 'error', 'message': 'User not found'})
+
+        user = result['records'][0]
+        user_id = user.get("Id")
+
+        # Get updated profile data from the form
+        new_name = request.form.get('customerName')
+        new_email = request.form.get('email')
+        new_phone = request.form.get('phone')
+        new_referral_code = request.form.get('referralCode')
+        new_reward_points = request.form.get('rewardPoints')
+
+        # Prepare data for Salesforce update
+        update_data = {
+            'Name': new_name,
+            'Email__c': new_email,
+            'Phone_Number__c': new_phone,
+            'Referral__c': new_referral_code,
+            'Reward_Points__c': new_reward_points
+        }
+
+        # Update Salesforce record
+        sf.Customer_Login__c.update(user_id, update_data)
+
+        return jsonify({
+            'status': 'success',
+            'message': 'Profile updated successfully!',
+            'data': update_data
+        })
+
+    except Exception as e:
+        return jsonify({'status': 'error', 'message': str(e)})
+
+
+
+from datetime import datetime
+import pytz  # Library to handle timezone conversions
+
+@app.route("/order-history", methods=["GET"])
+def order_history():
+    email = session.get('user_email')  # Get logged-in user's email
+    if not email:
+        return redirect(url_for("login"))
+
+    try:
+        # Fetch past orders 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, CreatedDate
+            FROM Order__c
+            WHERE Customer_Email__c = '{email}'
+            ORDER BY CreatedDate DESC
+        """)
+
+        print(f"Salesforce query result: {result}")  # Debugging line
+
+        orders = result.get("records", [])  # Fetch all orders
+
+        if not orders:
+            print("No orders found for this email.")  # Debugging line
+
+        # Format the order details for better readability
+        for order in orders:
+            order_details = order.get("Order_Details__c", "")
+            items = order_details.split("\n")  # Assuming each item is separated by a new line
+            formatted_items = []
+
+            # Loop through the items and format them as "item name * quantity"
+            for item in items:
+                item_details = item.split(" | ")
+                if len(item_details) > 1:
+                    name = item_details[0].strip()
+                    quantity = item_details[1].strip()
+                    formatted_items.append(f"{name} * {quantity}")
+
+            # Join the formatted items into a single string
+            order['formatted_items'] = ", ".join(formatted_items)
+
+            # Get the order date and time from CreatedDate
+            created_date = order.get("CreatedDate", "")
+            if created_date:
+                # Convert CreatedDate to datetime object in UTC
+                utc_datetime = datetime.strptime(created_date, '%Y-%m-%dT%H:%M:%S.000+0000')
+                utc_datetime = utc_datetime.replace(tzinfo=pytz.UTC)
+            
+                # Convert UTC datetime to the desired timezone (e.g., IST)
+                local_timezone = pytz.timezone('Asia/Kolkata')  # Replace with your timezone
+                local_datetime = utc_datetime.astimezone(local_timezone)
+
+                # Format the date and time in the desired format
+                order['formatted_date'] = local_datetime.strftime('%B %d, %I:%M %p')
+
+            order_status = order.get("Order_Status__c", "N/A")  # Default to "N/A" if no status
+            order['order_status'] = order_status
+
+
+        return render_template("order_history.html", orders=orders)
+
+    except Exception as e:
+        print(f"Error fetching order history: {str(e)}")
+        return render_template("order_history.html", orders=[], error=str(e))
+
+
+app.permanent_session_lifetime = timedelta(minutes=5)
+@app.before_request
+def check_session_timeout():
+    if "last_activity" in session:
+        last_activity_time = session["last_activity"]
+        now = datetime.now().timestamp()
+        
+        # Check if inactivity time has exceeded 5 minutes (300 seconds)
+        if now - last_activity_time > 300:
+            session.clear()  # Clear session
+            return redirect(url_for("logout"))
+    
+    # Update last activity timestamp on every request
+    session["last_activity"] = datetime.now().timestamp()
+
+@app.route("/dashboard")
+def dashboard():
+    return render_template("dashboard.html") 
+@app.route("/logout")
+def logout():
+    # Retrieve table number before clearing session
+    table_number = session.get('table_number', '')
+
+    # Clear session variables
+    session.pop('name', None)
+    session.pop('email', None)
+    session.pop('rewardPoints', None)
+    session.pop('coupon', None)
+
+    # Pass table number to redirect page
+    return render_template("redirect_page.html", table_number=table_number)
+
+@app.route("/signup", methods=["GET", "POST"])
+def signup():
+    if request.method == "POST":
+        name = request.form.get("name")
+        phone = request.form.get("phone")
+        email = request.form.get("email").strip()  # Trim spaces
+        password = request.form.get("password")
+        referral_code = request.form.get("referral")  # Fetch referral code from the form
+        generated_referral_code = generate_referral_code()
+
+        try:
+            ref = 0  # Default reward points for new user
+
+            # **Fix: Fetch all emails and compare in Python (Case-Insensitive)**
+            email_query = "SELECT Id, Email__c FROM Customer_Login__c"
+            email_result = sf.query(email_query)
+
+            # Convert all stored emails to lowercase and compare with user input
+            existing_emails = {record["Email__c"].lower() for record in email_result["records"]}
+            if email.lower() in existing_emails:
+                return render_template("signup.html", error="Email already in use! Please use a different email.")
+
+            # Check if a referral code is entered
+            if referral_code:
+                referral_query = f"SELECT Id, Email__c, Name FROM Customer_Login__c WHERE Referral__c = '{referral_code}'"
+                referral_result = sf.query(referral_query)
+
+                if not referral_result['records']:
+                    return render_template("signup.html", error="Invalid referral code!")
+
+                # Get referrer's details
+                referrer = referral_result['records'][0]
+                referrer_email = referrer.get('Email__c')
+                referrer_name = referrer.get('Name')
+
+                # Generate a new unique coupon code
+                new_coupon_code = generate_coupon_code()
+
+                # Check if referrer already has a record in Referral_Coupon__c
+                existing_coupon_query = f"SELECT Id, Coupon_Code__c FROM Referral_Coupon__c WHERE Referral_Email__c = '{referrer_email}'"
+                existing_coupon_result = sf.query(existing_coupon_query)
+
+                if existing_coupon_result['records']:
+                    referral_record = existing_coupon_result['records'][0]
+                    referral_id = referral_record['Id']
+                    existing_coupons = referral_record.get('Coupon_Code__c', '')
+
+                    updated_coupons = f"{existing_coupons}\n{new_coupon_code}".strip()
+
+                    # Update the existing record with the new coupon
+                    sf.Referral_Coupon__c.update(referral_id, {
+                        "Coupon_Code__c": updated_coupons
+                    })
+                else:
+                    # If no record exists, create a new one
+                    sf.Referral_Coupon__c.create({
+                        "Name": referrer_name,
+                        "Referral_Email__c": referrer_email,
+                        "Coupon_Code__c": new_coupon_code
+                    })
+
+            # **Fix: Ensure Salesforce enforces unique email constraint**
+            sf.Customer_Login__c.create({
+                "Name": name,
+                "Phone_Number__c": phone,
+                "Email__c": email,
+                "Password__c": password,
+                "Reward_Points__c": ref,  # No points added, only coupon is created
+                "Referral__c": generated_referral_code
+            })
+
+            return redirect(url_for("login"))
+
+        except Exception as e:
+            return render_template("signup.html", error=f"Error: {str(e)}")
+
+    return render_template("signup.html")
+
+
+
+
+@app.route("/login", methods=["GET", "POST"])
+def login():
+    if request.method == "POST":
+        email = request.form.get("email")
+        password = request.form.get("password")
+        print(f"Login attempt with email: {email}")  # Debug log
+
+        try:
+            # Fetch user details from Salesforce
+            query = f"SELECT Id, Name, Email__c, Reward_Points__c FROM Customer_Login__c WHERE Email__c='{email}' AND Password__c='{password}'"
+            result = sf.query(query)
+
+            if result["records"]:
+                user = result["records"][0]
+                session['user_id'] = user['Id']
+
+                # ✅ Always store or update session email
+                if 'user_email' not in session or session['user_email'] != email:
+                    session['user_email'] = email
+                    session['user_name'] = user.get("Name", "")
+                    print(f"✅ Session email updated: {session['user_email']}")
+
+                reward_points = user.get("Reward_Points__c") or 0
+
+                # Coupon generation logic (if reward points >= 500)
+                if reward_points >= 500:
+                    new_coupon_code = generate_coupon_code()
+                    coupon_query = sf.query(f"SELECT Id, Coupon_Code__c FROM Referral_Coupon__c WHERE Referral_Email__c = '{email}'")
+
+                    if coupon_query["records"]:
+                        coupon_record = coupon_query["records"][0]
+                        referral_coupon_id = coupon_record["Id"]
+                        existing_coupons = coupon_record.get("Coupon_Code__c", "")
+
+                        updated_coupons = f"{existing_coupons}\n{new_coupon_code}".strip()
+                        sf.Referral_Coupon__c.update(referral_coupon_id, {"Coupon_Code__c": updated_coupons})
+                    else:
+                        sf.Referral_Coupon__c.create({
+                            "Referral_Email__c": email,
+                            "Name": user.get("Name", ""),
+                            "Coupon_Code__c": new_coupon_code
+                        })
+
+                    new_reward_points = reward_points - 500
+                    sf.Customer_Login__c.update(user['Id'], {"Reward_Points__c": new_reward_points})
+
+                return redirect(url_for("menu"))
+
+            else:
+                print("Invalid credentials!")
+                return render_template("login.html", error="Invalid credentials!")
+
+        except Exception as e:
+            print(f"Error during login: {str(e)}")
+            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_email = session.get('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  # Store name in session
+        else:
+            return redirect(url_for("login"))
+    else:
+        user_name = session.get('user_name')  # Get name from session if it's already stored
+
+    # Get the first letter of the user's name (make it uppercase for consistency)
+    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']:
+            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)
+
+        # Query to fetch Menu_Item__c records including Total_Ordered__c for best sellers
+        menu_query = """
+            SELECT Name, Price__c, Description__c, Image1__c, Image2__c, Veg_NonVeg__c, Section__c, Total_Ordered__c 
+            FROM Menu_Item__c
+        """
+        result = sf.query(menu_query)
+        food_items = result['records'] if 'records' in result else []
+
+        # Ensure Total_Ordered__c has a valid value
+        for item in food_items:
+            if 'Total_Ordered__c' not in item or item['Total_Ordered__c'] is None:
+                item['Total_Ordered__c'] = 0  # Default value
+
+        # Query to fetch Custom_Dish__c records created within the last 7 days with Total_Ordered__c > 10
+        custom_dish_query = """
+            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_dishes = custom_dish_result['records'] if 'records' in custom_dish_result else []
+
+        # Merge both Menu_Item__c and Custom_Dish__c records into the ordered menu
+        all_items = food_items + custom_dishes
+
+        # Define the order of sections, adding "Best Sellers" at the top
+        section_order = ["Best Sellers", "Starters", "Biryanis", "Curries", "Breads", "Customized dish", "Apetizer", "Desserts", "Soft Drinks"]
+        ordered_menu = {section: [] for section in section_order}
+
+        # Sort items by Total_Ordered__c in descending order and pick top 4 as best sellers
+        best_sellers = sorted(all_items, key=lambda x: x.get("Total_Ordered__c", 0), 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"]]
+
+        # Take only the top 4 best sellers after filtering
+        best_sellers = best_sellers[:4]
+
+        # Ensure "Best Sellers" is added only if there are items after filtering
+        if best_sellers:
+            ordered_menu["Best Sellers"] = best_sellers
+
+        # Create a set to track item names already added to prevent duplicates
+        added_item_names = set()
+
+        # Filter and organize menu items based on category and section (to avoid duplicates)
+        for item in all_items:
+            section = item.get("Section__c", "Others")  # Default to "Others" if missing
+            if section not in ordered_menu:
+                ordered_menu[section] = []
+
+            # Skip item if it's already been added to avoid duplicates
+            if item['Name'] in added_item_names:
+                continue
+
+            # Apply category filters
+            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
+
+            ordered_menu[section].append(item)
+            added_item_names.add(item['Name'])  # Add item to the set of added items
+            print(f"Added item to {section}: {item['Name']}")  # Debugging
+
+        # Remove empty sections
+        ordered_menu = {section: items for section, items in ordered_menu.items() if items}
+        print(f"Final ordered menu: {ordered_menu.keys()}")  # Debugging
+
+        categories = ["All", "Veg", "Non veg"]
+
+    except Exception as e:
+        print(f"Error fetching menu data: {str(e)}")
+        ordered_menu = {}
+        categories = ["All", "Veg", "Non veg"]
+        referral_code = 'N/A'
+        reward_points = 0
+
+    # Pass the user's first letter (first_letter) to the template
+    return render_template(
+        "menu.html",
+        ordered_menu=ordered_menu,
+        categories=categories,
+        selected_category=selected_category,
+        referral_code=referral_code,
+        reward_points=reward_points,
+        user_name=user_name,  # Pass name to the template
+        first_letter=first_letter  # Pass first letter to the template
+    )
+
+
+@app.route("/cart", methods=["GET"])
+def cart():
+    email = session.get('user_email')
+    if not email:
+        return redirect(url_for("login"))
+
+    try:
+        # Fetch cart items with Category and Section
+        result = sf.query(f"""
+            SELECT Name, Price__c, Quantity__c, Add_Ons__c, Add_Ons_Price__c, Image1__c, Instructions__c, Category__c, Section__c
+            FROM Cart_Item__c
+            WHERE Customer_Email__c = '{email}'
+        """)
+        cart_items = result.get("records", [])
+
+        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}'
+        """)
+        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 = []
+
+        # Initialize suggestions as an empty list
+        suggestions = []
+
+        # If there are items in the cart, fetch suggestions
+        if cart_items:
+            # Get the category and section of the first item in the cart (You can choose which item you want to base suggestions on)
+            first_item = cart_items[0]
+            item_category = first_item.get('Category__c', 'All')  # Default to 'All' if not found
+            item_section = first_item.get('Section__c', 'Biryanis')  # Default to 'Biryanis' if not found
+
+            # Define section-to-complementary section mapping
+            complementary_sections = {
+                'Breads': ['Curries', 'Biryanis', 'Starters'],
+                'Biryanis': ['Curries', 'Starters', 'Desserts'],
+                'Curries': ['Biryanis', 'Breads', 'Starters'],
+                'Starters': ['Biryanis', 'Curries', 'Desserts'],
+                'Desserts': ['Biryanis', 'Curries', 'Soft Drinks'],
+                'Soft Drinks': ['Starters', 'Biryanis', 'Curries']
+            }
+
+            # Get the complementary sections for the selected section
+            suggested_sections = complementary_sections.get(item_section, [])
+
+            # Fetch suggestions from the complementary sections
+            try:
+                for suggested_section in suggested_sections:
+                    if item_category == "All":
+                        query = f"""
+                            SELECT Name, Price__c, Image1__c
+                            FROM Menu_Item__c
+                            WHERE Section__c = '{suggested_section}' 
+                            AND (Veg_NonVeg__c = 'Veg' OR Veg_NonVeg__c = 'Non veg')
+                            LIMIT 4
+                        """
+                    else:
+                        query = f"""
+                            SELECT Name, Price__c, Image1__c
+                            FROM Menu_Item__c
+                            WHERE Section__c = '{suggested_section}' 
+                            AND Veg_NonVeg__c = '{item_category}'
+                            LIMIT 4
+                        """
+                    suggestion_result = sf.query(query)
+                    suggestions.extend(suggestion_result.get("records", []))  # Add suggestions from each section
+
+                # Limit the number of suggestions to 4
+                if len(suggestions) > 4:
+                    suggestions = suggestions[:4]
+
+            except Exception as e:
+                print(f"Error fetching suggestions: {e}")
+
+        return render_template(
+            "cart.html",
+            cart_items=cart_items,
+            subtotal=subtotal,
+            reward_points=reward_points,
+            customer_email=email,
+            coupons=coupons,
+            suggestions=suggestions
+        )
+
+    except Exception as e:
+        print(f"Error fetching cart items: {e}")
+        return render_template("cart.html", cart_items=[], subtotal=0, reward_points=0, coupons=[], suggestions=[])
+
+
+@app.route("/cart/add_suggestion_to_cart", methods=["POST"])
+def add_suggestion_to_cart():
+    try:
+        # Get data from the request
+        data = request.get_json()
+        item_name = data.get('item_name').strip()
+        item_price = data.get('item_price')
+        item_image = data.get('item_image')
+        item_id = data.get('item_id')
+        customer_email = data.get('customer_email')
+        addons = data.get('addons', [])
+        instructions = data.get('instructions', "")
+
+        # Default values if addons and instructions are not provided
+        addons_price = 0
+        addons_string = "None"
+
+        # Check if the customer already has this item in their cart
+        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", [])
+
+        # If item already exists in the cart, update its quantity and other details
+        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', "")
+
+            # Combine existing and new addons
+            combined_addons = existing_addons if existing_addons != "None" else ""
+            if addons:
+                combined_addons = f"{combined_addons}; {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
+            )
+
+            # Update the cart item
+            sf.Cart_Item__c.update(cart_item_id, {
+                "Quantity__c": existing_quantity + 1,
+                "Add_Ons__c": combined_addons,
+                "Add_Ons_Price__c": combined_addons_price,
+                "Instructions__c": combined_instructions,
+                "Price__c": (existing_quantity + 1) * float(item_price) + combined_addons_price
+            })
+        else:
+            # If item doesn't exist in cart, create a new cart item
+            total_price = float(item_price) + addons_price
+
+            # Create a new cart item in Salesforce
+            sf.Cart_Item__c.create({
+                "Name": item_name,
+                "Price__c": total_price,
+                "Base_Price__c": item_price,
+                "Quantity__c": 1,
+                "Add_Ons_Price__c": addons_price,
+                "Add_Ons__c": addons_string,
+                "Image1__c": item_image,
+                "Customer_Email__c": customer_email,
+                "Instructions__c": 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', methods=['POST'])
+def add_to_cart():
+    try:
+        # Get data from request
+        data = request.json
+        item_name = data.get('itemName', '').strip()
+        item_price = data.get('itemPrice')
+        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)  # Get the quantity field from the request
+        customer_email = session.get('user_email')
+
+        # Basic validation for required fields
+        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
+
+        # Query to check if the item is already in the cart
+        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 total price for the addons
+        addons_price = sum(addon['price'] for addon in addons)
+        new_addons = "; ".join([f"{addon['name']} (${addon['price']})" for addon in addons])
+
+        # If the item is already in the cart, update it
+        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', "")
+
+            # Combine the new addons with the existing ones
+            combined_addons = existing_addons if existing_addons != "None" else ""
+            if new_addons:
+                combined_addons = f"{combined_addons}; {new_addons}".strip("; ")
+
+            # Combine existing instructions with new instructions
+            combined_instructions = existing_instructions
+            if instructions:
+                combined_instructions = f"{combined_instructions} | {instructions}".strip(" | ")
+
+            # Calculate total addons 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 cart item in Salesforce (updating quantity)
+            sf.Cart_Item__c.update(cart_item_id, {
+                "Quantity__c": existing_quantity + quantity,  # Add the selected 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:
+            # If the item is not already in the cart, create a new entry
+            addons_string = "None"
+            if addons:
+                addons_string = new_addons
+
+            total_price = item_price * quantity + addons_price  # Multiply by the quantity
+
+            # Create new cart item in Salesforce
+            sf.Cart_Item__c.create({
+                "Name": item_name,
+                "Price__c": total_price,
+                "Base_Price__c": item_price,
+                "Quantity__c": quantity,  # Use the selected 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."})
+
+    except KeyError as e:
+        # Handle missing expected keys in request data
+        return jsonify({"success": False, "error": f"Missing required field: {str(e)}"}), 400
+
+    except Exception as e:
+        # Log the error for debugging and return a general error message
+        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
+
+
+@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')  
+    item_section = request.args.get('item_section')  
+
+    # Check if both item_name and item_section are provided
+    if not item_name or not item_section:
+        return jsonify({"success": False, "error": "Item name and section are required."}), 400
+
+    try:
+        # Fetch customization options from Salesforce based on the section
+        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', [])
+
+        # Check if we found any addons
+        if not addons:
+            return jsonify({"success": False, "error": "No customization options found for the given section."}), 404
+
+        # Format data for frontend
+        formatted_addons = []
+        for addon in addons:
+            # Ensure 'Options__c' exists and is not None
+            options = addon.get("Options__c", "")
+            if options:  # If options are available, split them
+                options = options.split(", ")  # Convert comma-separated options into a list
+            else:
+                options = []  # If no options, default to an empty list
+
+            formatted_addons.append({
+                "name": addon["Name"],
+                "type": addon["Customization_Type__c"],
+                "options": options,
+                "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)
+            })
+
+        return jsonify({"success": True, "addons": formatted_addons})
+
+    except Exception as e:
+        # Log the exception for debugging
+        app.logger.error(f"Error fetching addons: {str(e)}")
+        return jsonify({"success": False, "error": "An error occurred while fetching customization options."}), 500
+
+
+@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')
+    table_number = session.get('table_number')  # Retrieve table number
+
+    print(f"Session Email: {email}, User ID: {user_id}, Table Number: {table_number}")  # Debugging session data
+
+    if not email or not user_id:
+        print("User not logged in")
+        return jsonify({"success": False, "message": "User not logged in"})
+
+    try:
+        # Fetch the selected coupon (if any)
+        data = request.json
+        selected_coupon = data.get("selectedCoupon", "").strip() if data.get("selectedCoupon") else None
+        # Now selected_coupon will be None if it's not provided or empty, or a valid string otherwise
+        print(f"Selected Coupon: {selected_coupon}")  # Debugging selected coupon
+
+        # Fetch cart items for the current user
+        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}'
+        """)
+        
+        # Log the cart items to see if they are fetched correctly
+        cart_items = result.get("records", [])
+        print(f"Cart Items Retrieved: {cart_items}")  # Debugging log
+
+        if not cart_items:
+            print("Cart is empty")
+            return jsonify({"success": False, "message": "Cart is empty"})
+
+        total_price = sum(item['Price__c'] for item in cart_items)
+        print(f"Total Price: {total_price}")  # Debugging total price calculation
+
+        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}'
+        """)
+        print(f"Coupon Query Results: {coupon_query}")  # Debugging coupon query results
+
+        has_coupons = bool(coupon_query["records"])
+        print(f"Has Coupons: {has_coupons}")  # Debugging coupon presence check
+
+        if selected_coupon:
+            # Apply 10% discount if a valid coupon is selected
+            discount = total_price * 0.10  # Example: 10% discount
+            print(f"Discount Applied: {discount}")  # Debugging discount calculation
+            
+            referral_coupon_id = coupon_query["records"][0]["Id"]
+            print(f"Referral Coupon ID: {referral_coupon_id}")  # Debugging referral coupon ID
+
+            existing_coupons = coupon_query["records"][0]["Coupon_Code__c"].split("\n")
+            print(f"Existing Coupons Before Removal: {existing_coupons}")  # Debugging existing coupons
+
+            # Remove the selected coupon from the list of existing coupons
+            updated_coupons = [coupon for coupon in existing_coupons if coupon.strip() != selected_coupon]
+            updated_coupons_str = "\n".join(updated_coupons).strip()
+
+            print(f"Updated Coupons After Removal: {updated_coupons}")  # Debugging updated coupons
+
+            # If no coupons remain, set the field to None (not empty string)
+            if not updated_coupons:
+                updated_coupons_str = None  # Set to None if no coupons are left
+                print("No Coupons Remaining. Setting to None")  # Debugging no coupons left
+
+            # Update the Referral_Coupon__c record
+            print(f"Updating Referral Coupon: {updated_coupons_str}")  # Debugging update to Salesforce
+            sf.Referral_Coupon__c.update(referral_coupon_id, {
+                "Coupon_Code__c": updated_coupons_str
+            })
+        else:
+            # If no coupon is selected, add reward points
+            reward_points_to_add = total_price * 0.10  # Example: 10% reward points
+            print(f"Reward Points to Add: {reward_points_to_add}")  # Debugging reward points
+
+            # Fetch current reward points
+            customer_record = sf.query(f"""
+                SELECT Id, Reward_Points__c FROM Customer_Login__c
+                WHERE Email__c = '{email}'
+            """)
+            print(f"Customer Reward Points Query: {customer_record}")  # Debugging customer reward points query
+            
+            customer = customer_record.get("records", [])[0] if customer_record else None
+            if customer:
+                current_reward_points = customer.get("Reward_Points__c") or 0
+                print(f"Current Reward Points: {current_reward_points}")  # Debugging current reward points
+                new_reward_points = current_reward_points + reward_points_to_add
+                print(f"New Reward Points: {new_reward_points}")  # Debugging new reward points calculation
+
+                # Update reward points
+                sf.Customer_Login__c.update(customer["Id"], {
+                    "Reward_Points__c": new_reward_points
+                })
+
+        # Final total bill calculation
+        total_bill = total_price - discount
+        print(f"Total Bill After Discount: {total_bill}")  # Debugging final total bill
+
+        # Store all order details (before deleting cart items)
+        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
+        )
+        print(f"Order Details: {order_details}")  # Debugging order details
+
+        # Fetch Customer ID from Customer_Login__c
+        customer_query = sf.query(f"""
+            SELECT Id FROM Customer_Login__c
+            WHERE Email__c = '{email}'
+        """)
+        
+        customer_id = customer_query["records"][0]["Id"] if customer_query["records"] else None
+        print(f"Customer ID: {customer_id}")  # Debugging customer ID retrieval
+
+        if not customer_id:
+            print("Customer record not found")
+            return jsonify({"success": False, "message": "Customer record not found in Salesforce"})
+        table_number = table_number if table_number != 'null' else None  # Ensure 'null' string is replaced with None
+        # Store order data
+        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",
+            "Customer2__c": customer_id,
+            "Order_Details__c": order_details,
+            "Table_Number__c": table_number  # Store table number
+        }
+        print(f"Order Data: {order_data}")  # Debugging order data
+
+        # Create the order in Salesforce
+        order_response = sf.Order__c.create(order_data)
+        print(f"Order Response: {order_response}")  # Debugging order creation response
+
+        # Ensure the order was created successfully before deleting cart items
+        if order_response:
+            # Only delete cart items after the order is created
+            for item in cart_items:
+                print(f"Deleting Cart Item: {item['Id']}")  # Debugging cart item deletion
+                sf.Cart_Item__c.delete(item["Id"])
+
+        return jsonify({"success": True, "message": "Order placed successfully!", "discount": discount, "totalBill": total_bill})
+
+    except Exception as e:
+        print(f"Error during checkout: {str(e)}")  # Debugging error message
+        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))
+import smtplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+
+
+
+
+if __name__ == "__main__":
+    app.run(debug=True, host="0.0.0.0", port=7860)