Update app.py

app.py

@@ -1,32 +1,54 @@
-import torch
-from flask import Flask, render_template, request, jsonify, redirect, session
-import json
 import os
+import json
+import time
+from flask import Flask, render_template, request, jsonify, redirect, session
 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
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
 
 # Initialize Flask app
 app = Flask(__name__)
 app.secret_key = os.urandom(24)  # For session handling
 
-# Salesforce connection details
+# Salesforce Connection
 try:
     print("Attempting to connect to Salesforce...")
-    sf = Salesforce(username='[email protected]', password='Sati@1020', security_token='sSSjyhInIsUohKpG8sHzty2q')
+    sf = Salesforce(
+        username=os.getenv('[email protected]'), 
+        password=os.getenv('Sati@1020'), 
+        security_token=os.getenv('sSSjyhInIsUohKpG8sHzty2q')
+    )
     print("Connected to Salesforce successfully!")
 except Exception as e:
     print(f"Failed to connect to Salesforce: {str(e)}")
 
 # Functions for Salesforce operations
-def create_salesforce_record(sf, name, email, phone_number):
+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."""
     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,
@@ -36,58 +58,49 @@ def create_salesforce_record(sf, name, email, phone_number):
     except Exception as e:
         raise Exception(f"Failed to create record: {str(e)}")
 
-def create_salesforce_order(sf, cart_items, total_price, customer_id):
+def create_salesforce_order(cart_items, total_price, customer_id):
+    """Create order in Salesforce."""
     try:
         order = sf.Order__c.create({
             'Total_Price__c': total_price,
-            'Cart_Items__c': json.dumps(cart_items),  # Storing cart items as JSON
-            'Customer__c': customer_id  # Linking to the customer record
+            'Cart_Items__c': json.dumps(cart_items),
+            'Customer__c': customer_id
         })
         return order
     except Exception as e:
         raise Exception(f"Failed to create order: {str(e)}")
 
-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']
+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 []
 
-# 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 gtts.tts.gTTSError as e:
+    except Exception as e:
         print(f"Error: {e}")
         print("Retrying after 5 seconds...")
-        time.sleep(5)  # Wait for 5 seconds before retrying
+        time.sleep(5)
         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("/login", methods=["POST"])
-def login():
-    data = request.json  # Assuming voice bot sends JSON data
+@app.route("/register", methods=["POST"])
+def register():
+    """Handles new user registration."""
+    data = request.json
     name = data.get('name')
     email = data.get('email')
     phone_number = data.get('phone_number')
@@ -96,54 +109,85 @@ def login():
         return jsonify({'error': 'Missing required fields'}), 400
 
     try:
-        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
+        customer = create_salesforce_record(name, email, phone_number)
+        session['customer_id'] = customer['id']
+        return jsonify({'message': 'User registered successfully', 'customer_id': customer['id']}), 201
     except Exception as e:
-        return jsonify({'error': f'Failed to create record in Salesforce: {str(e)}'}), 500
+        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
 
 @app.route("/menu", methods=["GET"])
 def menu_page():
-    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]
+    """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
+    ]
     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.get('customer_id', None)  # Get customer ID from session
+    customer_id = session['customer_id']
 
-    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
+    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
 
 @app.route("/add_to_cart", methods=["POST"])
 def add_to_cart():
-    item_name = request.json.get('item_name')
-    quantity = request.json.get('quantity')
-    
+    """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
+
     cart_items = session.get('cart_items', [])
-    cart_items.append({"name": item_name, "quantity": quantity, "price": 10})  # Assuming a fixed price for now
+    cart_items.append({"name": item_name, "quantity": quantity, "price": 10})  # Assuming a fixed price
     session['cart_items'] = cart_items
-    
+
     return jsonify({"success": True, "message": f"Added {item_name} to cart."})
 
 # Start Production Server