Update app.py

app.py

@@ -65,56 +65,6 @@ SALESFORCE_HEADERS = {
     "Content-Type": "application/json"
 }
 
-# Hugging Face Client
-class HuggingFaceClient:
-    def __init__(self):
-        self.api_url = "https://api-inference.huggingface.co/models/"
-        self.headers = {}
-        self.sentiment_model = "distilbert-base-uncased-finetuned-sst-2-english"
-        self.severity_model = "bert-base-uncased"
-
-    def query(self, text, model):
-        payload = {"inputs": text}
-        try:
-            response = requests.post(f"{self.api_url}{model}", headers=self.headers, json=payload, timeout=10)
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logging.error(f"API request failed: {str(e)}")
-            return None
-
-    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:
-            for item in result[0]:
-                if item["label"] == "POSITIVE":
-                    return int(item["score"] * 100)
-                elif item["label"] == "NEGATIVE":
-                    return int((1 - item["score"]) * 100)
-        return 0
-
-    def process_severity(self, result):
-        if result and isinstance(result, list) and len(result) > 0:
-            return int(result[0].get("score", 0) * 100)
-        return 0
-
-    def determine_risk_level(self, sentiment_score, severity_score):
-        combined_score = (sentiment_score + severity_score) / 2
-        if combined_score >= 75:
-            return "High"
-        elif combined_score >= 50:
-            return "Medium"
-        return "Low"
-
 # Salesforce Client
 class SalesforceClient:
     def __init__(self, base_url, headers):
@@ -171,7 +121,6 @@ class TwilioClient:
             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)
 
@@ -202,27 +151,68 @@ def follow_up_scheduler():
                     sf_client.update_record("FollowUpPlan__c", plan["Id"], {"Status__c": "Sent"})
         time.sleep(86400)  # Run daily
 
+# Update Patient Profile
+def update_patient_profile(patient_id, height, weight, emergency_name, emergency_number, emergency_relationship, address, dob):
+    if not patient_id:
+        return "Please log in to update your profile."
+    update_data = {}
+    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 address: update_data["Address__c"] = address
+    if dob: update_data["DateOfBirth__c"] = dob
+    if update_data:
+        if sf_client.update_record("Patient__c", patient_id, update_data):
+            return "Profile updated successfully!"
+        return "Failed to update profile."
+    return "No changes made."
+
 # 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]):
+def schedule_appointment(patient_id, doctor_name, appointment_type, preferred_date, time_slot, reason, special_requests):
+    if not all([patient_id, doctor_name, appointment_type, preferred_date, time_slot]):
         return "All fields are required."
     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":
+    if doctor_name not 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",
+        "Doctor__c": doctor_name,
+        "AppointmentType__c": appointment_type,
+        "DateTime__c": f"{preferred_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 sf_client.query_records(f"SELECT Email__c FROM Patient__c WHERE Id = '{patient_id}'") else "",
+        "Reason__c": reason,
+        "SpecialRequests__c": special_requests
     }
-    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 result:
-        return f"Appointment scheduled with {doctor_name} on {appointment_date} at {time_slot}:00!"
+        return f"Appointment scheduled with {doctor_name} on {preferred_date} at {time_slot}:00!"
     return "Failed to schedule appointment."
 
+# Get Next Appointment
+def get_next_appointment(patient_id):
+    if not patient_id:
+        return None
+    next_appt = sf_client.query_records(f"SELECT DateTime__c, Doctor__c FROM Appointment__c WHERE Patient__c = '{patient_id}' AND Status__c = 'Scheduled' ORDER BY DateTime__c ASC LIMIT 1")
+    return next_appt[0] if next_appt else None
+
+# Get Pending Fields
+def get_pending_fields(patient_id):
+    if not patient_id:
+        return []
+    patient_data = sf_client.query_records(f"SELECT Height__c, Weight__c, EmergencyContactName__c, EmergencyContactNumber__c, EmergencyContactRelationship__c, Address__c, DateOfBirth__c FROM Patient__c WHERE Id = '{patient_id}'")[0]
+    required_fields = ["Height__c", "Weight__c", "EmergencyContactName__c", "EmergencyContactNumber__c", "EmergencyContactRelationship__c", "Address__c", "DateOfBirth__c"]
+    pending = [field for field in required_fields if not patient_data.get(field)]
+    return pending
+
+# Get All Appointments
+def get_all_appointments(patient_id):
+    if not patient_id:
+        return []
+    appointments = sf_client.query_records(f"SELECT DateTime__c, Doctor__c, AppointmentType__c, Status__c, Reason__c FROM Appointment__c WHERE Patient__c = '{patient_id}' ORDER BY DateTime__c DESC")
+    return appointments if appointments else []
+
 # Gradio Interface
 with gr.Blocks(theme=gr.themes.Soft(), title="HealthPortal - Patient Care") as demo:
     gr.Markdown("# HealthPortal - Patient Care System")
@@ -231,50 +221,106 @@ with gr.Blocks(theme=gr.themes.Soft(), title="HealthPortal - Patient Care") as d
 
     with gr.Tabs():
         with gr.Tab("Home"):
-            gr.Markdown("## Welcome to Your Dashboard!")
             if not patient_id_state.value:
                 gr.Markdown("**You are not logged in.** Please log in or register to access your personalized dashboard.")
                 with gr.Row():
                     gr.Button("Login", link=f"{SALESFORCE_INSTANCE_URL}/apex/PatientLoginForm")
                     gr.Button("Register", link=f"{SALESFORCE_INSTANCE_URL}/apex/PatientRegistrationForm")
+                # Note: Login and register links unchanged; relies on iframe/Salesforce flow
             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():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### New Appointment")
+                        next_appt = get_next_appointment(patient_id_state.value)
+                        if next_appt:
+                            gr.Markdown(f"**Date:** {next_appt['DateTime__c'].split(' ')[0]}\n**Time:** {next_appt['DateTime__c'].split(' ')[1][:5]}\n**Doctor:** {next_appt['Doctor__c']}")
+                        else:
+                            gr.Markdown("No upcoming appointments.")
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Pending Forms")
+                        pending_fields = get_pending_fields(patient_id_state.value)
+                        if pending_fields:
+                            gr.Markdown(f"**Unfilled Fields:** {', '.join(pending_fields)}")
+                            with gr.Row():
+                                details_button = gr.Button("View Details")
+                        else:
+                            gr.Markdown("No pending forms.")
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Health Score")
                         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'}")
+                        gr.Markdown(f"**Score:** {int(health_score)}/100\n{'Excellent' if health_score >= 80 else 'Monitor'}")
+
+                if pending_fields:
+                    def show_details_page():
+                        return gr.update(visible=True)
+                    details_page = gr.Column(visible=False)
+                    with details_page:
+                        gr.Markdown("## Update Patient Details")
+                        patient_data = sf_client.query_records(f"SELECT Height__c, Weight__c, EmergencyContactName__c, EmergencyContactNumber__c, EmergencyContactRelationship__c, Address__c, DateOfBirth__c FROM Patient__c WHERE Id = '{patient_id_state.value}'")[0]
+                        height_input = gr.Number(label="Height (cm)", value=patient_data.get("Height__c", 0), interactive=True)
+                        weight_input = gr.Number(label="Weight (kg)", value=patient_data.get("Weight__c", 0), interactive=True)
+                        emergency_name_input = gr.Textbox(label="Emergency Contact Name", value=patient_data.get("EmergencyContactName__c", ""))
+                        emergency_number_input = gr.Textbox(label="Emergency Contact Number", value=patient_data.get("EmergencyContactNumber__c", ""))
+                        emergency_rel_input = gr.Textbox(label="Emergency Contact Relationship", value=patient_data.get("EmergencyContactRelationship__c", ""))
+                        address_input = gr.Textbox(label="Address", value=patient_data.get("Address__c", ""))
+                        dob_input = gr.Textbox(label="Date of Birth (YYYY-MM-DD)", value=patient_data.get("DateOfBirth__c", ""))
+                        update_button = gr.Button("Save")
+                        back_button = gr.Button("Back")
+                        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, address_input, dob_input],
+                            outputs=output
+                        )
+                        back_button.click(
+                            fn=lambda: gr.update(visible=False),
+                            outputs=details_page
+                        )
+                    details_button.click(
+                        fn=show_details_page,
+                        outputs=details_page
+                    )
 
         with gr.Tab("Appointments"):
             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")
+                gr.Markdown("## Appointment History")
+                appointments = get_all_appointments(patient_id_state.value)
+                if appointments:
+                    for appt in appointments:
+                        gr.Markdown(f"**{appt['AppointmentType__c']} with {appt['Doctor__c']}\nDate:** {appt['DateTime__c'].split(' ')[0]}\n**Time:** {appt['DateTime__c'].split(' ')[1][:5]}\n**Status:** {appt['Status__c']}\n**Reason:** {appt.get('Reason__c', 'N/A')}")
+                else:
+                    gr.Markdown("You have not booked any appointments.")
                 with gr.Row():
-                    gr.Markdown("**Schedule New Appointment**")
-                    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
+                    with gr.Column(scale=1, min_width=100):
+                        schedule_button = gr.Button("Schedule Appointment", variant="primary")
+                    with gr.Column(scale=3):
+                        pass
+                def show_schedule_page():
+                    return gr.update(visible=True)
+                schedule_page = gr.Column(visible=False)
+                with schedule_page:
+                    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, label="Select Provider", value=doctors[0] if doctors else "")
+                    appointment_type_input = gr.Dropdown(["Consultation", "Follow-up", "Procedure"], label="Appointment Type", value="Consultation")
+                    date_input = gr.Date(label="Preferred Date", value=date.today())
+                    time_slots = ["09:00", "10:00", "11:00", "14:00", "15:00", "16:00"]  # Mock, to be replaced with real availability
                     time_input = gr.Dropdown(time_slots, label="Available Time Slots", value=time_slots[0])
                     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(
+                    schedule_submit = gr.Button("Schedule")
+                    output = gr.Textbox(label="Result")
+                    schedule_submit.click(
                         fn=schedule_appointment,
-                        inputs=[patient_id_state, doctor_input, date_input, time_input, reason_input, special_input],
-                        outputs=appt_output
+                        inputs=[patient_id_state, doctor_input, appointment_type_input, date_input, time_input, reason_input, special_input],
+                        outputs=output
                     )
+                schedule_button.click(
+                    fn=show_schedule_page,
+                    outputs=schedule_page
+                )
 
 # Launch with Scheduler
 if __name__ == "__main__":