Update app.py

app.py

@@ -2,10 +2,14 @@ from flask import Flask, render_template, request, jsonify, redirect, url_for, s
 from flask_session import Session  # Import the Session class
 from flask.sessions import SecureCookieSessionInterface  # Import the class
 from salesforce import get_salesforce_connection
-from Menu_page import menu_page  # Now you can import the Blueprint after app is initialized
 from datetime import timedelta
 import os
-
+import smtplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from menu import menu_blueprint  # Make sure this import is correct
+from cart import cart_blueprint  # Same for other blueprints
+from order import order_blueprint  # Same for user blueprint
 
 
 # Initialize Flask app and Salesforce connection
@@ -18,17 +22,11 @@ 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
+app.secret_key = os.getenv("SECRET_KEY", "xEr0cwgsiatzrzaeFewYrVA1O")  # Replace with a secure key
 
-# Register Blueprints after Flask app is created
-app.register_blueprint(menu_page, url_prefix="/menu_page")  # Optional: you can add a URL prefix
-print("Menu page is working now")
-
-# 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
+app.config["SESSION_TYPE"] = "filesystem"  # Storing sessions in filesystem
+app.config["SESSION_COOKIE_SECURE"] = True  # Enabling secure cookies (ensure your app is served over HTTPS)
+app.config["SESSION_COOKIE_SAMESITE"] = "None"  # Cross-site cookies allowed
 
 # Initialize the session
 Session(app)  # Correctly initialize the Session object
@@ -61,7 +59,7 @@ def home():
 
         # Ensure session is saved before redirecting
         session.modified = True
-        return redirect(url_for("menu_page.menu"))  # Redirect to menu directly
+        return redirect(url_for("menu.menu"))  # Redirect to menu directly
 
     return render_template("index.html")
 
@@ -169,97 +167,94 @@ def generate_custom_dish():
     except Exception as e:
         return jsonify({"success": False, "error": str(e)}), 500
 
-import re
-@app.route("/edit_profile", methods=["GET", "POST"])
-def edit_profile():
+@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, Password__c
+            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 redirect(url_for("login"))
+            return jsonify({'status': 'error', 'message': 'User not found'})
 
         user = result['records'][0]
         user_id = user.get("Id")
-        user_name = user.get("Name")
-        user_phone = user.get("Phone_Number__c")
-        user_email = user.get("Email__c")
 
-    except Exception as e:
-        print(f"Error fetching user data: {str(e)}")
-        return jsonify({"success": False, "message": "Error fetching user data"})
-
-    try:
-        # Process user profile update
-        new_name = request.form.get('name')
+        # 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_password = request.form.get('password')
+        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
+            'Phone_Number__c': new_phone,
+            'Referral__c': new_referral_code,
+            'Reward_Points__c': new_reward_points
         }
 
-        if new_password:
-            update_data['Password__c'] = new_password
-
         # Update Salesforce record
         sf.Customer_Login__c.update(user_id, update_data)
 
-        return redirect(url_for('customer_details'))
+        return jsonify({
+            'status': 'success',
+            'message': 'Profile updated successfully!',
+            'data': update_data
+        })
 
     except Exception as e:
-        return render_template("edit_profile.html", user_name=user_name, user_phone=user_phone, user_email=user_email, error=str(e))
+        return jsonify({'status': 'error', 'message': str(e)})
 
-import re
-@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"))  # If no email is found, redirect to login
 
-    try:
-        # Fetch customer details from Salesforce based on the email
-        customer_record = sf.query(f"""
-            SELECT Name, Email__c, Phone_Number__c, Referral__c, Reward_Points__c
-            FROM Customer_Login__c
-            WHERE Email__c = '{email}'
-            LIMIT 1
-        """)
-
-        # If no customer record found, handle it
-        if not customer_record.get("records"):
-            return jsonify({"success": False, "message": "Customer not found in Salesforce"})
-
-        # Get the customer details
-        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 the customer details as JSON response
-        return render_template("customer_details.html", customer=customer_data)
-
-    except Exception as e:
-        print(f"Error fetching customer details: {str(e)}")
-        return jsonify({"success": False, "message": f"Error fetching customer details: {str(e)}"})
+from datetime import datetime
+import pytz  # Library to handle timezone conversions
 
 @app.route("/order-history", methods=["GET"])
 def order_history():
@@ -277,25 +272,55 @@ def order_history():
             ORDER BY CreatedDate DESC
         """)
 
+        print(f"Salesforce query result: {result}")  # Debugging line
+
         orders = result.get("records", [])  # Fetch all orders
 
-        # Strip image URLs from order details and split remaining data by new lines
+        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", "")
-            # Remove image URLs using regex
-            cleaned_details = re.sub(r'http[s]?://\S+', '', order_details)
+            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)
             
-            # Now split the cleaned details by lines and join them with <br> to create line breaks
-            cleaned_details = cleaned_details.replace("\n", "  ")
+                # 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
 
-            # 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.permanent_session_lifetime = timedelta(minutes=5)
 @app.before_request
 def check_session_timeout():
@@ -406,6 +431,9 @@ def signup():
 
     return render_template("signup.html")
 
+
+
+
 @app.route("/login", methods=["GET", "POST"])
 def login():
     if request.method == "POST":
@@ -452,7 +480,7 @@ def login():
                     new_reward_points = reward_points - 500
                     sf.Customer_Login__c.update(user['Id'], {"Reward_Points__c": new_reward_points})
 
-                return redirect(url_for("menu_page.menu"))
+                return redirect(url_for("menu.menu"))
 
             else:
                 print("Invalid credentials!")
@@ -463,584 +491,11 @@ def login():
             return render_template("login.html", error=f"Error: {str(e)}")
 
     return render_template("login.html")
+# Register Blueprints for each functionality
+app.register_blueprint(menu_blueprint)
+app.register_blueprint(cart_blueprint, url_prefix='/cart')  # Register the cart blueprint with URL prefix
 
-
-@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', 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_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_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
-
-    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"])
-
-        if selected_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]
-            updated_coupons_str = "\n".join(updated_coupons).strip()
-
-            sf.Referral_Coupon__c.update(referral_coupon_id, {
-                "Coupon_Code__c": updated_coupons_str
-            })
-        else:
-            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
-
-                sf.Customer_Login__c.update(customer["Id"], {
-                    "Reward_Points__c": new_reward_points
-                })
-
-        total_bill = total_price - discount
-
-        # ✅ Store all order details
-        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
-        )
-
-        # 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
-        
-        if not customer_id:
-            return jsonify({"success": False, "message": "Customer record not found in Salesforce"})
-
-        # ✅ Store table number 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",
-            "Customer2__c": customer_id,
-            "Order_Details__c": order_details,
-            "Table_Number__c": table_number  # ✅ Store table number
-        }
-
-        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))
-import smtplib
-from email.mime.multipart import MIMEMultipart
-from email.mime.text import MIMEText
+app.register_blueprint(order_blueprint)
 
 
 if __name__ == "__main__":