Update cart.py

cart.py

@@ -267,128 +267,84 @@ def update_quantity():
 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
+    table_number = session.get('table_number')
 
     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
+        # 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}'
         """)
-        
-        # 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 handling (existing logic)
         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
-            
+        if selected_coupon and coupon_query["records"]:
+            discount = total_price * 0.10
             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
-            })
+            updated_coupons_str = "\n".join(updated_coupons).strip() or None
+            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
+            # Add reward points (existing logic)
+            reward_points_to_add = total_price * 0.10
             customer_record = sf.query(f"""
-                SELECT Id, Reward_Points__c FROM Customer_Login__c
-                WHERE Email__c = '{email}'
+                SELECT Id, Reward_Points__c, Total_Orders__c, Total_Spent__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
+                current_reward_points = customer.get("Reward_Points__c", 0)
                 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
+                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
                 sf.Customer_Login__c.update(customer["Id"], {
-                    "Reward_Points__c": new_reward_points
+                    "Reward_Points__c": new_reward_points,
+                    "Total_Orders__c": total_orders,
+                    "Total_Spent__c": total_spent,
+                    "Badge__c": badge
                 })
 
-        # 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)
+        # 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"})
+
         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']}"
+            f"Instructions: {item.get('Instructions__c', 'None')} | Price: ${item['Price__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
+        table_number = table_number if table_number != 'null' else None
         order_data = {
             "Customer_Name__c": user_id,
             "Customer_Email__c": email,
@@ -398,59 +354,54 @@ def checkout():
             "Order_Status__c": "Pending",
             "Customer2__c": customer_id,
             "Order_Details__c": order_details,
-            "Table_Number__c": table_number  # Store table number
+            "Table_Number__c": 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("/fetch_previous_order", methods=["GET"])
-def fetch_previous_order():
-    # Assuming `email` is the unique identifier for the user
+@cart_blueprint.route("/loyalty", methods=["GET"])
+def get_loyalty_data():
     email = session.get('user_email')
-    
     if not email:
         return jsonify({"success": False, "message": "User not logged in"})
 
     try:
-        # Fetch the most recent order (or any other logic to get the previous order)
-        previous_order_query = f"""
-            SELECT Order_Details__c 
-            FROM Order__c 
-            WHERE Customer_Email__c = '{email}' AND Order_Status__c = 'Completed' 
-            ORDER BY CreatedDate DESC LIMIT 1
-        """
-        previous_order_result = sf.query(previous_order_query)
-        previous_order = previous_order_result["records"][0] if previous_order_result["records"] else None
-        
-        if not previous_order:
-            return jsonify({"success": False, "message": "No previous order found."})
-
-        # Parse the order details to extract the items and add-ons
-        order_details = previous_order["Order_Details__c"]
-        
-        # Assuming the order details are stored as JSON (you can use JSON.parse() in JavaScript to handle this)
-        # You might need to adjust the parsing based on how the data is structured (whether it's JSON or string-based)
-        order_items = json.loads(order_details)["items"]
-        
-        return jsonify({"success": True, "previousOrder": order_items})
+        # Fetch customer loyalty data
+        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 jsonify({"success": False, "message": "Customer not found"})
+
+        # Define available rewards
+        rewards = [
+            {"name": "$5 Off", "points": 50, "description": "Get $5 off your next order"},
+            {"name": "Free Drink", "points": 100, "description": "Redeem for a free drink"},
+            {"name": "20% Off", "points": 200, "description": "20% off your next order"}
+        ]
+
+        loyalty_data = {
+            "reward_points": customer.get("Reward_Points__c", 0),
+            "total_orders": customer.get("Total_Orders__c", 0),
+            "total_spent": customer.get("Total_Spent__c", 0),
+            "badge": customer.get("Badge__c", "Newbie"),
+            "available_rewards": rewards
+        }
+        return jsonify({"success": True, "data": loyalty_data})
 
     except Exception as e:
-        print(f"Error fetching previous order: {e}")
-        return jsonify({"success": False, "message": "Error fetching previous order."})
-
-
+        return jsonify({"success": False, "error": str(e)})