|
from flask import Flask, render_template, request, jsonify, redirect, url_for, session |
|
from flask_session import Session |
|
from flask.sessions import SecureCookieSessionInterface |
|
from salesforce import get_salesforce_connection |
|
from datetime import timedelta |
|
import os |
|
|
|
|
|
print("Starting app...") |
|
app = Flask(__name__) |
|
print("Flask app initialized.") |
|
|
|
|
|
sf = get_salesforce_connection() |
|
print("Salesforce connection established.") |
|
|
|
|
|
app.secret_key = os.getenv("SECRET_KEY", "sSSjyhInIsUohKpG8sHzty2q") |
|
|
|
|
|
app.config["SESSION_TYPE"] = "filesystem" |
|
|
|
app.config["SESSION_COOKIE_SECURE"] = True |
|
app.config["SESSION_COOKIE_SAMESITE"] = "None" |
|
|
|
|
|
Session(app) |
|
print("Session interface configured.") |
|
|
|
|
|
app.session_interface = SecureCookieSessionInterface() |
|
print("Session interface configured.") |
|
import random |
|
import string |
|
|
|
def generate_referral_code(length=8): |
|
|
|
characters = string.ascii_letters + string.digits |
|
referral_code = ''.join(random.choice(characters) for _ in range(length)) |
|
return referral_code |
|
|
|
@app.route("/") |
|
def home(): |
|
|
|
user_email = request.args.get("email") |
|
user_name = request.args.get("name") |
|
table_number = request.args.get("table") |
|
|
|
if user_email and user_name: |
|
session["user_email"] = user_email |
|
session["user_name"] = user_name |
|
session["table_number"] = table_number |
|
print(f"User logged in: {user_email} - {user_name} - Table: {table_number}") |
|
|
|
|
|
session.modified = True |
|
return redirect(url_for("menu")) |
|
|
|
return render_template("index.html") |
|
|
|
|
|
|
|
from datetime import datetime |
|
|
|
def generate_coupon_code(length=10): |
|
"""Generates a random alphanumeric coupon code""" |
|
characters = string.ascii_uppercase + string.digits |
|
return ''.join(random.choice(characters) for _ in range(length)) |
|
@app.route("/generate_custom_dish", methods=["POST"]) |
|
def generate_custom_dish(): |
|
try: |
|
data = request.form |
|
dish_name = data.get("name") |
|
description = data.get("description") |
|
item_image_url = "https://huggingface.co/spaces/nagasurendra/BiryaniHubflask30/resolve/main/static/customized.jpg" |
|
item_image_url2 = "https://huggingface.co/spaces/nagasurendra/BiryaniHubflask30/resolve/main/static/customized1.jpg" |
|
|
|
if not dish_name or not description: |
|
return jsonify({"success": False, "error": "Both fields are required"}), 400 |
|
|
|
|
|
price = random.randint(10, 30) |
|
|
|
|
|
veg_keywords = ["paneer", "vegetable", "mushroom", "cheese"] |
|
non_veg_keywords = ["chicken", "mutton", "fish", "egg"] |
|
|
|
category = "Veg" if any(word in description.lower() for word in veg_keywords) else \ |
|
"Non veg" if any(word in description.lower() for word in non_veg_keywords) else \ |
|
"both" |
|
|
|
|
|
existing_dish_query = f"SELECT Id, Name, Price__c, Image1__c, Image2__c, Description__c, Veg_NonVeg__c FROM Custom_Dish__c WHERE Name = '{dish_name}'" |
|
existing_dish_result = sf.query(existing_dish_query) |
|
|
|
if existing_dish_result['totalSize'] > 0: |
|
|
|
existing_dish = existing_dish_result['records'][0] |
|
price = existing_dish['Price__c'] |
|
item_image_url = existing_dish['Image1__c'] |
|
item_image_url2 = existing_dish['Image2__c'] |
|
category = existing_dish['Veg_NonVeg__c'] |
|
else: |
|
|
|
custom_dish = { |
|
'Name': dish_name, |
|
'Price__c': price, |
|
'Image1__c': item_image_url, |
|
'Image2__c': item_image_url2, |
|
'Description__c': description, |
|
'Veg_NonVeg__c': category, |
|
'Section__c': 'Customized dish', |
|
'Total_Ordered__c': 0 |
|
} |
|
|
|
|
|
result = sf.Custom_Dish__c.create(custom_dish) |
|
|
|
if not result.get('success'): |
|
return jsonify({"success": False, "error": "Failed to create custom dish in Salesforce"}), 500 |
|
|
|
|
|
email = session.get('user_email') |
|
|
|
|
|
cart_item_query = f"SELECT Id, Quantity__c, Price__c, Base_Price__c FROM Cart_Item__c WHERE Customer_Email__c = '{email}' AND Name = '{dish_name}'" |
|
cart_item_result = sf.query(cart_item_query) |
|
|
|
if cart_item_result['totalSize'] > 0: |
|
|
|
cart_item = cart_item_result['records'][0] |
|
new_quantity = cart_item['Quantity__c'] + 1 |
|
new_price = price * new_quantity |
|
|
|
|
|
updated_cart_item = { |
|
'Quantity__c': new_quantity, |
|
'Price__c': new_price |
|
} |
|
|
|
cart_item_update = sf.Cart_Item__c.update(cart_item['Id'], updated_cart_item) |
|
|
|
else: |
|
|
|
cart_item = { |
|
'Name': dish_name, |
|
'Price__c': price, |
|
'Base_Price__c': price, |
|
'Image1__c': item_image_url, |
|
'Quantity__c': 1, |
|
'Add_Ons__c': '', |
|
'Add_Ons_Price__c': 0, |
|
'Customer_Email__c': email |
|
} |
|
|
|
|
|
cart_result = sf.Cart_Item__c.create(cart_item) |
|
|
|
|
|
return redirect(url_for("cart")) |
|
|
|
except Exception as e: |
|
return jsonify({"success": False, "error": str(e)}), 500 |
|
|
|
import re |
|
@app.route("/edit_profile", methods=["GET", "POST"]) |
|
def edit_profile(): |
|
email = session.get('user_email') |
|
if not email: |
|
return redirect(url_for("login")) |
|
|
|
try: |
|
|
|
result = sf.query(f""" |
|
SELECT Id, Name, Email__c, Phone_Number__c, Password__c |
|
FROM Customer_Login__c |
|
WHERE Email__c = '{email}' |
|
""") |
|
|
|
if not result['records']: |
|
return redirect(url_for("login")) |
|
|
|
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: |
|
|
|
new_name = request.form.get('name') |
|
new_email = request.form.get('email') |
|
new_phone = request.form.get('phone') |
|
new_password = request.form.get('password') |
|
|
|
update_data = { |
|
'Name': new_name, |
|
'Email__c': new_email, |
|
'Phone_Number__c': new_phone |
|
} |
|
|
|
if new_password: |
|
update_data['Password__c'] = new_password |
|
|
|
|
|
sf.Customer_Login__c.update(user_id, update_data) |
|
|
|
return redirect(url_for('customer_details')) |
|
|
|
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)) |
|
|
|
import re |
|
@app.route("/customer_details", methods=["GET"]) |
|
def customer_details(): |
|
email = session.get('user_email') |
|
|
|
if not email: |
|
return redirect(url_for("login")) |
|
|
|
try: |
|
|
|
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 not customer_record.get("records"): |
|
return jsonify({"success": False, "message": "Customer not found in Salesforce"}) |
|
|
|
|
|
customer = customer_record["records"][0] |
|
|
|
|
|
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: |
|
print(f"Error fetching customer details: {str(e)}") |
|
return jsonify({"success": False, "message": f"Error fetching customer details: {str(e)}"}) |
|
|
|
@app.route("/order-history", methods=["GET"]) |
|
def order_history(): |
|
email = session.get('user_email') |
|
if not email: |
|
return redirect(url_for("login")) |
|
|
|
try: |
|
|
|
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", []) |
|
|
|
|
|
for order in orders: |
|
order_details = order.get("Order_Details__c", "") |
|
|
|
cleaned_details = re.sub(r'http[s]?://\S+', '', order_details) |
|
|
|
|
|
cleaned_details = cleaned_details.replace("\n", " ") |
|
|
|
|
|
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(): |
|
if "last_activity" in session: |
|
last_activity_time = session["last_activity"] |
|
now = datetime.now().timestamp() |
|
|
|
|
|
if now - last_activity_time > 300: |
|
session.clear() |
|
return redirect(url_for("logout")) |
|
|
|
|
|
session["last_activity"] = datetime.now().timestamp() |
|
|
|
@app.route("/dashboard") |
|
def dashboard(): |
|
return render_template("dashboard.html") |
|
@app.route("/logout") |
|
def logout(): |
|
|
|
table_number = session.get('table_number', '') |
|
|
|
|
|
session.pop('name', None) |
|
session.pop('email', None) |
|
session.pop('rewardPoints', None) |
|
session.pop('coupon', None) |
|
|
|
|
|
return render_template("redirect_page.html", table_number=table_number) |
|
|
|
@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() |
|
password = request.form.get("password") |
|
referral_code = request.form.get("referral") |
|
generated_referral_code = generate_referral_code() |
|
|
|
try: |
|
ref = 0 |
|
|
|
|
|
email_query = "SELECT Id, Email__c FROM Customer_Login__c" |
|
email_result = sf.query(email_query) |
|
|
|
|
|
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.") |
|
|
|
|
|
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!") |
|
|
|
|
|
referrer = referral_result['records'][0] |
|
referrer_email = referrer.get('Email__c') |
|
referrer_name = referrer.get('Name') |
|
|
|
|
|
new_coupon_code = generate_coupon_code() |
|
|
|
|
|
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() |
|
|
|
|
|
sf.Referral_Coupon__c.update(referral_id, { |
|
"Coupon_Code__c": updated_coupons |
|
}) |
|
else: |
|
|
|
sf.Referral_Coupon__c.create({ |
|
"Name": referrer_name, |
|
"Referral_Email__c": referrer_email, |
|
"Coupon_Code__c": new_coupon_code |
|
}) |
|
|
|
|
|
sf.Customer_Login__c.create({ |
|
"Name": name, |
|
"Phone_Number__c": phone, |
|
"Email__c": email, |
|
"Password__c": password, |
|
"Reward_Points__c": ref, |
|
"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}") |
|
|
|
try: |
|
|
|
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'] |
|
|
|
|
|
if 'user_email' not in session or session['user_email'] != email: |
|
session['user_email'] = email |
|
session['user_name'] = user.get("Name", "") |
|
print(f"✅ Session email updated: {session['user_email']}") |
|
|
|
reward_points = user.get("Reward_Points__c") or 0 |
|
|
|
|
|
if reward_points >= 500: |
|
new_coupon_code = generate_coupon_code() |
|
coupon_query = sf.query(f"SELECT Id, Coupon_Code__c FROM Referral_Coupon__c WHERE Referral_Email__c = '{email}'") |
|
|
|
if coupon_query["records"]: |
|
coupon_record = coupon_query["records"][0] |
|
referral_coupon_id = coupon_record["Id"] |
|
existing_coupons = coupon_record.get("Coupon_Code__c", "") |
|
|
|
updated_coupons = f"{existing_coupons}\n{new_coupon_code}".strip() |
|
sf.Referral_Coupon__c.update(referral_coupon_id, {"Coupon_Code__c": updated_coupons}) |
|
else: |
|
sf.Referral_Coupon__c.create({ |
|
"Referral_Email__c": email, |
|
"Name": user.get("Name", ""), |
|
"Coupon_Code__c": new_coupon_code |
|
}) |
|
|
|
new_reward_points = reward_points - 500 |
|
sf.Customer_Login__c.update(user['Id'], {"Reward_Points__c": 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 = session.get('user_email') |
|
|
|
if not user_email: |
|
user_email = request.args.get("email") |
|
user_name = request.args.get("name") |
|
|
|
if user_email: |
|
session['user_email'] = user_email |
|
session['user_name'] = user_name |
|
else: |
|
return redirect(url_for("login")) |
|
else: |
|
user_name = session.get('user_name') |
|
|
|
|
|
first_letter = user_name[0].upper() if user_name else "A" |
|
|
|
try: |
|
|
|
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']: |
|
return redirect(url_for('login')) |
|
|
|
referral_code = user_result['records'][0].get('Referral__c', 'N/A') |
|
reward_points = user_result['records'][0].get('Reward_Points__c', 0) |
|
|
|
|
|
menu_query = """ |
|
SELECT Name, Price__c, Description__c, Image1__c, Image2__c, Veg_NonVeg__c, Section__c, Total_Ordered__c |
|
FROM Menu_Item__c |
|
""" |
|
result = sf.query(menu_query) |
|
food_items = result['records'] if 'records' in result else [] |
|
|
|
|
|
for item in food_items: |
|
if 'Total_Ordered__c' not in item or item['Total_Ordered__c'] is None: |
|
item['Total_Ordered__c'] = 0 |
|
|
|
|
|
custom_dish_query = """ |
|
SELECT Name, Price__c, Description__c, Image1__c, Image2__c, Veg_NonVeg__c, Section__c, Total_Ordered__c |
|
FROM Custom_Dish__c |
|
WHERE CreatedDate >= LAST_N_DAYS:7 |
|
""" |
|
custom_dish_result = sf.query(custom_dish_query) |
|
custom_dishes = custom_dish_result['records'] if 'records' in custom_dish_result else [] |
|
|
|
|
|
all_items = food_items + custom_dishes |
|
|
|
|
|
section_order = ["Best Sellers", "Starters", "Biryanis", "Curries", "Breads", "Customized dish", "Apetizer", "Desserts", "Soft Drinks"] |
|
ordered_menu = {section: [] for section in section_order} |
|
|
|
|
|
best_sellers = sorted(all_items, key=lambda x: x.get("Total_Ordered__c", 0), reverse=True) |
|
|
|
if selected_category == "Veg": |
|
best_sellers = [item for item in best_sellers if item.get("Veg_NonVeg__c") in ["Veg", "both"]] |
|
elif selected_category == "Non veg": |
|
best_sellers = [item for item in best_sellers if item.get("Veg_NonVeg__c") in ["Non veg", "both"]] |
|
|
|
|
|
best_sellers = best_sellers[:4] |
|
|
|
|
|
if best_sellers: |
|
ordered_menu["Best Sellers"] = best_sellers |
|
|
|
|
|
added_item_names = set() |
|
|
|
|
|
for item in all_items: |
|
section = item.get("Section__c", "Others") |
|
if section not in ordered_menu: |
|
ordered_menu[section] = [] |
|
|
|
|
|
if item['Name'] in added_item_names: |
|
continue |
|
|
|
|
|
if selected_category == "Veg" and item.get("Veg_NonVeg__c") not in ["Veg", "both"]: |
|
continue |
|
if selected_category == "Non veg" and item.get("Veg_NonVeg__c") not in ["Non veg", "both"]: |
|
continue |
|
|
|
ordered_menu[section].append(item) |
|
added_item_names.add(item['Name']) |
|
print(f"Added item to {section}: {item['Name']}") |
|
|
|
|
|
ordered_menu = {section: items for section, items in ordered_menu.items() if items} |
|
print(f"Final ordered menu: {ordered_menu.keys()}") |
|
|
|
categories = ["All", "Veg", "Non veg"] |
|
|
|
except Exception as e: |
|
print(f"Error fetching menu data: {str(e)}") |
|
ordered_menu = {} |
|
categories = ["All", "Veg", "Non veg"] |
|
referral_code = 'N/A' |
|
reward_points = 0 |
|
|
|
|
|
return render_template( |
|
"menu.html", |
|
ordered_menu=ordered_menu, |
|
categories=categories, |
|
selected_category=selected_category, |
|
referral_code=referral_code, |
|
reward_points=reward_points, |
|
user_name=user_name, |
|
first_letter=first_letter |
|
) |
|
|
|
|
|
@app.route("/cart", methods=["GET"]) |
|
def cart(): |
|
email = session.get('user_email') |
|
if not email: |
|
return redirect(url_for("login")) |
|
|
|
try: |
|
|
|
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) |
|
|
|
|
|
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 |
|
|
|
|
|
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 = [] |
|
|
|
|
|
suggestions = [] |
|
|
|
|
|
if cart_items: |
|
|
|
first_item = cart_items[0] |
|
item_category = first_item.get('Category__c', 'All') |
|
item_section = first_item.get('Section__c', 'Biryanis') |
|
|
|
|
|
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'] |
|
} |
|
|
|
|
|
suggested_sections = complementary_sections.get(item_section, []) |
|
|
|
|
|
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", [])) |
|
|
|
|
|
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: |
|
|
|
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', "") |
|
|
|
|
|
addons_price = 0 |
|
addons_string = "None" |
|
|
|
|
|
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 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', "") |
|
|
|
|
|
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 |
|
) |
|
|
|
|
|
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: |
|
|
|
total_price = float(item_price) + addons_price |
|
|
|
|
|
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', methods=['POST']) |
|
def add_to_cart(): |
|
try: |
|
|
|
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') |
|
customer_email = session.get('user_email') |
|
|
|
|
|
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 = 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", []) |
|
|
|
|
|
addons_price = sum(addon['price'] for addon in addons) |
|
new_addons = "; ".join([f"{addon['name']} (${addon['price']})" for addon in addons]) |
|
|
|
|
|
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', "") |
|
|
|
|
|
combined_addons = existing_addons if existing_addons != "None" else "" |
|
if new_addons: |
|
combined_addons = f"{combined_addons}; {new_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 |
|
) |
|
|
|
|
|
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) * item_price + combined_addons_price, |
|
"Category__c": category, |
|
"Section__c": section |
|
}) |
|
else: |
|
|
|
addons_string = "None" |
|
if addons: |
|
addons_string = new_addons |
|
|
|
total_price = item_price + addons_price |
|
|
|
|
|
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, |
|
"Category__c": category, |
|
"Section__c": section |
|
}) |
|
|
|
return jsonify({"success": True, "message": "Item added to cart successfully."}) |
|
|
|
except KeyError as e: |
|
|
|
return jsonify({"success": False, "error": f"Missing required field: {str(e)}"}), 400 |
|
|
|
except Exception as e: |
|
|
|
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_item", methods=["POST"]) |
|
def add_item_to_cart(): |
|
data = request.json |
|
email = data.get('email') |
|
item_name = data.get('item_name') |
|
quantity = data.get('quantity', 1) |
|
addons = data.get('addons', []) |
|
|
|
|
|
if not email or not item_name: |
|
return jsonify({"success": False, "error": "Email and item name are required."}), 400 |
|
|
|
try: |
|
|
|
sf.Cart_Item__c.create({ |
|
"Customer_Email__c": email, |
|
"Item_Name__c": item_name, |
|
"Quantity__c": quantity, |
|
"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)}") |
|
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') |
|
|
|
|
|
if not item_name or not item_section: |
|
return jsonify({"success": False, "error": "Item name and section are required."}), 400 |
|
|
|
try: |
|
|
|
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', []) |
|
|
|
|
|
if not addons: |
|
return jsonify({"success": False, "error": "No customization options found for the given section."}), 404 |
|
|
|
|
|
formatted_addons = [] |
|
for addon in addons: |
|
|
|
options = addon.get("Options__c", "") |
|
if options: |
|
options = options.split(", ") |
|
else: |
|
options = [] |
|
|
|
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: |
|
|
|
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 |
|
email = data.get('email') |
|
item_name = data.get('item_name') |
|
try: |
|
|
|
quantity = int(data.get('quantity')) |
|
except (ValueError, TypeError): |
|
return jsonify({"success": False, "error": "Invalid quantity provided."}), 400 |
|
|
|
|
|
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: |
|
|
|
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 |
|
|
|
|
|
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) |
|
|
|
|
|
new_item_price = (base_price * quantity) + addons_price |
|
|
|
|
|
sf.Cart_Item__c.update(cart_item_id, { |
|
"Quantity__c": quantity, |
|
"Price__c": new_item_price, |
|
}) |
|
|
|
|
|
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 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') |
|
|
|
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() |
|
|
|
|
|
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 |
|
|
|
|
|
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 |
|
referral_coupon_id = coupon_query["records"][0]["Id"] |
|
existing_coupons = coupon_query["records"][0]["Coupon_Code__c"].split("\n") |
|
|
|
|
|
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 |
|
|
|
|
|
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 |
|
|
|
|
|
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 |
|
) |
|
|
|
|
|
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"}) |
|
|
|
|
|
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 |
|
} |
|
|
|
sf.Order__c.create(order_data) |
|
|
|
|
|
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') |
|
if not email: |
|
return redirect(url_for("login")) |
|
|
|
try: |
|
|
|
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 |
|
|
|
|
|
|
|
|
|
if __name__ == "__main__": |
|
app.run(debug=True, host="0.0.0.0", port=7860) |