Update app.py

app.py

@@ -1,159 +1,125 @@
-import os
-import time
-import logging
-import json
-import requests
 import torch
-from flask import Flask, render_template, request, jsonify, session
-from flask_session import Session
-from simple_salesforce import Salesforce
+from flask import Flask, render_template, request, jsonify, redirect, url_for
+import os
 from transformers import pipeline, AutoConfig
-from gtts import gTTS
 from pydub import AudioSegment
 from pydub.silence import detect_nonsilent
+import time
 from waitress import serve
+from simple_salesforce import Salesforce
+import requests
 
 app = Flask(__name__)
 
-# Configure Flask session
-app.secret_key = os.getenv("SECRET_KEY", "sSSjyhInIsUohKpG8sHzty2q")
-app.config["SESSION_TYPE"] = "filesystem"
-Session(app)
+# Use whisper-small for faster processing
+device = "cuda" if torch.cuda.is_available() else "cpu"
 
-# Set up logging
-logging.basicConfig(level=logging.INFO)
+# Whisper ASR Model Configuration
+config = AutoConfig.from_pretrained("openai/whisper-small")
+config.update({"timeout": 60})  # Set timeout to 60 seconds
 
-# Connect to Salesforce
+# Salesforce Connection
 try:
+    print("Connecting to Salesforce...")
     sf = Salesforce(username='diggavalli98@gmail.com', password='Sati@1020', security_token='sSSjyhInIsUohKpG8sHzty2q')
-    print("✅ Connected to Salesforce successfully!")
+    print("Connected to Salesforce!")
 except Exception as e:
-    print(f"❌ Failed to connect to Salesforce: {str(e)}")
-
-# Whisper ASR Configuration
-device = "cuda" if torch.cuda.is_available() else "cpu"
-config = AutoConfig.from_pretrained("openai/whisper-small")
-config.update({"timeout": 60})
-
-# Voice prompts
-prompts = {
-    "welcome": "Welcome to Biryani Hub.",
-    "ask_name": "Tell me your name.",
-    "ask_email": "Please provide your email address.",
-    "thank_you": "Thank you for registration."
-}
-
-# Function to generate voice prompts
-def generate_audio_prompt(text, filename):
-    try:
-        tts = gTTS(text)
-        tts.save(os.path.join("static", filename))
-    except gtts.tts.gTTSError as e:
-        time.sleep(5)
-        generate_audio_prompt(text, filename)
-
-for key, text in prompts.items():
-    generate_audio_prompt(text, f"{key}.mp3")
+    print(f"Failed to connect to Salesforce: {str(e)}")
 
 # Function to convert audio to WAV format
 def convert_to_wav(input_path, output_path):
-    audio = AudioSegment.from_file(input_path)
-    audio = audio.set_frame_rate(16000).set_channels(1)
-    audio.export(output_path, format="wav")
+    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"Audio conversion failed: {str(e)}")
+        raise
 
-# Function to check if audio contains actual speech
+# Check if audio contains speech
 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)
-    return len(nonsilent_parts) == 0
-
-@app.route("/")
-def index():
-    return render_template("index.html")
-
-# ✅ LOGIN ENDPOINT
-@app.route('/login', methods=['POST'])
-def login():
-    data = request.json
-    email = data.get('email', '').strip().lower()
-    phone_number = data.get('phone_number', '').strip()
-
-    if not email or not phone_number:
-        return jsonify({'error': 'Missing email or phone number'}), 400
+    return len(nonsilent_parts) == 0  # If no speech detected
 
+# Create Salesforce Record
+def create_salesforce_record(name, email, phone_number):
     try:
-        query = f"SELECT Id, Name FROM Customer_Login__c WHERE LOWER(Email__c) = '{email}' AND Phone_Number__c = '{phone_number}' LIMIT 1"
-        result = sf.query(query)
-
-        if result['totalSize'] == 0:
-            return jsonify({'error': 'Invalid email or phone number. User not found'}), 401
-
-        user_data = result['records'][0]
-        session['user_id'] = user_data['Id']
-        session['name'] = user_data['Name']
-
-        return jsonify({'success': True, 'message': 'Login successful', 'user_id': user_data['Id'], 'name': user_data['Name']}), 200
-
+        response = sf.Customer_Login__c.create({
+            'Name': name,
+            'Email__c': email,
+            'Phone_Number__c': phone_number
+        })
+        return {'success': True, 'id': response.get('id')}
     except Exception as e:
-        return jsonify({'error': f'Unexpected error: {str(e)}'}), 500
+        return {'error': f'Failed to create record: {str(e)}'}
 
-# ✅ REGISTRATION ENDPOINT
-@app.route("/register", methods=["POST"])
-def register():
+# Registration API
+@app.route("/submit", methods=["POST"])
+def submit():
     data = request.json
-    name = data.get('name', '').strip()
-    email = data.get('email', '').strip().lower()
-    phone = data.get('phone', '').strip()
+    name = data.get('name')
+    email = data.get('email')
+    phone = data.get('phone')
 
     if not name or not email or not phone:
         return jsonify({'error': 'Missing data'}), 400
 
-    try:
-        query = f"SELECT Id FROM Customer_Login__c WHERE LOWER(Email__c) = '{email}' AND Phone_Number__c = '{phone}' LIMIT 1"
-        existing_user = sf.query(query)
+    response = create_salesforce_record(name, email, phone)
+    return jsonify(response) if "error" not in response else (jsonify(response), 500)
 
-        if existing_user['totalSize'] > 0:
-            return jsonify({'error': 'User already exists'}), 409
+# Updated Login API (Only for Registered Users)
+@app.route('/login', methods=['POST'])
+def login():
+    data = request.json
+    email = data.get('email')
+    phone_number = data.get('phone_number')
 
-        customer_login = sf.Customer_Login__c.create({
-            'Name': name,
-            'Email__c': email,
-            'Phone_Number__c': phone
-        })
+    if not email or not phone_number:
+        return jsonify({'error': 'Email and phone number are required'}), 400
 
-        if customer_login.get('id'):
-            return jsonify({'success': True, 'user_id': customer_login['id']}), 200
+    try:
+        # Print received login details for debugging
+        print(f"🔍 Received login request for Email: {email}, Phone: {phone_number}")
+
+        # Query Salesforce to check if the user exists
+        query_result = sf.query(f"""
+            SELECT Id, Name, Email__c, Phone_Number__c FROM Customer_Login__c 
+            WHERE LOWER(Email__c) = '{email.lower()}' 
+            AND Phone_Number__c = '{phone_number}'
+        """)
+
+        # Debugging: Print Salesforce Query Result
+        print("🔍 Salesforce Query Result:", query_result)
+
+        if query_result['totalSize'] > 0:
+            print("✅ Login successful!")
+            return jsonify({
+                'success': True, 
+                'message': 'Login successful',
+                'user': query_result['records'][0],
+                'redirect': '/dashboard'
+            }), 200
         else:
-            return jsonify({'error': 'Failed to create record'}), 500
-
+            print("❌ Invalid credentials! User not found in Salesforce.")  # Debugging
+            return jsonify({'error': 'Invalid credentials! Only registered users can log in.', 'refresh': True}), 401  
     except Exception as e:
-        return jsonify({'error': str(e)}), 500
+        print(f"⚠️ Salesforce Query Failed: {str(e)}")  # Debugging
+        return jsonify({'error': f'Salesforce query failed: {str(e)}', 'refresh': True}), 500
 
-# ✅ TRANSCRIPTION ENDPOINT
-@app.route("/transcribe", methods=["POST"])
-def transcribe():
-    if "audio" not in request.files:
-        return jsonify({"error": "No audio file provided"}), 400
-
-    audio_file = request.files["audio"]
-    input_audio_path = os.path.join("static", "temp_input.wav")
-    output_audio_path = os.path.join("static", "temp.wav")
-    audio_file.save(input_audio_path)
-
-    try:
-        convert_to_wav(input_audio_path, output_audio_path)
-
-        if is_silent_audio(output_audio_path):
-            return jsonify({"error": "No speech detected. Please try again."}), 400
-
-        result = pipeline("automatic-speech-recognition", model="openai/whisper-small", device=0 if torch.cuda.is_available() else -1, config=config)
-        transcribed_text = result(output_audio_path)["text"].strip().capitalize()
+# Serve Registration and Login Pages
+@app.route("/")
+def index():
+    return render_template("index.html")
 
-        return jsonify({"text": transcribed_text})
+@app.route("/login-page")
+def login_page():
+    return render_template("login.html")
 
-    except Exception as e:
-        return jsonify({"error": f"Speech recognition error: {str(e)}"}), 500
+@app.route("/dashboard")
+def dashboard():
+    return "<h1>Welcome to the Dashboard</h1><p>You have successfully logged in.</p>"
 
-# Start Production Server
+# Start the Flask App
 if __name__ == "__main__":
-    serve(app, host="0.0.0.0", port=7860)
+    serve(app, host="0.0.0.0", port=7860)