Update app.py

app.py

@@ -1,161 +1,180 @@
+# app.py
 import gradio as gr
-from simplesalesforce import Salesforce
-import re
-import random
-import smtplib
-from email.mime.text import MIMEText
+from simple_salesforce import Salesforce
 from datetime import datetime, timedelta
+import random
+
+# Salesforce Authentication
 
-# Salesforce Connection
 sf = Salesforce(username='diggavalli98@gmail.com', password='Sati@1020', security_token='sSSjyhInIsUohKpG8sHzty2q')
 
-# Helper Functions
-otp_storage = {}
 
-def send_otp(email):
-    otp = random.randint(100000, 999999)
-    otp_expiration = datetime.now() + timedelta(minutes=2)
-    otp_storage[email] = {'otp': otp, 'expires': otp_expiration}
-    
-    # Sending email (Replace with actual SMTP setup)
-    msg = MIMEText(f"Your OTP is {otp}. It expires in 2 minutes.")
-    msg['Subject'] = 'Your OTP'
-    msg['From'] = 'your_email@example.com'
-    msg['To'] = email
+otp_data = {}  # Temporary OTP storage
+
+# Navigation state
+current_page = "login"
+
+def set_page(page):
+    global current_page
+    current_page = page
+
+# Login Page Function
+def login(email, password):
+    global current_page
     try:
-        with smtplib.SMTP('smtp.example.com', 587) as server:
-            server.starttls()
-            server.login('your_email@example.com', 'your_email_password')
-            server.send_message(msg)
-        return "OTP sent successfully."
+        query_result = sf.query(f"SELECT Password__c FROM Customer_Login__c WHERE Email__c = '{email}'")
+        if not query_result['records']:
+            return "Error: Email not found."
+        
+        stored_password = query_result['records'][0]['Password__c']
+        if password != stored_password:
+            return "Error: Invalid password."
+
+        sf.Customer_Login__c.update(query_result['records'][0]['Id'], {'Login_Status__c': 'Logged In'})
+        set_page("menu")
+        return "Login successful! Redirecting to menu..."
     except Exception as e:
-        return f"Error sending OTP: {str(e)}"
-
-def validate_email(email):
-    regex = r'^\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
-    return re.match(regex, email)
+        return f"Error: {str(e)}"
 
-def validate_password(password):
-    if (len(password) >= 6 and len(password) <= 10 and
-        re.search(r'[A-Z]', password) and
-        re.search(r'[a-z]', password) and
-        re.search(r'\d', password) and
-        re.search(r'[!@#$%^&*]', password)):
-        return True
-    return False
+def login_ui():
+    return gr.Interface(
+        fn=login,
+        inputs=[gr.Textbox(label="Email"), gr.Password(label="Password")],
+        outputs="text",
+        title="Login Page"
+    )
 
-# Functions for Gradio
+# Signup Page Functions
+def send_otp(email):
+    try:
+        query_result = sf.query(f"SELECT Id FROM Customer_Login__c WHERE Email__c = '{email}'")
+        if query_result['records']:
+            return "Error: Email already registered."
+
+        otp = random.randint(100000, 999999)
+        otp_data[email] = {
+            "otp": otp,
+            "expiration": datetime.now() + timedelta(minutes=2)
+        }
+        print(f"OTP for {email}: {otp}")  # Simulated email sending
+        return "OTP sent successfully! Check your email."
+    except Exception as e:
+        return f"Error: {str(e)}"
 
-def login(email, password):
-    if not email or not password:
-        return "Email and Password cannot be empty."
-
-    query = sf.query(f"SELECT Id, Password__c FROM Customer_Login__c WHERE Email__c = '{email}'")
-    if not query['records']:
-        return "Invalid email or password."
-
-    record = query['records'][0]
-    if password == record['Password__c']:
-        sf.Customer_Login__c.update(record['Id'], {'Login_Status__c': 'Logged In'})
-        return "Login successful. Redirecting to the menu page..."
-    else:
-        return "Invalid email or password."
-
-def signup(name, email, password, phone, otp, verify_otp):
-    if not all([name, email, password, phone, otp]):
-        return "All fields are required."
-
-    if not validate_email(email):
-        return "Invalid email format."
-
-    if not validate_password(password):
-        return "Password does not meet complexity requirements."
-
-    if otp_storage.get(email) and otp_storage[email]['otp'] == int(otp):
-        if datetime.now() > otp_storage[email]['expires']:
-            return "OTP has expired. Please resend OTP."
-
-        # Store data in Salesforce
-        try:
-            sf.Customer_Login__c.create({
-                'Name': name,
-                'Email__c': email,
-                'Password__c': password,
-                'Phone_Number__c': phone,
-                'OTP__c': str(otp),
-                'OTP_Expiration__c': otp_storage[email]['expires'],
-                'Login_Status__c': 'Logged Out'
-            })
-            return "Signup successful. Please log in."
-        except Exception as e:
-            return f"Error storing data: {str(e)}"
-    else:
-        return "Invalid OTP."
-
-def forgot_password(email, otp, new_password, confirm_password):
-    if not email:
-        return "Email is required."
-
-    if not validate_email(email):
-        return "Invalid email format."
-
-    if email in otp_storage and otp_storage[email]['otp'] == int(otp):
-        if datetime.now() > otp_storage[email]['expires']:
-            return "OTP has expired."
-
-        if new_password != confirm_password:
-            return "Passwords do not match."
-
-        if not validate_password(new_password):
-            return "Password does not meet complexity requirements."
-
-        # Update password in Salesforce
-        query = sf.query(f"SELECT Id FROM Customer_Login__c WHERE Email__c = '{email}'")
-        if query['records']:
-            record_id = query['records'][0]['Id']
-            sf.Customer_Login__c.update(record_id, {'Password__c': new_password})
-            return "Password updated successfully."
-        else:
-            return "Email not found."
-    else:
-        return "Invalid OTP."
-
-# Gradio Interface
-login_ui = gr.Interface(
-    fn=login,
-    inputs=[gr.Textbox(label="Email"), gr.Textbox(label="Password", type="password")],
-    outputs="text",
-    title="Login Page"
-)
-
-signup_ui = gr.Interface(
-    fn=signup,
-    inputs=[
-        gr.Textbox(label="Name"),
-        gr.Textbox(label="Email"),
-        gr.Textbox(label="Password", type="password"),
-        gr.Textbox(label="Phone Number"),
-        gr.Textbox(label="Enter OTP"),
-    ],
-    outputs="text",
-    title="Signup Page"
-)
-
-forgot_password_ui = gr.Interface(
-    fn=forgot_password,
-    inputs=[
-        gr.Textbox(label="Email"),
-        gr.Textbox(label="OTP"),
-        gr.Textbox(label="New Password", type="password"),
-        gr.Textbox(label="Confirm Password", type="password")
-    ],
-    outputs="text",
-    title="Forgot Password"
-)
-
-dashboard = gr.TabbedInterface(
-    [login_ui, signup_ui, forgot_password_ui],
-    tab_names=["Login", "Signup", "Forgot Password"]
-)
-
-dashboard.launch()
+def verify_otp(email, otp, name, password, phone):
+    try:
+        if email not in otp_data or otp_data[email]['expiration'] < datetime.now():
+            return "Error: OTP expired or invalid."
+
+        if otp_data[email]['otp'] != int(otp):
+            return "Error: Incorrect OTP."
+
+        if not (6 <= len(password) <= 10 and
+                any(c.isupper() for c in password) and
+                any(c.islower() for c in password) and
+                any(c.isdigit() for c in password) and
+                any(c in "!@#$%^&*" for c in password)):
+            return "Error: Password does not meet complexity requirements."
+
+        sf.Customer_Login__c.create({
+            "Name": name,
+            "Email__c": email,
+            "Password__c": password,
+            "Phone_Number__c": phone,
+            "Login_Status__c": "Logged Out"
+        })
+        del otp_data[email]
+        set_page("login")
+        return "Signup successful! Redirecting to login page..."
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def signup_ui():
+    return gr.Interface(
+        fn=lambda email, otp, name, password, phone: (
+            send_otp(email) if otp == "" else verify_otp(email, otp, name, password, phone)
+        ),
+        inputs=[
+            gr.Textbox(label="Email"),
+            gr.Textbox(label="OTP (Leave blank to send OTP)"),
+            gr.Textbox(label="Name"),
+            gr.Password(label="Password"),
+            gr.Textbox(label="Phone Number")
+        ],
+        outputs="text",
+        title="Signup Page"
+    )
+
+# Forgot Password Page Function
+def forgot_password(email, otp, new_password):
+    global current_page
+    try:
+        query_result = sf.query(f"SELECT Id FROM Customer_Login__c WHERE Email__c = '{email}'")
+        if not query_result['records']:
+            return "Error: Email not found."
+
+        if otp == "":
+            otp = random.randint(100000, 999999)
+            otp_data[email] = {
+                "otp": otp,
+                "expiration": datetime.now() + timedelta(minutes=2)
+            }
+            print(f"OTP for {email}: {otp}")
+            return "OTP sent successfully! Check your email."
+
+        if email in otp_data and otp_data[email]['otp'] == int(otp) and otp_data[email]['expiration'] > datetime.now():
+            if not (6 <= len(new_password) <= 10 and
+                    any(c.isupper() for c in new_password) and
+                    any(c.islower() for c in new_password) and
+                    any(c.isdigit() for c in new_password) and
+                    any(c in "!@#$%^&*" for c in new_password)):
+                return "Error: Password does not meet complexity requirements."
+
+            sf.Customer_Login__c.update(query_result['records'][0]['Id'], {"Password__c": new_password})
+            del otp_data[email]
+            set_page("login")
+            return "Password updated successfully! Redirecting to login page..."
+
+        return "Error: Invalid or expired OTP."
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def forgot_password_ui():
+    return gr.Interface(
+        fn=forgot_password,
+        inputs=[
+            gr.Textbox(label="Email"),
+            gr.Textbox(label="OTP (Leave blank to send OTP)"),
+            gr.Password(label="New Password")
+        ],
+        outputs="text",
+        title="Forgot Password Page"
+    )
+
+# Menu Page Function
+def menu_page():
+    global current_page
+    return "Welcome to the Menu Page! Select your options here."
+
+def menu_ui():
+    return gr.Interface(
+        fn=menu_page,
+        inputs=None,
+        outputs="text",
+        title="Menu Page"
+    )
+
+# Main App Logic
+def render_page():
+    if current_page == "login":
+        return login_ui()
+    elif current_page == "signup":
+        return signup_ui()
+    elif current_page == "forgot_password":
+        return forgot_password_ui()
+    elif current_page == "menu":
+        return menu_ui()
+
+# Launch App
+app = render_page()
+app.launch()