Update cart.py

cart.py

@@ -1,4 +1,415 @@
 from flask import Blueprint, render_template, request, session
 import random
 
-cart_blueprint = Blueprint('cart', __name__)
+cart_blueprint = Blueprint('cart', __name__)
+@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/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("/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)})
+
+