Update app.py

app.py

@@ -7,6 +7,7 @@ import logging
 import pandas as pd
 import os
 from urllib.parse import quote, unquote
+import time
 
 # Configure logging for audit purposes (FR4, NFR: Security)
 logging.basicConfig(level=logging.INFO, filename='app_log.txt', 
@@ -66,7 +67,7 @@ SALESFORCE_HEADERS = {
     "Content-Type": "application/json"
 }
 
-# Hugging Face Client (No token needed in Hugging Face Spaces)
+# Hugging Face Client for Risk Analysis
 class HuggingFaceClient:
     def __init__(self):
         self.api_url = "https://api-inference.huggingface.co/models/"
@@ -79,26 +80,20 @@ class HuggingFaceClient:
         try:
             response = requests.post(f"{self.api_url}{model}", headers=self.headers, json=payload, timeout=10)
             response.raise_for_status()
-            logging.info(f"API request successful for model {model}")
             return response.json()
         except requests.exceptions.RequestException as e:
             logging.error(f"API request failed for model {model}: {str(e)}")
             return None
 
-    def analyze_response(self, response_text, language_code="en"):
-        try:
-            sentiment_result = self.query(response_text, self.sentiment_model)
-            severity_result = self.query(response_text, self.severity_model)
-            if not sentiment_result or not severity_result:
-                return None
-            sentiment_score = self.process_sentiment(sentiment_result)
-            severity_score = self.process_severity(severity_result)
-            risk_level = self.determine_risk_level(sentiment_score, severity_score)
-            logging.info(f"Analysis: Sentiment={sentiment_score}, Severity={severity_score}, Risk={risk_level}")
-            return {"sentiment_score": sentiment_score, "severity_score": severity_score, "risk_level": risk_level}
-        except Exception as e:
-            logging.error(f"Error analyzing response: {str(e)}")
+    def analyze_response(self, response_text):
+        sentiment_result = self.query(response_text, self.sentiment_model)
+        severity_result = self.query(response_text, self.severity_model)
+        if not sentiment_result or not severity_result:
             return None
+        sentiment_score = self.process_sentiment(sentiment_result)
+        severity_score = self.process_severity(severity_result)
+        risk_level = self.determine_risk_level(sentiment_score, severity_score)
+        return {"sentiment_score": sentiment_score, "severity_score": severity_score, "risk_level": risk_level}
 
     def process_sentiment(self, result):
         if result and isinstance(result, list) and len(result) > 0:
@@ -144,6 +139,19 @@ class SalesforceClient:
             logging.error(error_message)
             return error_message
 
+    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)}")
+            return False
+
     def query_records(self, query):
         try:
             encoded_query = quote(query)
@@ -157,7 +165,7 @@ class SalesforceClient:
             logging.error(f"Failed to query records: {str(e)}")
             return []
 
-# Twilio Client with WhatsApp Support
+# Twilio Client
 class TwilioClient:
     def __init__(self, account_sid, auth_token, from_number):
         self.api_url = f"https://api.twilio.com/2010-04-01/Accounts/{account_sid}/Messages.json"
@@ -198,133 +206,114 @@ def get_patient_info():
     return None, None
 
 patient_id, patient_name = get_patient_info()
-if not patient_id or not patient_name:
-    patient_id = gr.State(value=None)
-    patient_name = gr.State(value=None)
+patient_id_state = gr.State(value=patient_id)
+patient_name_state = gr.State(value=patient_name)
+
+# Follow-Up Scheduler (Simulated Cron Job)
+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'")
+        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"})
+        time.sleep(86400)  # Run daily
 
 # Automated Follow-up Function
-def send_automated_followup(patient_id, action_type, patient_phone=None):
-    try:
-        if not patient_id:
-            return "Patient ID not found. Please log in via Salesforce."
-        patients = sf_client.query_records(f"SELECT Phone__c, Name__c FROM Patient__c WHERE Id = '{patient_id}'")
-        if not patients:
-            return "Patient not found."
-        patient_phone = patient_phone or patients[0]["Phone__c"]
-        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 {patients[0]['Name__c']}, your consent has been recorded. Welcome to our clinic!",
-            "survey": f"Hi {patients[0]['Name__c']}, thank you for your feedback. We’ll follow up soon.",
-            "appointment": f"Dear {patients[0]['Name__c']}, your appointment is confirmed. A reminder will be sent closer to the date."
-        }
-        message = message_templates.get(action_type, f"Hi {patients[0]['Name__c']}, an action ({action_type}) was performed. Contact us for details.")
-        send_result = twilio_client.send_message(patient_phone, message, method=consent_method.lower())
-        if send_result is True:
-            sf_client.create_record("MessageLog__c", {
-                "Patient__c": patient_id, "MessageText__c": message,
-                "Direction__c": "Outbound", "Timestamp__c": datetime.utcnow().isoformat()
-            })
-            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}"
-    except Exception as e:
-        logging.error(f"Error in automated follow-up: {str(e)}")
-        return f"Error sending follow-up: {str(e)}. Please try again."
+def send_automated_followup(patient_id, action_type):
+    if not patient_id:
+        return "Patient ID not found. Please log in via Salesforce."
+    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."
+    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."
+    }
+    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:
+        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}"
 
-# Gradio Interface Functions
-def submit_consent(patient_id, consent_method):
-    if not patient_id or not consent_method:
-        return "Please provide a consent method."
-    try:
-        consent_data = {"Patient__c": patient_id, "Method__c": consent_method, "GivenOn__c": date.today().isoformat()}
-        result = sf_client.create_record("Consent__c", consent_data)
-        if isinstance(result, str):
-            return result
+# 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."
+    update_data = {}
+    if height: update_data["Height__c"] = float(height)
+    if 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:
-            followup_msg = send_automated_followup(patient_id, "consent")
-            return f"Consent recorded successfully! {followup_msg}"
-        return "Failed to record consent. Please try again."
-    except Exception as e:
-        logging.error(f"Error submitting consent: {str(e)}")
-        return f"Error: {str(e)}. Please try again."
+            return "Profile updated successfully!"
+        return "Failed to update profile."
+    return "No changes made."
 
-def schedule_appointment(patient_id, doctor_name, appointment_date, time_slot):
-    if not patient_id or not doctor_name or not appointment_date or not time_slot:
-        return "All fields are required for appointment scheduling."
-    try:
-        appointment_data = {
-            "Patient__c": patient_id,
-            "DoctorName__c": doctor_name,
-            "DateTime__c": f"{appointment_date} {time_slot}:00",
-            "Status__c": "Scheduled"
-        }
-        result = sf_client.create_record("Appointment__c", appointment_data)
-        if isinstance(result, str):
-            return result
-        if result:
-            followup_msg = send_automated_followup(patient_id, "appointment")
-            return f"Appointment scheduled with Dr. {doctor_name} on {appointment_date} at {time_slot}:00! {followup_msg}"
-        return "Failed to schedule appointment. Please try again."
-    except Exception as e:
-        logging.error(f"Error scheduling appointment: {str(e)}")
-        return f"Error: {str(e)}. Please try again."
-
-def submit_survey(patient_id, question, answer):
-    if not patient_id or not answer:
-        return "Please provide an answer to the selected question."
-    try:
-        survey_data = {"Patient__c": patient_id, "Question__c": question, "Answer__c": answer}
-        result = sf_client.create_record("Survey__c", survey_data)
-        if isinstance(result, str):
-            return result
-        if result:
-            analysis = hf_client.analyze_response(answer)
-            if analysis:
-                symptom_data = {
-                    "Patient__c": patient_id, "ResponseText__c": answer,
-                    "RiskScore__c": analysis["risk_level"], "Severity__c": analysis["severity_score"],
-                    "Sentiment__c": analysis["sentiment_score"]
-                }
-                symptom_result = sf_client.create_record("SymptomLog__c", symptom_data)
-                if isinstance(symptom_result, str):
-                    return symptom_result
-                if symptom_result and analysis["risk_level"] == "High":
-                    case_data = {
-                        "RelatedPatient__c": patient_id, "Priority__c": "High",
-                        "Description__c": f"High-risk survey response: {answer}"
-                    }
-                    sf_client.create_record("Case__c", case_data)
-                followup_msg = send_automated_followup(patient_id, "survey")
-                return f"Survey submitted! Risk Level: {analysis['risk_level']}. {followup_msg}"
-            return "Survey submitted, but analysis failed. Please contact support."
-        return "Failed to submit survey. Please try again."
-    except Exception as e:
-        logging.error(f"Error submitting survey: {str(e)}")
-        return f"Error: {str(e)}. Please try again."
+# Schedule Appointment
+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]:
+        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"],
+    }
+    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!"
 
+# View Risk Dashboard
 def view_risk_dashboard(patient_id):
-    try:
-        query = f"SELECT Patient__c, ResponseText__c, RiskScore__c, Severity__c, Sentiment__c FROM SymptomLog__c WHERE Patient__c = '{patient_id}'"
-        symptom_logs = sf_client.query_records(query)
-        if symptom_logs:
-            df = pd.DataFrame([
-                {"Patient": log["Patient__c"], "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"]
-            high_risk_info = high_risk.to_dict('records') if not high_risk.empty else "No high-risk cases for this patient."
-            return df, high_risk_info
-        return pd.DataFrame(), "No symptom logs available for this patient."
-    except Exception as e:
-        logging.error(f"Error loading risk dashboard: {str(e)}")
-        return pd.DataFrame(), f"Error: {str(e)}. Please try again."
+    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 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')
+        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 to escalate the case."
-    try:
+        return "Please 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}"
@@ -332,89 +321,121 @@ def escalate_case(patient_id, response_text):
         result = sf_client.create_record("Case__c", case_data)
         if isinstance(result, str):
             return result
-        if result:
-            patients = sf_client.query_records(f"SELECT Phone__c FROM Patient__c WHERE Id = '{patient_id}'")
-            if patients:
-                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 = "Your case has been escalated due to a high-risk response. A doctor will contact you soon."
-                twilio_client.send_message(patients[0]["Phone__c"], message, method=consent_method.lower())
-            return "Case escalated successfully! The patient will be contacted soon."
-        return "Failed to escalate case. Please try again."
-    except Exception as e:
-        logging.error(f"Error escalating case: {str(e)}")
-        return f"Error: {str(e)}. Please try again."
+        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."
 
 # Gradio Interface
-with gr.Blocks(theme=gr.themes.Soft(), title="Clinic Patient Portal") as demo:
-    gr.Markdown(f"# Clinic Patient Portal - Welcome, {patient_name.value if patient_name.value else 'Guest'}!")
-    
+with gr.Blocks(theme=gr.themes.Soft(), title="HealthPortal - Patient Care System") as demo:
+    gr.Markdown(f"# HealthPortal - Patient Care System")
     with gr.Tabs():
-        with gr.Tab("Consent Management"):
-            gr.Markdown("**Update Your Consent Method**")
-            consent_method_input = gr.Dropdown(["SMS", "WhatsApp"], label="Consent Method", value="SMS")
-            consent_button = gr.Button("Submit Consent")
-            consent_output = gr.Textbox(label="Result")
-            consent_button.click(
-                fn=submit_consent,
-                inputs=[patient_id, consent_method_input],
-                outputs=consent_output
-            )
+        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("Appointment Scheduling"):
-            gr.Markdown("**Book an Appointment**")
-            doctors = ["Dr. Smith", "Dr. Jones", "Dr. Patel"]  # Mock doctor list
-            doctor_input = gr.Dropdown(doctors, label="Select Doctor", value=doctors[0])
-            date_input = gr.Textbox(label="Select Date (YYYY-MM-DD)", value=date.today().isoformat(), placeholder="YYYY-MM-DD")
-            time_slots = ["09:00", "10:00", "11:00", "14:00", "15:00", "16:00"]  # Mock slots
-            time_input = gr.Dropdown(time_slots, label="Select Time Slot", value=time_slots[0])
-            appt_button = gr.Button("Schedule Appointment")
-            appt_output = gr.Textbox(label="Result")
-            appt_button.click(
-                fn=schedule_appointment,
-                inputs=[patient_id, doctor_input, date_input, time_input],
-                outputs=appt_output
+        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():
+                    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")
+                    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_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...")
+                    appt_button = gr.Button("Schedule Appointment")
+                    appt_output = gr.Textbox(label="Result")
+                    appt_button.click(
+                        fn=schedule_appointment,
+                        inputs=[patient_id_state, doctor_input, date_input, time_input, reason_input, special_input],
+                        outputs=appt_output
+                    )
+
+        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
             )
 
-        with gr.Tab("Patient Survey"):
-            gr.Markdown("**Submit Your Feedback**")
-            survey_questions = [
-                "How would you rate your visit today?",
-                "Are you experiencing any discomfort?",
-                "How satisfied are you with our staff?"
-            ]
+        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=submit_survey,
-                inputs=[patient_id, survey_question_input, survey_answer_input],
+                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.Tab("Risk Dashboard"):
-            gr.Markdown("**View Your Health Risk Insights**")
-            dashboard_button = gr.Button("Load Dashboard")
-            dashboard_table = gr.Dataframe(label="Symptom Logs")
-            high_risk_output = gr.Textbox(label="High-Risk Cases")
-            dashboard_button.click(
-                fn=view_risk_dashboard,
-                inputs=[patient_id],
-                outputs=[dashboard_table, high_risk_output]
-            )
-
-        with gr.Tab("Case Escalation"):
-            gr.Markdown("**Escalate a High-Risk Case**")
-            escalate_response_input = gr.Textbox(label="Response Text", lines=4)
-            escalate_button = gr.Button("Escalate Case")
-            escalate_output = gr.Textbox(label="Result")
-            escalate_button.click(
-                fn=escalate_case,
-                inputs=[patient_id, escalate_response_input],
-                outputs=escalate_output
+            with gr.Row():
+                escalate_response_input = gr.Textbox(label="Response for Escalation", lines=4)
+                escalate_button = gr.Button("Escalate Case")
+                escalate_output = gr.Textbox(label="Result")
+                escalate_button.click(
+                    fn=escalate_case,
+                    inputs=[patient_id_state, escalate_response_input],
+                    outputs=escalate_output
             )
 
-# Launch Gradio app
+# Launch Gradio app with scheduler
 if __name__ == "__main__":
+    import threading
+    scheduler_thread = threading.Thread(target=follow_up_scheduler, daemon=True)
+    scheduler_thread.start()
     demo.launch(server_name="0.0.0.0", server_port=7860)