Update app.py

app.py

@@ -9,11 +9,11 @@ import os
 from urllib.parse import quote, unquote
 import time
 
-# Configure logging for audit purposes (FR4, NFR: Security)
+# Configure logging for audit purposes
 logging.basicConfig(level=logging.INFO, filename='app_log.txt', 
                     format='%(asctime)s - %(levelname)s - %(message)s')
 
-# Load environment variables (Hugging Face Spaces secrets)
+# Load environment variables
 SALESFORCE_USERNAME = os.getenv("SF_USERNAME", "app41@clinic.com")
 SALESFORCE_PASSWORD = os.getenv("SF_PASSWORD", "text@12345")
 SALESFORCE_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN", "6JgPkW3K5MPPGXDgc2JNxCUdB")
@@ -22,11 +22,10 @@ TWILIO_ACCOUNT_SID = os.getenv("TWILIO_ACCOUNT_SID", "AC80ba89ceecaa0f3058326f5c
 TWILIO_AUTH_TOKEN = os.getenv("TWILIO_AUTH_TOKEN", "13d8416e924902b19f8181b77c968060")
 TWILIO_PHONE = os.getenv("TWILIO_PHONE", "+13304226436")
 
-# Validate environment variables
 required_vars = [SALESFORCE_USERNAME, SALESFORCE_PASSWORD, SALESFORCE_SECURITY_TOKEN, SALESFORCE_INSTANCE_URL,
                  TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_PHONE]
 if not all(required_vars):
-    logging.error("Missing environment variables for API integrations.")
+    logging.error("Missing environment variables.")
     raise ValueError("Missing environment variables. Configure API tokens in Hugging Face Spaces secrets.")
 
 # Salesforce Authentication
@@ -56,7 +55,6 @@ def get_salesforce_access_token():
         logging.error(f"Salesforce authentication failed: {str(e)}")
         return None
 
-# Salesforce REST API Headers
 sf_auth = get_salesforce_access_token()
 if not sf_auth:
     logging.error("Failed to authenticate with Salesforce.")
@@ -67,7 +65,7 @@ SALESFORCE_HEADERS = {
     "Content-Type": "application/json"
 }
 
-# Hugging Face Client for Risk Analysis
+# Hugging Face Client
 class HuggingFaceClient:
     def __init__(self):
         self.api_url = "https://api-inference.huggingface.co/models/"
@@ -82,7 +80,7 @@ class HuggingFaceClient:
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:
-            logging.error(f"API request failed for model {model}: {str(e)}")
+            logging.error(f"API request failed: {str(e)}")
             return None
 
     def analyze_response(self, response_text):
@@ -127,29 +125,18 @@ class SalesforceClient:
         try:
             response = requests.post(f"{self.base_url}sobjects/{object_name}/", headers=self.headers, json=data)
             response.raise_for_status()
-            record_id = response.json()["id"]
-            logging.info(f"Created {object_name} record: {record_id}")
-            return record_id
-        except requests.exceptions.HTTPError as e:
-            error_message = f"HTTP error creating {object_name} record: {e.response.status_code} - {e.response.text}"
-            logging.error(error_message)
-            return error_message
-        except requests.exceptions.RequestException as e:
-            error_message = f"Failed to create {object_name} record: {str(e)}"
-            logging.error(error_message)
-            return error_message
+            return response.json()["id"]
+        except Exception as e:
+            logging.error(f"Create record failed: {str(e)}")
+            return None
 
     def update_record(self, object_name, record_id, data):
         try:
             response = requests.patch(f"{self.base_url}sobjects/{object_name}/{record_id}", headers=self.headers, json=data)
             response.raise_for_status()
-            logging.info(f"Updated {object_name} record: {record_id}")
             return True
-        except requests.exceptions.HTTPError as e:
-            logging.error(f"HTTP error updating {object_name} record: {e.response.status_code} - {e.response.text}")
-            return False
-        except requests.exceptions.RequestException as e:
-            logging.error(f"Failed to update {object_name} record: {str(e)}")
+        except Exception as e:
+            logging.error(f"Update record failed: {str(e)}")
             return False
 
     def query_records(self, query):
@@ -158,11 +145,8 @@ class SalesforceClient:
             response = requests.get(f"{self.base_url}query/?q={encoded_query}", headers=self.headers)
             response.raise_for_status()
             return response.json()["records"]
-        except requests.exceptions.HTTPError as e:
-            logging.error(f"HTTP error querying records: {e.response.status_code} - {e.response.text}")
-            return []
-        except requests.exceptions.RequestException as e:
-            logging.error(f"Failed to query records: {str(e)}")
+        except Exception as e:
+            logging.error(f"Query records failed: {str(e)}")
             return []
 
 # Twilio Client
@@ -175,99 +159,87 @@ class TwilioClient:
     def send_message(self, to_number, body, method="sms"):
         try:
             if not to_number.startswith("+"):
-                return "Invalid phone number format. Must start with +country_code."
+                return False
             to_number = f"whatsapp:{to_number}" if method == "whatsapp" else to_number
             from_number = f"whatsapp:{self.from_number}" if method == "whatsapp" else self.from_number
             data = {"From": from_number, "To": to_number, "Body": body}
             response = requests.post(self.api_url, auth=self.auth, data=data, timeout=10)
             response.raise_for_status()
-            logging.info(f"Sent {method.upper()} message to {to_number}")
             return True
-        except requests.exceptions.HTTPError as e:
-            logging.error(f"Twilio HTTP error: {e.response.status_code} - {e.response.text}")
-            return f"Twilio error: {e.response.text}"
-        except requests.exceptions.RequestException as e:
-            logging.error(f"Failed to send message: {str(e)}")
-            return str(e)
+        except Exception as e:
+            logging.error(f"Send message failed: {str(e)}")
+            return False
 
 # Initialize Clients
 hf_client = HuggingFaceClient()
 sf_client = SalesforceClient(SALESFORCE_BASE_URL, SALESFORCE_HEADERS)
 twilio_client = TwilioClient(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_PHONE)
 
-# Get patient info from URL parameters
+# Patient Info and State Management
 def get_patient_info():
     patient_id = unquote(os.getenv("patientId", ""))
     patient_name = unquote(os.getenv("patientName", ""))
     if patient_id and patient_name:
-        logging.info(f"Loaded patient: ID={patient_id}, Name={patient_name}")
         return patient_id, patient_name
-    logging.warning("No patient data from URL. Defaulting to manual input.")
     return None, None
 
 patient_id, patient_name = get_patient_info()
 patient_id_state = gr.State(value=patient_id)
 patient_name_state = gr.State(value=patient_name)
 
-# Follow-Up Scheduler (Simulated Cron Job)
+# Follow-Up Scheduler
 def follow_up_scheduler():
     while True:
         current_date = date.today().isoformat()
-        plans = sf_client.query_records(f"SELECT Patient__c, MessageContent__c FROM FollowUpPlan__c WHERE ScheduledDate__c = {current_date} AND Status__c = 'Scheduled'")
+        plans = sf_client.query_records(f"SELECT Patient__c, MessageContent__c FROM FollowUpPlan__c WHERE ScheduledDate__c = '{current_date}' AND Status__c = 'Scheduled'")
         for plan in plans:
-            patient = sf_client.query_records(f"SELECT Phone__c, ConsentGiven__c FROM Patient__c WHERE Id = '{plan['Patient__c']}'")[0]
-            if patient["ConsentGiven__c"]:
-                message = plan["MessageContent__c"] or f"Hi {patient_name_state.value}, this is your daily follow-up check-in."
-                twilio_client.send_message(patient["Phone__c"], message)
-                sf_client.create_record("MessageLog__c", {
-                    "Patient__c": plan["Patient__c"], "MessageText__c": message,
-                    "Direction__c": "Outbound", "Timestamp__c": datetime.utcnow().isoformat()
-                })
-                sf_client.update_record("FollowUpPlan__c", plan["Id"], {"Status__c": "Sent"})
+            patient = sf_client.query_records(f"SELECT Phone__c, ConsentGiven__c FROM Patient__c WHERE Id = '{plan['Patient__c']}'")
+            if patient and patient[0]["ConsentGiven__c"]:
+                message = plan.get("MessageContent__c", f"Hi, this is your daily follow-up.")
+                if twilio_client.send_message(patient[0]["Phone__c"], message):
+                    sf_client.create_record("MessageLog__c", {
+                        "Patient__c": plan["Patient__c"], "MessageText__c": message,
+                        "Direction__c": "Outbound", "Timestamp__c": datetime.utcnow().isoformat()
+                    })
+                    sf_client.update_record("FollowUpPlan__c", plan["Id"], {"Status__c": "Sent"})
         time.sleep(86400)  # Run daily
 
-# Automated Follow-up Function
+# Automated Follow-up
 def send_automated_followup(patient_id, action_type):
     if not patient_id:
-        return "Patient ID not found. Please log in via Salesforce."
+        return "Please log in to receive follow-ups."
     patients = sf_client.query_records(f"SELECT Phone__c, Name, ConsentGiven__c FROM Patient__c WHERE Id = '{patient_id}'")
-    if not patients:
-        return "Patient not found."
+    if not patients or not patients[0]["ConsentGiven__c"]:
+        return "No patient found or consent not given."
     patient = patients[0]
-    if not patient["ConsentGiven__c"]:
-        return "Consent not given. Please update your consent."
     consent = sf_client.query_records(f"SELECT Method__c FROM Consent__c WHERE Patient__c = '{patient_id}' ORDER BY CreatedDate DESC LIMIT 1")
     consent_method = consent[0]["Method__c"] if consent else "SMS"
     message_templates = {
-        "consent": f"Hello {patient['Name']}, thank you for registering with our clinic!",
-        "daily": f"Hi {patient['Name']}, this is your daily follow-up. How are you feeling today?",
-        "appointment": f"Dear {patient['Name']}, your appointment is confirmed. Details will follow."
+        "consent": f"Hello {patient['Name']}, thank you for registering!",
+        "daily": f"Hi {patient['Name']}, your daily follow-up check-in.",
+        "appointment": f"Dear {patient['Name']}, your appointment is confirmed."
     }
-    message = message_templates.get(action_type, f"Hi {patient['Name']}, an action ({action_type}) was performed.")
-    send_result = twilio_client.send_message(patient["Phone__c"], message, method=consent_method.lower())
-    if send_result is True:
+    message = message_templates.get(action_type, f"Hi {patient['Name']}, an action was performed.")
+    if twilio_client.send_message(patient["Phone__c"], message, method=consent_method.lower()):
         sf_client.create_record("MessageLog__c", {
             "Patient__c": patient_id, "MessageText__c": message,
             "Direction__c": "Outbound", "Timestamp__c": datetime.utcnow().isoformat()
         })
-        sf_client.update_record("Patient__c", patient_id, {"FollowUpMessage__c": message})
-        logging.info(f"Automated follow-up sent for {action_type}: {patient_id}")
-        return f"Follow-up message sent for {action_type}!"
-    return f"Failed to send follow-up: {send_result}"
+        return f"Follow-up sent for {action_type}!"
+    return "Failed to send follow-up."
 
 # Update Patient Profile
 def update_patient_profile(patient_id, height, weight, emergency_name, emergency_number, emergency_relationship):
     if not patient_id:
-        return "Patient ID not found."
+        return "Please log in to update your profile."
     update_data = {}
-    if height: update_data["Height__c"] = float(height)
-    if weight: update_data["Weight__c"] = float(weight)
+    if height is not None and height != "": update_data["Height__c"] = float(height)
+    if weight is not None and weight != "": update_data["Weight__c"] = float(weight)
     if emergency_name: update_data["EmergencyContactName__c"] = emergency_name
     if emergency_number: update_data["EmergencyContactNumber__c"] = emergency_number
     if emergency_relationship: update_data["EmergencyContactRelationship__c"] = emergency_relationship
     if update_data:
-        result = sf_client.update_record("Patient__c", patient_id, update_data)
-        if result:
+        if sf_client.update_record("Patient__c", patient_id, update_data):
             return "Profile updated successfully!"
         return "Failed to update profile."
     return "No changes made."
@@ -276,114 +248,106 @@ def update_patient_profile(patient_id, height, weight, emergency_name, emergency
 def schedule_appointment(patient_id, doctor_name, appointment_date, time_slot, reason, special_requests):
     if not all([patient_id, doctor_name, appointment_date, time_slot]):
         return "All fields are required."
-    doctors = sf_client.query_records("SELECT Name FROM Doctor__c")
-    if doctor_name not in [doc["Name"] for doc in doctors]:
+    doctors = [doc["Name"] for doc in sf_client.query_records("SELECT Name FROM Doctor__c")]
+    if doctor_name not in doctors and doctor_name != "None":
         return "Invalid doctor selected."
     appointment_data = {
         "Patient__c": patient_id,
         "Name": f"Appointment with {doctor_name}",
         "DateTime__c": f"{appointment_date} {time_slot}:00",
         "Status__c": "Scheduled",
-        "Email__c": sf_client.query_records(f"SELECT Email__c FROM Patient__c WHERE Id = '{patient_id}'")[0]["Email__c"],
+        "Email__c": sf_client.query_records(f"SELECT Email__c FROM Patient__c WHERE Id = '{patient_id}'")[0]["Email__c"] if sf_client.query_records(f"SELECT Email__c FROM Patient__c WHERE Id = '{patient_id}'") else "",
     }
     if reason: appointment_data["Reason__c"] = reason
     if special_requests: appointment_data["SpecialRequests__c"] = special_requests
     result = sf_client.create_record("Appointment__c", appointment_data)
-    if isinstance(result, str):
-        return result
-    send_automated_followup(patient_id, "appointment")
-    return f"Appointment scheduled with {doctor_name} on {appointment_date} at {time_slot}:00!"
+    if result:
+        send_automated_followup(patient_id, "appointment")
+        return f"Appointment scheduled with {doctor_name} on {appointment_date} at {time_slot}:00!"
+    return "Failed to schedule appointment."
 
 # View Risk Dashboard
 def view_risk_dashboard(patient_id):
-    query = f"SELECT ResponseText__c, RiskScore__c, Severity__c, Sentiment__c FROM SymptomLog__c WHERE Patient__c = '{patient_id}'"
-    symptom_logs = sf_client.query_records(query)
+    if not patient_id:
+        return pd.DataFrame(), "Please log in to view your risk dashboard."
+    symptom_logs = sf_client.query_records(f"SELECT ResponseText__c, RiskScore__c, Severity__c, Sentiment__c FROM SymptomLog__c WHERE Patient__c = '{patient_id}'")
     if symptom_logs:
         df = pd.DataFrame([
             {"Response": log["ResponseText__c"], "Risk Score": log["RiskScore__c"],
              "Severity": log["Severity__c"], "Sentiment": log["Sentiment__c"]}
             for log in symptom_logs
         ])
-        high_risk = df[df["Severity"] == "High"].to_dict('records')
+        high_risk = df[df["Severity"] == "High"].to_dict('records') if not df.empty and "Severity" in df else []
         return df, high_risk if high_risk else "No high-risk cases."
     return pd.DataFrame(), "No symptom logs available."
 
 # Escalate Case
 def escalate_case(patient_id, response_text):
     if not patient_id or not response_text:
-        return "Please provide a response text."
+        return "Please log in and provide a response text."
     analysis = hf_client.analyze_response(response_text)
     if analysis and analysis["risk_level"] == "High":
         case_data = {
             "RelatedPatient__c": patient_id, "Priority__c": "High",
             "Description__c": f"High-risk response: {response_text}"
         }
-        result = sf_client.create_record("Case__c", case_data)
-        if isinstance(result, str):
-            return result
-        patient = sf_client.query_records(f"SELECT Phone__c FROM Patient__c WHERE Id = '{patient_id}'")[0]
-        twilio_client.send_message(patient["Phone__c"], "Your case has been escalated. A doctor will contact you soon.")
-        return "Case escalated successfully!"
-    return "No high-risk case detected."
+        if sf_client.create_record("Case__c", case_data):
+            patient = sf_client.query_records(f"SELECT Phone__c FROM Patient__c WHERE Id = '{patient_id}'")
+            if patient:
+                twilio_client.send_message(patient[0]["Phone__c"], "Your case is escalated. A doctor will contact you.")
+            return "Case escalated successfully!"
+    return "No high-risk case detected or escalation failed."
 
 # Gradio Interface
-with gr.Blocks(theme=gr.themes.Soft(), title="HealthPortal - Patient Care System") as demo:
-    gr.Markdown(f"# HealthPortal - Patient Care System")
+with gr.Blocks(theme=gr.themes.Soft(), title="HealthPortal - Patient Care") as demo:
+    gr.Markdown("# HealthPortal - Patient Care System")
+    patient_id_state = gr.State(value=patient_id)
+    patient_name_state = gr.State(value=patient_name)
+
+    def get_welcome_message(pid):
+        if pid:
+            patient = sf_client.query_records(f"SELECT Name FROM Patient__c WHERE Id = '{pid}'")
+            return f"## Welcome back, {patient[0]['Name'] if patient else 'Guest'}!" if patient else "## Welcome, Guest!"
+        return "## Welcome, Guest!"
+
     with gr.Tabs():
-        with gr.Tab("Dashboard"):
-            gr.Markdown(f"## Welcome back, {patient_name_state.value or 'Guest'}!")
-            gr.Markdown("Here's an overview of your healthcare journey")
-            with gr.Row():
-                with gr.Column():
-                    next_appt = sf_client.query_records(f"SELECT DateTime__c, Name FROM Appointment__c WHERE Patient__c = '{patient_id_state.value}' AND Status__c = 'Scheduled' ORDER BY DateTime__c ASC LIMIT 1")
-                    gr.Markdown(f"**Next Appointment**\n{next_appt[0]['DateTime__c'].split(' ')[0]} - {next_appt[0]['Name'].split('with ')[1]}") if next_appt else gr.Markdown("**Next Appointment**\nNo upcoming appointments")
-                with gr.Column():
-                    pending_fields = [f for f in ["Height__c", "Weight__c", "EmergencyContactName__c"] if not sf_client.query_records(f"SELECT {f} FROM Patient__c WHERE Id = '{patient_id_state.value}'")[0].get(f)]
-                    gr.Markdown(f"**Pending Forms**\n{len(pending_fields)} - {', '.join(pending_fields)}") if pending_fields else gr.Markdown("**Pending Forms**\nNone")
-                with gr.Column():
-                    health_score = sf_client.query_records(f"SELECT AVG(RiskScore__c) FROM SymptomLog__c WHERE Patient__c = '{patient_id_state.value}'")[0]["expr0"] or 0
-                    gr.Markdown(f"**Health Score**\n{int(health_score)}/100\n{'Excellent progress' if health_score >= 80 else 'Monitor progress'}")
-                with gr.Column():
-                    notifications = sf_client.query_records(f"SELECT MessageText__c FROM MessageLog__c WHERE Patient__c = '{patient_id_state.value}' ORDER BY Timestamp__c DESC LIMIT 3")
-                    gr.Markdown(f"**Notifications**\n{len(notifications)} - {'Lab results available' if notifications else 'No new notifications'}")
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("**Tasks & Reminders**")
-                    tasks = [
-                        gr.Markdown("Complete Pre-visit Form\nFill out questionnaire before your appointment\nDue: Dec 14") if pending_fields else gr.Markdown("Complete Pre-visit Form\nAll fields completed"),
-                        gr.Markdown("Review Lab Results\nCheck your latest blood work results\nAvailable now"),
-                        gr.Markdown("Schedule Follow-up\nRecommended: Jan 2025")
-                    ]
-                with gr.Column():
-                    gr.Markdown("**Recent Activity**")
-                    activities = [
-                        gr.Markdown("Lab Results Available\nBlood work results from Dec 10 are now available"),
-                        gr.Markdown("Appointment Confirmed\nYour Dec 15 appointment with Dr. Smith is confirmed\n1 day ago"),
-                        gr.Markdown("Follow-up Reminder\nTime for your weekly blood pressure check\n5 days ago")
-                    ]
+        with gr.Tab("Home"):
+            gr.Markdown(get_welcome_message(patient_id_state.value))
+            if not patient_id_state.value:
+                gr.Markdown("**You are not logged in.** Please [login](/apex/PatientLoginForm) or [register](/apex/PatientRegistrationFormImproved) to access your personalized dashboard.")
+                gr.Button("Login", link="/apex/PatientLoginForm")
+                gr.Button("Register", link="/apex/PatientRegistrationFormImproved")
+            else:
+                with gr.Row():
+                    with gr.Column():
+                        next_appt = sf_client.query_records(f"SELECT DateTime__c, Name FROM Appointment__c WHERE Patient__c = '{patient_id_state.value}' AND Status__c = 'Scheduled' ORDER BY DateTime__c ASC LIMIT 1")
+                        gr.Markdown(f"**Next Appointment**\n{next_appt[0]['DateTime__c'].split(' ')[0]} - {next_appt[0]['Name'].split('with ')[1]}") if next_appt else gr.Markdown("**Next Appointment**\nNo upcoming appointments")
+                    with gr.Column():
+                        patient_data = sf_client.query_records(f"SELECT Height__c, Weight__c, EmergencyContactName__c FROM Patient__c WHERE Id = '{patient_id_state.value}'")
+                        if patient_data:
+                            pending_fields = [f for f in ["Height__c", "Weight__c", "EmergencyContactName__c"] if not patient_data[0].get(f)]
+                            gr.Markdown(f"**Pending Forms**\n{len(pending_fields)} - {', '.join(pending_fields)}") if pending_fields else gr.Markdown("**Pending Forms**\nNone")
+                    with gr.Column():
+                        health_score = sf_client.query_records(f"SELECT AVG(RiskScore__c) FROM SymptomLog__c WHERE Patient__c = '{patient_id_state.value}'")[0].get("expr0", 0)
+                        gr.Markdown(f"**Health Score**\n{int(health_score)}/100\n{'Excellent' if health_score >= 80 else 'Monitor'}")
 
         with gr.Tab("Appointments"):
-            gr.Markdown("## Appointments\nManage your healthcare appointments and schedule new visits")
-            with gr.Row():
-                with gr.Column():
-                    upcoming_appts = sf_client.query_records(f"SELECT DateTime__c, Name FROM Appointment__c WHERE Patient__c = '{patient_id_state.value}' AND Status__c = 'Scheduled'")
-                    for appt in upcoming_appts[:2]:
-                        gr.Markdown(f"{appt['Name']}\n{appt['DateTime__c']}\nReschedule | Cancel | Call Office")
-                with gr.Column():
-                    gr.Markdown("**Quick Actions**")
-                    gr.Button("View Available Times")
-                    gr.Button("Call to Schedule")
-                    gr.Button("Request Urgent Care")
-            with gr.Row():
-                with gr.Column():
+            if not patient_id_state.value:
+                gr.Markdown("Please log in to manage appointments.")
+            else:
+                gr.Markdown("## Appointments")
+                upcoming_appts = sf_client.query_records(f"SELECT DateTime__c, Name FROM Appointment__c WHERE Patient__c = '{patient_id_state.value}' AND Status__c = 'Scheduled'")
+                for appt in upcoming_appts[:2]:
+                    gr.Markdown(f"{appt['Name']}\n{appt['DateTime__c']}\nReschedule | Cancel | Call Office")
+                with gr.Row():
                     gr.Markdown("**Schedule New Appointment**")
-                    doctors = [doc["Name"] for doc in sf_client.query_records("SELECT Name FROM Doctor__c")]
-                    doctor_input = gr.Dropdown(doctors or ["None"], label="Select Provider", value=doctors[0] if doctors else "None")
+                    doctors = [doc["Name"] for doc in sf_client.query_records("SELECT Name FROM Doctor__c")] or ["None"]
+                    doctor_input = gr.Dropdown(doctors, label="Select Provider", value=doctors[0] if doctors[0] != "None" else "")
                     date_input = gr.Textbox(label="Preferred Date", value=date.today().isoformat(), interactive=True)
-                    time_slots = ["09:00", "10:00", "11:00", "14:00", "15:00", "16:00"]  # Mock, to be dynamic
+                    time_slots = ["09:00", "10:00", "11:00", "14:00", "15:00", "16:00"]  # Mock
                     time_input = gr.Dropdown(time_slots, label="Available Time Slots", value=time_slots[0])
-                    reason_input = gr.Textbox(label="Reason for Visit", value="Please describe the reason for your appointment...")
-                    special_input = gr.Textbox(label="Special Instructions or Requests", value="Any special accommodations or preferences...")
+                    reason_input = gr.Textbox(label="Reason for Visit")
+                    special_input = gr.Textbox(label="Special Instructions")
                     appt_button = gr.Button("Schedule Appointment")
                     appt_output = gr.Textbox(label="Result")
                     appt_button.click(
@@ -393,37 +357,41 @@ with gr.Blocks(theme=gr.themes.Soft(), title="HealthPortal - Patient Care System
                     )
 
         with gr.Tab("Health Records"):
-            gr.Markdown("## Health Records")
-            patient_data = sf_client.query_records(f"SELECT Name, Height__c, Weight__c, EmergencyContactName__c, EmergencyContactNumber__c, EmergencyContactRelationship__c FROM Patient__c WHERE Id = '{patient_id_state.value}'")[0]
-            with gr.Row():
-                gr.Markdown(f"**Patient Info: {patient_data['Name']}**")
-                height_input = gr.Number(label="Height", value=patient_data["Height__c"] or 0, interactive=True)
-                weight_input = gr.Number(label="Weight", value=patient_data["Weight__c"] or 0, interactive=True)
-                emergency_name_input = gr.Textbox(label="Emergency Contact Name", value=patient_data["EmergencyContactName__c"] or "")
-                emergency_number_input = gr.Textbox(label="Emergency Contact Number", value=patient_data["EmergencyContactNumber__c"] or "")
-                emergency_rel_input = gr.Textbox(label="Emergency Contact Relationship", value=patient_data["EmergencyContactRelationship__c"] or "")
-            update_button = gr.Button("Update Profile")
-            update_output = gr.Textbox(label="Result")
-            update_button.click(
-                fn=update_patient_profile,
-                inputs=[patient_id_state, height_input, weight_input, emergency_name_input, emergency_number_input, emergency_rel_input],
-                outputs=update_output
-            )
+            if not patient_id_state.value:
+                gr.Markdown("Please log in to view or update your health records.")
+            else:
+                gr.Markdown("## Health Records")
+                patient_data = sf_client.query_records(f"SELECT Name, Height__c, Weight__c, EmergencyContactName__c, EmergencyContactNumber__c, EmergencyContactRelationship__c FROM Patient__c WHERE Id = '{patient_id_state.value}'")
+                if patient_data:
+                    patient = patient_data[0]
+                    height_input = gr.Number(label="Height", value=patient.get("Height__c", 0), interactive=True)
+                    weight_input = gr.Number(label="Weight", value=patient.get("Weight__c", 0), interactive=True)
+                    emergency_name_input = gr.Textbox(label="Emergency Contact Name", value=patient.get("EmergencyContactName__c", ""))
+                    emergency_number_input = gr.Textbox(label="Emergency Contact Number", value=patient.get("EmergencyContactNumber__c", ""))
+                    emergency_rel_input = gr.Textbox(label="Emergency Contact Relationship", value=patient.get("EmergencyContactRelationship__c", ""))
+                    update_button = gr.Button("Update Profile")
+                    update_output = gr.Textbox(label="Result")
+                    update_button.click(
+                        fn=update_patient_profile,
+                        inputs=[patient_id_state, height_input, weight_input, emergency_name_input, emergency_number_input, emergency_rel_input],
+                        outputs=update_output
+                    )
 
         with gr.Tab("Follow-up"):
-            gr.Markdown("## Follow-up")
-            gr.Markdown("Submit your feedback or escalate a case")
-            survey_questions = ["How would you rate your visit?", "Are you experiencing discomfort?", "How satisfied are you with staff?"]
-            survey_question_input = gr.Dropdown(survey_questions, label="Select Question", value=survey_questions[0])
-            survey_answer_input = gr.Textbox(label="Your Answer", lines=4)
-            survey_button = gr.Button("Submit Survey")
-            survey_output = gr.Textbox(label="Result")
-            survey_button.click(
-                fn=lambda pid, q, a: submit_survey(pid, q, a) or send_automated_followup(pid, "daily"),
-                inputs=[patient_id_state, survey_question_input, survey_answer_input],
-                outputs=survey_output
-            )
-            with gr.Row():
+            if not patient_id_state.value:
+                gr.Markdown("Please log in to submit feedback or escalate cases.")
+            else:
+                gr.Markdown("## Follow-up")
+                survey_questions = ["How was your visit?", "Any discomfort?", "Staff satisfaction?"]
+                survey_question_input = gr.Dropdown(survey_questions, label="Select Question", value=survey_questions[0])
+                survey_answer_input = gr.Textbox(label="Your Answer", lines=4)
+                survey_button = gr.Button("Submit Survey")
+                survey_output = gr.Textbox(label="Result")
+                survey_button.click(
+                    fn=lambda pid, q, a: submit_survey(pid, q, a) or send_automated_followup(pid, "daily"),
+                    inputs=[patient_id_state, survey_question_input, survey_answer_input],
+                    outputs=survey_output
+                )
                 escalate_response_input = gr.Textbox(label="Response for Escalation", lines=4)
                 escalate_button = gr.Button("Escalate Case")
                 escalate_output = gr.Textbox(label="Result")
@@ -431,9 +399,9 @@ with gr.Blocks(theme=gr.themes.Soft(), title="HealthPortal - Patient Care System
                     fn=escalate_case,
                     inputs=[patient_id_state, escalate_response_input],
                     outputs=escalate_output
-            )
+                )
 
-# Launch Gradio app with scheduler
+# Launch with Scheduler
 if __name__ == "__main__":
     import threading
     scheduler_thread = threading.Thread(target=follow_up_scheduler, daemon=True)