Update app.py

app.py

@@ -81,711 +81,3 @@ def dashboard():
 if __name__ == '__main__':
     app.run(debug=True)
 
-# Initialize Flask app and Salesforce connection
-print("Starting app...")
-app = Flask(__name__)
-CORS(app) 
-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", "sSSjyhInIsUohKpG8sHzty2q")  # 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():
-    # Get email and name from the URL query parameters
-    email = request.args.get('email')
-    name = request.args.get('name')
-
-    # Use email and name as needed (e.g., display them in the page)
-    return render_template('index.html', email=email, name=name)
-
-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))
-
-
-import re
-
-import re
-
-@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
-        """)
-
-        orders = result.get("records", [])  # Fetch all orders
-
-        # Strip image URLs from order details and split remaining data by new lines
-        for order in orders:
-            order_details = order.get("Order_Details__c", "")
-            # Remove image URLs using regex
-            cleaned_details = re.sub(r'http[s]?://\S+', '', order_details)
-            
-            # Now split the cleaned details by lines and join them with <br> to create line breaks
-            cleaned_details = cleaned_details.replace("\n", "<br>")
-
-            # Update the order details with the cleaned and formatted details
-            order['Order_Details__c'] = cleaned_details
-
-        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.route("/logout")
-def logout():
-    session.clear()  # Clear the session
-    return redirect(url_for("login"))  # Redirect to the login page
-
-@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, including Name and Reward_Points__c
-            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']
-                session['user_email'] = email
-                print(f"Session variables set: user_id={session['user_id']}, user_email={session['user_email']}")
-
-                user_name = user.get("Name", "")  # Get the user's name
-                reward_points = user.get("Reward_Points__c") or 0  # Ensures reward_points is always an integer
-
-
-
-                if reward_points >= 500:
-                    print(f"User {email} has {reward_points} reward points. Generating coupon...")
-
-                    # Generate a new coupon code
-                    new_coupon_code = generate_coupon_code()
-
-                    # Check if user already has a record in Referral_Coupon__c
-                    coupon_query = sf.query(f"""
-                        SELECT Id, Coupon_Code__c FROM Referral_Coupon__c WHERE Referral_Email__c = '{email}'
-                    """)
-
-                    if coupon_query["records"]:
-                        # If record exists, append the new coupon
-                        coupon_record = coupon_query["records"][0]
-                        referral_coupon_id = coupon_record["Id"]
-                        existing_coupons = coupon_record.get("Coupon_Code__c", "")
-
-                        # Append the new coupon on the next line
-                        updated_coupons = f"{existing_coupons}\n{new_coupon_code}".strip()
-
-                        # Update the Referral_Coupon__c record
-                        sf.Referral_Coupon__c.update(referral_coupon_id, {
-                            "Coupon_Code__c": updated_coupons
-                        })
-                        print(f"Updated existing coupon record for {email}. New Coupon: {new_coupon_code}")
-                    else:
-                        # If no record exists, create a new one with Referral_Name__c
-                        sf.Referral_Coupon__c.create({
-                            "Referral_Email__c": email,
-                            "Name": user_name,  # Store user's name in Referral_Coupon__c
-                            "Coupon_Code__c": new_coupon_code
-                        })
-                        print(f"Created new coupon record for {email} with name {user_name}. Coupon: {new_coupon_code}")
-
-                    # Subtract 500 reward points from user's account
-                    new_reward_points = reward_points - 500
-                    sf.Customer_Login__c.update(user['Id'], {
-                        "Reward_Points__c": new_reward_points
-                    })
-                    print(f"Coupon {new_coupon_code} generated and 500 points deducted. New balance: {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 = request.args.get("email")  # Fetch the user's email from URL parameter
-    user_name = request.args.get("name")  # Fetch the user's name from URL parameter
-
-    if not user_email:
-        print("Email missing, redirecting to login.")
-        return redirect(url_for('login'))
-    
-    # Now, you can use user_email and user_name in your queries and logic
-    try:
-        # Fetch the user's Referral__c and Reward_Points__c from Salesforce using the 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']:
-            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 []
-
-        # Filter categories dynamically
-        categories = {item.get("Veg_NonVeg__c").capitalize() for item in food_items if item.get("Veg_NonVeg__c")}
-        categories = {"Veg", "Non-Veg"}  # 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 = {"All", "Veg", "Non-Veg"}  # Default categories on error
-        referral_code = 'N/A'
-        reward_points = 0
-
-    # Render the menu page with the fetched data and user details
-    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,
-        user_name=user_name,  # Pass user name to the template
-        user_email=user_email   # Pass user email to the template
-    )
-
-
-
-
-@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_id')
-
-    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=False, host="0.0.0.0", port=7860)