Update cart.py

cart.py

@@ -267,84 +267,128 @@ def update_quantity():
 def checkout():
     email = session.get('user_email')
     user_id = session.get('user_name')
-    table_number = session.get('table_number')
+    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
+        # 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
 
-        # Coupon handling (existing logic)
+        # 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}'
         """)
-        if selected_coupon and coupon_query["records"]:
-            discount = total_price * 0.10
+        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() or None
-            sf.Referral_Coupon__c.update(referral_coupon_id, {"Coupon_Code__c": updated_coupons_str})
+            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:
-            # Add reward points (existing logic)
-            reward_points_to_add = total_price * 0.10
+            # 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, Total_Orders__c, Total_Spent__c
-                FROM Customer_Login__c WHERE Email__c = '{email}'
+                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", 0)
+                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
-                total_orders = (customer.get("Total_Orders__c", 0) or 0) + 1
-                total_spent = (customer.get("Total_Spent__c", 0) or 0) + total_price
-
-                # Determine badge
-                badge = "Newbie"
-                if total_orders >= 10:
-                    badge = "VIP"
-                elif total_orders >= 5:
-                    badge = "Regular"
-                if total_spent > 500:
-                    badge = "Gold Member"
-
-                # Update customer record
+                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,
-                    "Total_Orders__c": total_orders,
-                    "Total_Spent__c": total_spent,
-                    "Badge__c": badge
+                    "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 order (existing logic)
-        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"})
-
+        # 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')} | Price: ${item['Price__c']}"
+            f"Instructions: {item.get('Instructions__c', 'None')} | "
+            f"Price: ${item['Price__c']} | Image: {item['Image1__c']}"
             for item in cart_items
         )
-        table_number = table_number if table_number != 'null' else None
+        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,
@@ -354,71 +398,26 @@ def checkout():
             "Order_Status__c": "Pending",
             "Customer2__c": customer_id,
             "Order_Details__c": order_details,
-            "Table_Number__c": table_number
+            "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
-        })
+        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)})
-@cart_blueprint.route("/loyalty", methods=["GET"])
-def get_loyalty_data():
-    email = session.get('user_email')
-    if not email:
-        return redirect(url_for('login'))
-
-    try:
-        customer_record = sf.query(f"""
-            SELECT Reward_Points__c, Total_Orders__c, Total_Spent__c, Badge__c
-            FROM Customer_Login__c WHERE Email__c = '{email}'
-        """)
-        customer = customer_record.get("records", [])[0] if customer_record["records"] else None
-        if not customer:
-            return "Customer not found", 404
-
-        # Clean up data
-        reward_points = round(customer.get("Reward_Points__c", 0) or 0, 2)  # Round to 2 decimals
-        total_orders = customer.get("Total_Orders__c", 0) or 0
-        total_spent = customer.get("Total_Spent__c", 0) or 0
-        badge = customer.get("Badge__c") or "Newbie"  # Default to "Newbie" if None
-
-        # Define rewards with image URLs (you can store these in Salesforce or locally)
-        rewards = [
-            {"name": "$5 Off", "points": 50, "description": "Get $5 off your next order", "image": "/static/images/reward_discount.png"},
-            {"name": "Free Drink", "points": 100, "description": "Redeem for a free drink", "image": "/static/images/reward_drink.png"},
-            {"name": "20% Off", "points": 200, "description": "20% off your next order", "image": "/static/images/reward_percentage.png"}
-        ]
-
-        # Badge images (map badge names to image paths)
-        badge_images = {
-            "Newbie": "/static/images/badge_bronze.png",
-            "Regular": "/static/images/badge_silver.png",
-            "VIP": "/static/images/badge_gold.png",
-            "Gold Member": "/static/images/badge_platinum.png"
-        }
-
-        loyalty_data = {
-            "reward_points": reward_points,
-            "total_orders": total_orders,
-            "total_spent": total_spent,
-            "badge": badge,
-            "badge_image": badge_images.get(badge, "/static/images/badge_bronze.png"),  # Default to bronze
-            "available_rewards": rewards
-        }
-        return render_template("loyalty.html", loyalty_data=loyalty_data)
-
-    except Exception as e:
-        return f"Error: {str(e)}", 500
 @cart_blueprint.route("/fetch_previous_order", methods=["GET"])
 def fetch_previous_order():
     # Assuming `email` is the unique identifier for the user
@@ -452,4 +451,4 @@ def fetch_previous_order():
 
     except Exception as e:
         print(f"Error fetching previous order: {e}")
-        return jsonify({"success": False, "message": "Error fetching previous order."})
+        return jsonify({"success": False, "message": "Error fetching previous order."})