app.py

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 details
try:
    print("Attempting to connect to Salesforce...")
    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 create_salesforce_record(sf, 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(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 create_salesforce_order(sf, cart_items, total_price, customer_id):
    # Creating an order record in Salesforce after the customer places the final order
    try:
        order = sf.Order__c.create({
            'Total_Price__c': total_price,
            'Cart_Items__c': json.dumps(cart_items),  # Storing cart items as JSON (you can refine this as needed)
            'Customer__c': customer_id  # Linking to the customer record
        })
        return order
    except Exception as e:
        raise Exception(f"Failed to create order: {str(e)}")

# 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

# Routes and Views
@app.route("/")
def index():
    return render_template("index.html")

@app.route("/dashboard", methods=["GET"])
def dashboard():
    # This route will render the dashboard page
    return render_template("dashboard.html")  # Render the dashboard template

@app.route("/menu", methods=["GET"])
def menu_page():
    # Fetch the menu items from Salesforce
    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():
    # Retrieve cart items from the session
    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():
    # Retrieve order details from session
    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():
    # Process the final order and create an order record in Salesforce
    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

    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():
    # Add item to the cart (example for cart item data: item_name, quantity)
    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 for now
    session['cart_items'] = cart_items
    
    return jsonify({"success": True, "message": f"Added {item_name} to cart."})

# Start Production Server
if __name__ == "__main__":
    serve(app, host="0.0.0.0", port=7860)