Update app.py

app.py

@@ -1,51 +1,33 @@
 
-import os
-import json
-import time
+import torch
 from flask import Flask, render_template, request, jsonify, redirect, session
+import json
+import os
 from transformers import pipeline
 from gtts import gTTS
 from pydub import AudioSegment
 from pydub.silence import detect_nonsilent
+from transformers import AutoConfig
+import time
 from waitress import serve
 from simple_salesforce import Salesforce
+import requests
 
 # Initialize Flask app
 app = Flask(__name__)
 app.secret_key = os.urandom(24)  # For session handling
 
-# Salesforce Connection
+# Salesforce connection details
 try:
     print("Attempting to connect to Salesforce...")
-    sf = Salesforce(
-        username=os.getenv('[email protected]'), 
-        password=os.getenv('Sati@1020'), 
-        security_token=os.getenv('sSSjyhInIsUohKpG8sHzty2q')
-    )
+    sf = Salesforce(username='[email protected]', password='Sati@1020', security_token='sSSjyhInIsUohKpG8sHzty2q')
     print("Connected to Salesforce successfully!")
 except Exception as e:
     print(f"Failed to connect to Salesforce: {str(e)}")
 
 # Functions for Salesforce operations
-def get_customer_by_email(email):
-    """Check if customer exists in Salesforce."""
-    try:
-        query = f"SELECT Id FROM Customer_Login__c WHERE Email__c = '{email}'"
-        result = sf.query(query)
-        if result['records']:
-            return result['records'][0]['Id']
-        return None
-    except Exception as e:
-        print(f"Error fetching customer: {str(e)}")
-        return None
-
-def create_salesforce_record(name, email, phone_number):
-    """Create customer login record in Salesforce."""
+def create_salesforce_record(sf, name, email, phone_number):
     try:
-        existing_customer = get_customer_by_email(email)
-        if existing_customer:
-            return {"id": existing_customer}  # Return existing customer ID
-
         customer_login = sf.Customer_Login__c.create({
             'Name': name,
             'Email__c': email,
@@ -55,49 +37,58 @@ def create_salesforce_record(name, email, phone_number):
     except Exception as e:
         raise Exception(f"Failed to create record: {str(e)}")
 
-def create_salesforce_order(cart_items, total_price, customer_id):
-    """Create order in Salesforce."""
+def create_salesforce_order(sf, cart_items, total_price, customer_id):
     try:
         order = sf.Order__c.create({
             'Total_Price__c': total_price,
-            'Cart_Items__c': json.dumps(cart_items),
-            'Customer__c': customer_id
+            'Cart_Items__c': json.dumps(cart_items),  # Storing cart items as JSON
+            'Customer__c': customer_id  # Linking to the customer record
         })
         return order
     except Exception as e:
         raise Exception(f"Failed to create order: {str(e)}")
 
-def get_menu_items():
-    """Fetch menu items from Salesforce."""
-    try:
-        query = "SELECT Name, Price__c, Ingredients__c, Category__c FROM Menu_Item__c"
-        result = sf.query(query)
-        return result.get('records', [])
-    except Exception as e:
-        print(f"Error fetching menu items: {str(e)}")
-        return []
+def get_menu_items(sf):
+    # Query to get menu items from Salesforce (assuming Menu_Item__c is the Salesforce object)
+    query = "SELECT Name, Price__c, Ingredients__c, Category__c FROM Menu_Item__c"
+    result = sf.query(query)
+    return result['records']
 
-# Voice-Related Functions
+# Voice-related functions
 def generate_audio_prompt(text, filename):
-    """Generate speech from text using gTTS."""
     try:
         tts = gTTS(text)
         tts.save(os.path.join("static", filename))
-    except Exception as e:
+    except gtts.tts.gTTSError as e:
         print(f"Error: {e}")
         print("Retrying after 5 seconds...")
-        time.sleep(5)
+        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
+
 # Routes and Views
 @app.route("/")
 def index():
     return render_template("index.html")
 
-@app.route("/register", methods=["POST"])
-def register():
-    """Handles new user registration."""
-    data = request.json
+@app.route("/login", methods=["POST"])
+def login():
+    data = request.json  # Assuming voice bot sends JSON data
     name = data.get('name')
     email = data.get('email')
     phone_number = data.get('phone_number')
@@ -106,85 +97,54 @@ def register():
         return jsonify({'error': 'Missing required fields'}), 400
 
     try:
-        customer = create_salesforce_record(name, email, phone_number)
-        session['customer_id'] = customer['id']
-        return jsonify({'message': 'User registered successfully', 'customer_id': customer['id']}), 201
+        customer_login = create_salesforce_record(sf, name, email, phone_number)
+        session['customer_id'] = customer_login['id']  # Store customer ID in session
+        return redirect("/menu")  # Redirect to the menu page after successful login
     except Exception as e:
-        return jsonify({'error': f'Failed to register user: {str(e)}'}), 500
-
-@app.route("/login", methods=["POST"])
-def login():
-    """Handles customer login."""
-    data = request.json
-    email = data.get('email')
-
-    if not email:
-        return jsonify({'error': 'Email is required'}), 400
-
-    customer_id = get_customer_by_email(email)
-    if customer_id:
-        session['customer_id'] = customer_id
-        return jsonify({'message': 'Login successful', 'customer_id': customer_id}), 200
-    else:
-        return jsonify({'error': 'User not found'}), 404
+        return jsonify({'error': f'Failed to create record in Salesforce: {str(e)}'}), 500
 
 @app.route("/menu", methods=["GET"])
 def menu_page():
-    """Displays the menu from Salesforce."""
-    menu_items = get_menu_items()
-    if not menu_items:
-        return jsonify({'error': 'No menu items found'}), 404
-
-    menu_data = [
-        {"name": item['Name'], "price": item['Price__c'], "ingredients": item.get('Ingredients__c', ''), "category": item.get('Category__c', '')}
-        for item in menu_items
-    ]
+    menu_items = get_menu_items(sf)  # Fetch menu items from Salesforce
+    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)
 
 @app.route("/cart", methods=["GET"])
 def cart():
-    """Displays the cart."""
     cart_items = session.get('cart_items', [])
     return render_template("cart_page.html", cart_items=cart_items)
 
 @app.route("/order-summary", methods=["GET"])
 def order_summary():
-    """Displays the order summary before finalizing."""
     order_details = session.get('cart_items', [])
     total_price = sum(item['price'] * item['quantity'] for item in order_details)
     return render_template("order_summary.html", order_details=order_details, total_price=total_price)
 
 @app.route("/final_order", methods=["GET"])
 def final_order():
-    """Handles final order placement."""
-    if 'cart_items' not in session or 'customer_id' not in session:
-        return jsonify({'error': 'No order details found'}), 400
-
     cart_items = session.get('cart_items', [])
     total_price = sum(item['price'] * item['quantity'] for item in cart_items)
-    customer_id = session['customer_id']
+    customer_id = session.get('customer_id', None)  # Get customer ID from session
 
-    try:
-        order = create_salesforce_order(cart_items, total_price, customer_id)
-        session.pop('cart_items', None)
-        return render_template("final_order.html", order_details=cart_items, total_price=total_price)
-    except Exception as e:
-        return jsonify({'error': f'Failed to create order in Salesforce: {str(e)}'}), 500
+    if customer_id:
+        try:
+            order = create_salesforce_order(sf, cart_items, total_price, customer_id)
+            session.pop('cart_items', None)  # Clear cart after placing the order
+            return render_template("final_order.html", order_details=cart_items, total_price=total_price)
+        except Exception as e:
+            return jsonify({'error': f'Failed to create order in Salesforce: {str(e)}'}), 500
+    else:
+        return jsonify({'error': 'Customer not logged in'}), 400
 
 @app.route("/add_to_cart", methods=["POST"])
 def add_to_cart():
-    """Adds an item to the cart."""
-    data = request.json
-    item_name = data.get('item_name')
-    quantity = data.get('quantity')
-
-    if not item_name or not quantity:
-        return jsonify({'error': 'Item name and quantity required'}), 400
-
+    item_name = request.json.get('item_name')
+    quantity = request.json.get('quantity')
+    
     cart_items = session.get('cart_items', [])
-    cart_items.append({"name": item_name, "quantity": quantity, "price": 10})  # Assuming a fixed price
+    cart_items.append({"name": item_name, "quantity": quantity, "price": 10})  # Assuming a fixed price for now
     session['cart_items'] = cart_items
-
+    
     return jsonify({"success": True, "message": f"Added {item_name} to cart."})
 
 # Start Production Server