Update app.py

app.py

@@ -1,138 +1,194 @@
-import torch
-from flask import Flask, render_template, request, jsonify, redirect, url_for
+from flask import Flask, render_template, request, jsonify, session
+from simple_salesforce import Salesforce
 import json
 import os
+import time
 from transformers import pipeline
+import torch
 from gtts import gTTS
 from pydub import AudioSegment
 from pydub.silence import detect_nonsilent
-from transformers import AutoConfig
-import time
+from transformers import AutoConfig  # Import AutoConfig for the config object
 from waitress import serve
-from simple_salesforce import Salesforce
-import requests
 
 app = Flask(__name__)
-
-# Use whisper-small for faster processing and better speed
-device = "cuda" if torch.cuda.is_available() else "cpu"
-
-# Create config object to set timeout and other parameters
-config = AutoConfig.from_pretrained("openai/whisper-small")
-config.update({"timeout": 60})  # Set timeout to 60 seconds
+app.secret_key = 'your_secret_key_here'  # Secret key for session management
+
+# Sample menu data
+menu_data = {
+    "Main Course": [
+        {"name": "Chicken Biryani", "price": 250},
+        {"name": "Veg Biryani", "price": 200},
+        {"name": "Mutton Biryani", "price": 300},
+    ],
+    "Appetizers": [
+        {"name": "Paneer Tikka", "price": 180},
+        {"name": "Chicken Wings", "price": 220},
+    ]
+}
 
 # Salesforce credentials (Replace with actual values)
 try:
     print("Attempting to connect to Salesforce...")
     sf = Salesforce(username='[email protected]', password='Sati@1020', security_token='sSSjyhInIsUohKpG8sHzty2q')
     print("Connected to Salesforce successfully!")
+    print("User Info:", sf.UserInfo)  # Log the user info to verify the connection
 except Exception as e:
     print(f"Failed to connect to Salesforce: {str(e)}")
 
-# Function for Salesforce operations
-def create_salesforce_record(name, email, phone_number):
-    try:
-        customer_login = sf.Customer_Login__c.create({
-            'Name': name,
-            'Email__c': email,
-            'Phone_Number__c': phone_number
-        })
-        return customer_login
-    except Exception as e:
-        raise Exception(f"Failed to create record: {str(e)}")
-
-def get_menu_items():
-    query = "SELECT Name, Price__c, Ingredients__c, Category__c FROM Menu_Item__c"
-    result = sf.query(query)
-    return result['records']
-
-# Login validation function
-def validate_user(email, phone):
-    query = f"SELECT Id, Name, Email__c, Phone_Number__c FROM Customer_Login__c WHERE Email__c = '{email}' AND Phone_Number__c = '{phone}'"
-    result = sf.query(query)
-    if result['records']:
-        return result['records'][0]  # Return user record if found
-    return None  # Return None if user not found
-
-# Routes and Views
+# Setup Whisper ASR model and Salesforce credentials
+device = "cuda" if torch.cuda.is_available() else "cpu"
+config = AutoConfig.from_pretrained("openai/whisper-small")
+config.update({"timeout": 60})
+
+# Route for the Welcome Page (Page 1)
 @app.route("/")
 def index():
     return render_template("index.html")
 
-@app.route("/login", methods=["POST"])
-def login():
-    # Get data from the form
-    email = request.form.get("email")
-    phone = request.form.get("phone")
+# Route for the Menu Pages (Page 2)
+@app.route("/menu", methods=["GET"])
+def menu_page():
+    category = request.args.get('category', 'Main Course')
+    if category not in menu_data:
+        return jsonify({"error": "Category not found"}), 404
+    return render_template("menu_page.html", menu_items=menu_data[category])
+
+# Route to add items to the cart
+@app.route("/add-to-cart", methods=["POST"])
+def add_to_cart():
+    item_data = request.get_json()
+    item_name = item_data.get('name')
+    item_price = item_data.get('price')
+    
+    # If cart is not in session, initialize it
+    if 'cart' not in session:
+        session['cart'] = []
     
-    if not email or not phone:
-        return jsonify({"success": False, "message": "Email and phone number are required."}), 400
+    # Add item to the cart
+    session['cart'].append({"name": item_name, "price": item_price})
     
-    # Validate user
-    user = validate_user(email, phone)
-    if user:
-        # User found, redirect to menu or dashboard
-        return redirect(url_for("menu_page"))  # Assuming login redirects to the menu
-    else:
-        return jsonify({"success": False, "message": "Invalid credentials. Please try again."}), 401
+    return jsonify({"message": f"{item_name} added to cart!"}), 200
 
-@app.route("/menu", methods=["GET"])
-def menu_page():
-    menu_items = get_menu_items()
-    menu_data = [{"name": item['Name'], "price": item['Price__c'], "ingredients": item['Ingredients__c'], "category": item['Category__c']} for item in menu_items]
-    return render_template("menu_page.html", menu_items=menu_data)
+# Route for Cart Page (Page 3)
+@app.route("/cart", methods=["GET"])
+def cart_page():
+    if 'cart' not in session or len(session['cart']) == 0:
+        return jsonify({"message": "Your cart is empty"}), 200
+    return render_template("cart_page.html", cart_items=session['cart'])
 
+# Route to place an order (API integration for placing order)
 @app.route("/order", methods=["POST"])
 def place_order():
-    item_name = request.json.get('item_name')
-    quantity = request.json.get('quantity')
-    order_data = {"Item__c": item_name, "Quantity__c": quantity}
-    sf.Order__c.create(order_data)
-    return jsonify({"success": True, "message": f"Order for {item_name} placed successfully."})
+    if 'cart' not in session or len(session['cart']) == 0:
+        return jsonify({"message": "Cart is empty, cannot place order."}), 400
+    
+    order_data = session['cart']
+    
+    # Here you can integrate with your API or Salesforce
+    # Example: Call Salesforce API to store the order
+    salesforce_response = send_to_salesforce(order_data)
 
-@app.route("/cart", methods=["GET"])
-def cart():
-    cart_items = []  # Placeholder for cart items
-    return render_template("cart_page.html", cart_items=cart_items)
+    # Simulate order processing with a success message
+    session['cart'] = []  # Clear the cart after order
+    return jsonify({"message": "Order placed successfully!", "order_data": order_data, "salesforce_response": salesforce_response}), 200
 
-@app.route("/order-summary", methods=["GET"])
-def order_summary():
-    order_details = []  # Placeholder for order details
-    return render_template("order_summary.html", order_details=order_details)
+# Salesforce integration function
+def send_to_salesforce(order_data):
+    try:
+        # Salesforce authentication
+        sf = Salesforce(username='[email protected]', password='Sati@1020', security_token='sSSjyhInIsUohKpG8sHzty2q')
 
-@app.route('/submit', methods=['POST'])
-def submit():
+        # Example: Create an Order record in Salesforce
+        order = sf.Order__c.create({
+            'Name': 'New Order',
+            'Items__c': str(order_data)  # Example field for items (this could be a custom Salesforce field)
+        })
+        return order
+    except Exception as e:
+        print(f"Error: {e}")
+        return None
+
+# Route to register a new user
+@app.route('/register', methods=['POST'])
+def register():
     try:
         data = request.get_json()
-        if not data:
-            return jsonify({"success": False, "message": "Invalid or empty JSON received"}), 400
-
-        # Get the values from the JSON data
-        name = data.get("name")
-        email = data.get("email")
-        phone = data.get("phone")
+        name = data.get('name')
+        email = data.get('email')
+        phone = data.get('phone')
 
-        # Validate if all fields are present
         if not name or not email or not phone:
-            return jsonify({"success": False, "message": "Missing required fields"}), 400
+            return jsonify({"success": False, "message": "All fields are required."}), 400
 
-        salesforce_data = {
-            "Name": name,
-            "Email__c": email,
-            "Phone_Number__c": phone
-        }
+        # Create a new record in Salesforce's Customer_Login__c object
+        customer_login = sf.Customer_Login__c.create({
+            'Name': name,
+            'Email__c': email,
+            'Phone_Number__c': phone
+        })
+        
+        return jsonify({"success": True, "message": "Registration successful!", "salesforce_response": customer_login}), 201
 
-        try:
-            result = sf.Customer_Login__c.create(salesforce_data)
-            return jsonify({"success": True, "message": "Data submitted successfully"})
-        except Exception as e:
-            print(f"Salesforce Insertion Error: {str(e)}")
-            return jsonify({"success": False, "message": "Salesforce submission failed", "error": str(e)}), 500
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        return jsonify({"success": False, "message": f"Registration failed: {str(e)}"}), 500
+
+# Route to validate login credentials
+@app.route('/validate-login', methods=['POST'])
+def validate_login():
+    try:
+        data = request.get_json()
+        login_email = data.get("email")
+        login_mobile = data.get("mobile")
+
+        if not login_email or not login_mobile:
+            return jsonify({"success": False, "message": "Missing email or mobile number"}), 400
+
+        # Query Salesforce to check if the record exists
+        query = f"SELECT Id, Name, Email__c, Phone_Number__c FROM Customer_Login__c WHERE Email__c = '{login_email}' AND Phone_Number__c = '{login_mobile}'"
+        result = sf.query(query)
+
+        if result['records']:
+            # If a matching record is found, return success and the name
+            user_name = result['records'][0]['Name']
+            return jsonify({"success": True, "message": "Login successful", "name": user_name})
+        else:
+            return jsonify({"success": False, "message": "Invalid email or mobile number"}), 401
 
     except Exception as e:
-        print(f"Server Error: {str(e)}")
+        print(f"Error validating login: {str(e)}")
         return jsonify({"success": False, "message": "Internal server error", "error": str(e)}), 500
 
-# Main function to run the application
+
+# Voice-related functions
+def generate_audio_prompt(text, filename):
+    try:
+        tts = gTTS(text)
+        tts.save(os.path.join("static", filename))
+    except gtts.tts.gTTSError as e:
+        print(f"Error: {e}")
+        print("Retrying after 5 seconds...")
+        time.sleep(5)  # Wait for 5 seconds before retrying
+        generate_audio_prompt(text, filename)
+
+# Utility functions
+def convert_to_wav(input_path, output_path):
+    try:
+        audio = AudioSegment.from_file(input_path)
+        audio = audio.set_frame_rate(16000).set_channels(1)  # Convert to 16kHz, mono
+        audio.export(output_path, format="wav")
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        raise Exception(f"Audio conversion failed: {str(e)}")
+
+def is_silent_audio(audio_path):
+    audio = AudioSegment.from_wav(audio_path)
+    nonsilent_parts = detect_nonsilent(audio, min_silence_len=500, silence_thresh=audio.dBFS-16)  # Reduced silence duration
+    print(f"Detected nonsilent parts: {nonsilent_parts}")
+    return len(nonsilent_parts) == 0  # If no speech detected
+
+
+# Start Production Server
 if __name__ == "__main__":
     serve(app, host="0.0.0.0", port=7860)