Update app.py

app.py

@@ -13,30 +13,65 @@ logging.basicConfig(level=logging.INFO, filename='app_log.txt',
                     format='%(asctime)s - %(levelname)s - %(message)s')
 
 # Load environment variables (Hugging Face Spaces secrets)
-HF_API_TOKEN = os.getenv("HF_API_TOKEN")
-SALESFORCE_ACCESS_TOKEN = os.getenv("SALESFORCE_ACCESS_TOKEN")
-TWILIO_ACCOUNT_SID = os.getenv("TWILIO_ACCOUNT_SID")
-TWILIO_AUTH_TOKEN = os.getenv("TWILIO_AUTH_TOKEN")
-TWILIO_PHONE = os.getenv("TWILIO_PHONE")
-CALENDLY_API_TOKEN = os.getenv("CALENDLY_API_TOKEN")
-SALESFORCE_BASE_URL = os.getenv("SALESFORCE_INSTANCE_URL", "https://your_instance.salesforce.com/services/data/v60.0/")
+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")
+SALESFORCE_INSTANCE_URL = os.getenv("SF_INSTANCE_URL", "https://clinic3-dev-ed.develop.lightning.force.com/")
+TWILIO_ACCOUNT_SID = os.getenv("TWILIO_ACCOUNT_SID", "AC80ba89ceecaa0f3058326f5c86d63f18")
+TWILIO_AUTH_TOKEN = os.getenv("TWILIO_AUTH_TOKEN", "13d8416e924902b19f8181b77c968060")
+TWILIO_PHONE = os.getenv("TWILIO_PHONE", "+13304226436")
+CALENDLY_API_TOKEN = os.getenv("CALENDLY_API_TOKEN", "eyJraWQiOiIxY2UxZTEzNjE3ZGNmNzY2YjNjZWJjY2Y4ZGM1YmFmYThhNjVlNjg0MDIzZjdjMzJiZTgzNDliMjM4MDEzNWI0IiwidHlwIjoiUEFUIiwiYWxnIjoiRVMyNTYifQ.eyJpc3MiOiJodHRwczovL2F1dGguY2FsZW5kbHkuY29tIiwiaWF0IjoxNzUwODQ5MDc3LCJqdGkiOiI2Njk2N2NjOC1lODk3LTRjZWQtOGM1NS03MGZlNzk5MGRhNTAiLCJ1c2VyX3V1aWQiOiIxYWNjMTMwZS1kN2MzLTQyOTAtYTBjNy1mMzZkYTYxMjMwMDQifQ.BexmuW5XR8wk4_FsROEv5eH7deUSSetNwjCaNiNeBLBYnbJDiG4Hfzbg2qNbUNR0Q8Nb-6-3uU3UuwXex-CgHQ")
 
 # Validate environment variables
-if not all([HF_API_TOKEN, SALESFORCE_ACCESS_TOKEN, TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_PHONE, CALENDLY_API_TOKEN]):
+required_vars = [SALESFORCE_USERNAME, SALESFORCE_PASSWORD, SALESFORCE_SECURITY_TOKEN, SALESFORCE_INSTANCE_URL,
+                 TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_PHONE, CALENDLY_API_TOKEN]
+if not all(required_vars):
     logging.error("Missing environment variables for API integrations.")
     raise ValueError("Missing environment variables. Configure API tokens in Hugging Face Spaces secrets.")
 
+# Salesforce Authentication
+def get_salesforce_access_token():
+    try:
+        login_url = "https://login.salesforce.com/services/Soap/u/60.0"
+        payload = f"""<?xml version="1.0" encoding="utf-8" ?>
+        <env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+            xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+            <env:Body>
+                <n1:login xmlns:n1="urn:partner.soap.sforce.com">
+                    <n1:username>{SALESFORCE_USERNAME}</n1:username>
+                    <n1:password>{SALESFORCE_PASSWORD}{SALESFORCE_SECURITY_TOKEN}</n1:password>
+                </n1:login>
+            </env:Body>
+        </env:Envelope>"""
+        headers = {"Content-Type": "text/xml", "SOAPAction": "login"}
+        response = requests.post(login_url, data=payload, headers=headers, timeout=10)
+        response.raise_for_status()
+        response_text = response.text
+        session_id = response_text.split("<sessionId>")[1].split("</sessionId>")[0]
+        server_url = response_text.split("<serverUrl>")[1].split("</serverUrl>")[0]
+        instance_url = server_url.split("/services")[0]
+        return {"access_token": session_id, "instance_url": instance_url}
+    except Exception as e:
+        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.")
+    raise ValueError("Salesforce authentication failed.")
+SALESFORCE_BASE_URL = sf_auth["instance_url"] + "/services/data/v60.0/"
 SALESFORCE_HEADERS = {
-    "Authorization": f"Bearer {SALESFORCE_ACCESS_TOKEN}",
+    "Authorization": f"Bearer {sf_auth['access_token']}",
     "Content-Type": "application/json"
 }
 
-# Hugging Face Client
+# Hugging Face Client (No token needed in Hugging Face Spaces)
 class HuggingFaceClient:
-    def __init__(self, api_token):
+    def __init__(self):
         self.api_url = "https://api-inference.huggingface.co/models/"
-        self.headers = {"Authorization": f"Bearer {api_token}"}
+        self.headers = {}  # Token is implicit in Hugging Face Spaces
         self.sentiment_model = "distilbert-base-uncased-finetuned-sst-2-english"
         self.severity_model = "bert-base-uncased"  # Placeholder; use custom model
         self.translation_model = "facebook/m2m100_418M"
@@ -58,6 +93,8 @@ class HuggingFaceClient:
                 response_text = self.translate(response_text, language_code, "en")
             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)
@@ -70,7 +107,7 @@ class HuggingFaceClient:
     def translate(self, text, source_lang, target_lang):
         payload = {"inputs": text, "parameters": {"src_lang": source_lang, "tgt_lang": target_lang}}
         result = self.query(payload, self.translation_model)
-        return result[0]["translation_text"] if result and isinstance(result, list) else text
+        return result[0].get("translation_text", text) if result and isinstance(result, list) else text
 
     def process_sentiment(self, result):
         if result and isinstance(result, list) and len(result) > 0:
@@ -107,6 +144,9 @@ class SalesforceClient:
             record_id = response.json()["id"]
             logging.info(f"Created {object_name} record: {record_id}")
             return record_id
+        except requests.exceptions.HTTPError as e:
+            logging.error(f"HTTP error creating {object_name} record: {e.response.status_code} - {e.response.text}")
+            return None
         except requests.exceptions.RequestException as e:
             logging.error(f"Failed to create {object_name} record: {str(e)}")
             return None
@@ -117,6 +157,9 @@ 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)}")
             return []
@@ -130,42 +173,71 @@ class TwilioClient:
 
     def send_message(self, to_number, body):
         try:
+            if not to_number.startswith("+"):
+                return "Invalid phone number format. Must start with +country_code."
             data = {"From": self.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 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 False
+            return str(e)
 
 # Calendly Client
 class CalendlyClient:
     def __init__(self, api_token):
         self.api_url = "https://api.calendly.com/scheduled_events"
+        self.event_types_url = "https://api.calendly.com/event_types"
         self.headers = {"Authorization": f"Bearer {api_token}"}
 
+    def get_event_type_uuid(self, event_slug="30min"):
+        try:
+            response = requests.get(self.event_types_url, headers=self.headers, timeout=5)
+            response.raise_for_status()
+            event_types = response.json()["collection"]
+            for event in event_types:
+                if event["slug"].endswith(event_slug):
+                    return event["uuid"]
+            logging.error(f"Event type {event_slug} not found.")
+            return None
+        except requests.exceptions.RequestException as e:
+            logging.error(f"Failed to fetch event types: {str(e)}")
+            return None
+
     def create_event(self, patient_email, event_type_uuid):
         try:
-            response = requests.post(self.api_url, headers=self.headers, 
-                                   json={"event_type": f"https://api.calendly.com/event_types/{event_type_uuid}", 
-                                         "invitee_email": patient_email})
+            if not event_type_uuid:
+                return None
+            event_data = {
+                "event_type": f"https://api.calendly.com/event_types/{event_type_uuid}",
+                "invitee_email": patient_email
+            }
+            response = requests.post(self.api_url, headers=self.headers, json=event_data, timeout=10)
             response.raise_for_status()
             logging.info(f"Scheduled Calendly event for {patient_email}")
             return response.json()["resource"]["start_time"]
+        except requests.exceptions.HTTPError as e:
+            logging.error(f"Calendly HTTP error: {e.response.status_code} - {e.response.text}")
+            return None
         except requests.exceptions.RequestException as e:
             logging.error(f"Failed to schedule Calendly event: {str(e)}")
             return None
 
 # Gradio Interface Functions
-hf_client = HuggingFaceClient(HF_API_TOKEN)
+hf_client = HuggingFaceClient()
 sf_client = SalesforceClient(SALESFORCE_BASE_URL, SALESFORCE_HEADERS)
 twilio_client = TwilioClient(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_PHONE)
 calendly_client = CalendlyClient(CALENDLY_API_TOKEN)
 
 def register_patient(phone, email, language, consent_status):
+    if not phone or not email or not language or not consent_status:
+        return "All fields are required."
     try:
-        name = f"PAT-{str(uuid.uuid4())[:6]}"  # Auto-generated
+        name = f"PAT-{str(uuid4())[:7]}"  # Unique patient ID
         patient_data = {
             "Name": name, "Phone__c": phone, "Email__c": email,
             "Language__c": language, "ConsentGiven__c": consent_status
@@ -173,20 +245,22 @@ def register_patient(phone, email, language, consent_status):
         patient_id = sf_client.create_record("Patient__c", patient_data)
         if patient_id:
             logging.info(f"Registered patient: {name}")
-            return f"Patient {name} registered successfully!"
-        return "Failed to register patient."
+            return f"Patient {name} registered successfully! ID: {patient_id}"
+        return "Failed to register patient. Check Salesforce logs."
     except Exception as e:
         logging.error(f"Error registering patient: {str(e)}")
         return f"Error: {str(e)}"
 
-def submit_consent(patient_phone, method):
+def submit_consent(patient_phone, consent_method):
+    if not patient_phone or not consent_method:
+        return "All fields are required."
     try:
-        patients = sf_client.query_records(f"SELECT Id FROM Patient__c WHERE Phone__c = '{patient_phone}'")
+        patients = sf_client.query_records(f"SELECT Id, Name FROM Patient__c WHERE Phone__c = '{patient_phone}'")
         if patients:
-            consent_data = {"Method__c": method, "GivenOn__c": date.today().isoformat()}
+            consent_data = {"Method__c": consent_method, "GivenOn__c": date.today().isoformat()}
             consent_id = sf_client.create_record("Consent__c", consent_data)
             if consent_id:
-                logging.info("Consent recorded.")
+                logging.info(f"Consent recorded for patient: {patients[0]['Name']}")
                 return "Consent recorded successfully!"
             return "Failed to record consent."
         return "Patient not found."
@@ -195,25 +269,33 @@ def submit_consent(patient_phone, method):
         return f"Error: {str(e)}"
 
 def schedule_followup(patient_phone, message_template, follow_up_date):
+    if not patient_phone or not message_template or not follow_up_date:
+        return "All fields are required."
     try:
-        patients = sf_client.query_records(f"SELECT Id, ConsentGiven__c, Language__c FROM Patient__c WHERE Phone__c = '{patient_phone}'")
-        if patients and patients[0]["ConsentGiven__c"] == "Approved":
-            followup_data = {
-                "Patient__c": patients[0]["Id"], "FollowUpDate__c": follow_up_date.isoformat(),
-                "MessageTemplate__c": message_template, "Status__c": "Scheduled"
-            }
-            followup_id = sf_client.create_record("FollowUpPlan__c", followup_data)
-            if followup_id:
-                if twilio_client.send_message(patient_phone, message_template):
-                    sf_client.create_record("MessageLog__c", {
-                        "Patient__c": patients[0]["Id"], "MessageText__c": message_template,
-                        "Direction__c": "Outbound", "Timestamp__c": datetime.utcnow().isoformat()
-                    })
-                    logging.info(f"Follow-up scheduled for patient: {patients[0]['Id']}")
-                    return "Follow-up scheduled and message sent!"
-                return "Failed to send message."
+        follow_up_date = datetime.strptime(follow_up_date, "%Y-%m-%d").date()
+        patients = sf_client.query_records(f"SELECT Id, ConsentGiven__c, Language__c, Name FROM Patient__c WHERE Phone__c = '{patient_phone}'")
+        if not patients:
+            return "Patient not found."
+        if patients[0]["ConsentGiven__c"] != "Approved":
+            return "Consent not approved for messaging."
+        followup_data = {
+            "Patient__c": patients[0]["Id"], "FollowUpDate__c": follow_up_date.isoformat(),
+            "MessageTemplate__c": message_template, "Status__c": "Scheduled"
+        }
+        followup_id = sf_client.create_record("FollowUpPlan__c", followup_data)
+        if not followup_id:
             return "Failed to schedule follow-up."
-        return "Patient not found or consent not approved."
+        send_result = twilio_client.send_message(patient_phone, message_template)
+        if send_result is True:
+            sf_client.create_record("MessageLog__c", {
+                "Patient__c": patients[0]["Id"], "MessageText__c": message_template,
+                "Direction__c": "Outbound", "Timestamp__c": datetime.utcnow().isoformat()
+            })
+            logging.info(f"Follow-up scheduled and message sent for patient: {patients[0]['Name']}")
+            return "Follow-up scheduled and message sent!"
+        return f"Failed to send message: {send_result}"
+    except ValueError:
+        return "Invalid date format. Use YYYY-MM-DD."
     except Exception as e:
         logging.error(f"Error scheduling follow-up: {str(e)}")
         return f"Error: {str(e)}"
@@ -228,13 +310,18 @@ def view_risk_dashboard():
                  "Sentiment": log["Sentiment__c"]} for log in symptom_logs
             ])
             high_risk = df[df["Severity"] == "High"]
-            return df, high_risk.to_dict('records') if not high_risk.empty else "No high-risk cases."
+            high_risk_info = high_risk.to_dict('records') if not high_risk.empty else "No high-risk cases."
+            logging.info("Risk dashboard loaded successfully.")
+            return df, high_risk_info
+        logging.info("No symptom logs found.")
         return pd.DataFrame(), "No symptom logs available."
     except Exception as e:
         logging.error(f"Error loading risk dashboard: {str(e)}")
         return pd.DataFrame(), f"Error: {str(e)}"
 
 def escalate_case(patient_id, response_text):
+    if not patient_id or not response_text:
+        return "All fields are required."
     try:
         case_data = {
             "RelatedPatient__c": patient_id, "Priority__c": "High",
@@ -249,8 +336,13 @@ def escalate_case(patient_id, response_text):
         logging.error(f"Error escalating case: {str(e)}")
         return f"Error: {str(e)}"
 
-def schedule_appointment(patient_email, event_type_uuid):
+def schedule_appointment(patient_email, event_type_slug="30min"):
+    if not patient_email or not event_type_slug:
+        return "All fields are required."
     try:
+        event_type_uuid = calendly_client.get_event_type_uuid(event_type_slug)
+        if not event_type_uuid:
+            return f"Event type '{event_type_slug}' not found."
         event_time = calendly_client.create_event(patient_email, event_type_uuid)
         if event_time:
             appointment_data = {"DateTime__c": event_time, "Status__c": "Scheduled"}
@@ -265,31 +357,33 @@ def schedule_appointment(patient_email, event_type_uuid):
         return f"Error: {str(e)}"
 
 def submit_survey(patient_phone, question, answer):
+    if not patient_phone or not question or not answer:
+        return "All fields are required."
     try:
-        patients = sf_client.query_records(f"SELECT Id, Language__c FROM Patient__c WHERE Phone__c = '{patient_phone}'")
-        if patients:
-            survey_data = {"Question__c": question, "Answer__c": answer}
-            survey_id = sf_client.create_record("Survey__c", survey_data)
-            if survey_id:
-                analysis = hf_client.analyze_response(answer, patients[0]["Language__c"])
-                if analysis:
-                    symptom_data = {
-                        "Patient__c": patients[0]["Id"], "ResponseText__c": answer,
-                        "RiskScore__c": analysis["risk_level"], "Severity__c": analysis["severity_score"],
-                        "Sentiment__c": analysis["sentiment_score"]
-                    }
-                    symptom_id = sf_client.create_record("SymptomLog__c", symptom_data)
-                    if symptom_id and analysis["risk_level"] == "High":
-                        case_data = {
-                            "RelatedPatient__c": patients[0]["Id"], "Priority__c": "High",
-                            "Description__c": f"High-risk survey response: {answer}"
-                        }
-                        sf_client.create_record("Case__c", case_data)
-                    logging.info(f"Survey submitted for patient: {patients[0]['Id']}")
-                    return "Survey submitted and analyzed!"
-                return "Failed to analyze survey response."
+        patients = sf_client.query_records(f"SELECT Id, Language__c, Name FROM Patient__c WHERE Phone__c = '{patient_phone}'")
+        if not patients:
+            return "Patient not found."
+        survey_data = {"Question__c": question, "Answer__c": answer}
+        survey_id = sf_client.create_record("Survey__c", survey_data)
+        if not survey_id:
             return "Failed to submit survey."
-        return "Patient not found."
+        analysis = hf_client.analyze_response(answer, patients[0]["Language__c"])
+        if analysis:
+            symptom_data = {
+                "Patient__c": patients[0]["Id"], "ResponseText__c": answer,
+                "RiskScore__c": analysis["risk_level"], "Severity__c": analysis["severity_score"],
+                "Sentiment__c": analysis["sentiment_score"]
+            }
+            symptom_id = sf_client.create_record("SymptomLog__c", symptom_data)
+            if symptom_id and analysis["risk_level"] == "High":
+                case_data = {
+                    "RelatedPatient__c": patients[0]["Id"], "Priority__c": "High",
+                    "Description__c": f"High-risk survey response: {answer}"
+                }
+                sf_client.create_record("Case__c", case_data)
+            logging.info(f"Survey submitted for patient: {patients[0]['Name']}")
+            return f"Survey submitted and analyzed! Risk Level: {analysis['risk_level']}"
+        return "Failed to analyze survey response."
     except Exception as e:
         logging.error(f"Error submitting survey: {str(e)}")
         return f"Error: {str(e)}"
@@ -346,22 +440,22 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI-Powered Patient Follow-up Agent
             with gr.Row():
                 escalate_id_input = gr.Textbox(label="Patient ID (for escalation)")
                 escalate_response_input = gr.Textbox(label="Response Text")
-                escalate_button = gr.Button("Submit Case Escalation")
+                escalate_button = gr.Button("Escalate Case")
                 escalate_output = gr.Textbox(label="Result")
                 escalate_button.click(
-                    fn=escribe_case,
+                    fn=escalate_case,
                     inputs=[escalate_id_input, escalate_response_input],
                     outputs=escalate_output
                 )
 
         with gr.Tab("Appointment Scheduling"):
             appt_email_input = gr.Textbox(label="Patient Email", placeholder="patient@example.com")
-            event_type_input = gr.Textbox(label="Calendly Event Type UUID", placeholder="your_event_type_uuid")
+            appt_event_input = gr.Textbox(label="Event Type Slug", value="30min", placeholder="e.g., 30min")
             appt_button = gr.Button("Schedule Appointment")
             appt_output = gr.Textbox(label="Result")
             appt_button.click(
                 fn=schedule_appointment,
-                inputs=[appt_email_input, event_type_input],
+                inputs=[appt_email_input, appt_event_input],
                 outputs=appt_output
             )