wellsky_get_patient_info.py

from curl_cffi import requests
import re
import json
import os
import time
from urllib.parse import unquote


def run(headers, user_input):
    """Get detailed patient information for a given patient ID and episode ID."""
    patient_id = user_input.get("patient_id")
    episode_id = user_input.get("episode_id")

    if not patient_id:
        return {'status_code': 400, 'body': {'error': 'patient_id is required'}}
    if not episode_id:
        return {'status_code': 400, 'body': {'error': 'episode_id is required'}}

    # Extract EHRTOKEN and sessionCacheKey from cookies
    cookie_header = headers.get("Cookie", "")
    ehr_token = ""
    token_match = re.search(r'EHRTOKEN=([^;]+)', cookie_header)
    if token_match:
        ehr_token = unquote(token_match.group(1))

    session_cache_key = ""
    sck_match = re.search(r'sessionCacheKey=([^;]+)', cookie_header)
    if sck_match:
        session_cache_key = sck_match.group(1)

    if not session_cache_key:
        return {'status_code': 401, 'body': {'error': 'Session expired - no sessionCacheKey in cookies'}}

    if not ehr_token:
        return {'status_code': 401, 'body': {'error': 'Session expired - no EHRTOKEN in cookies'}}

    try:
        data = _call_api(patient_id, episode_id, cookie_header, ehr_token, session_cache_key)
    except AuthError as e:
        return {'status_code': 401, 'body': {'error': str(e)}}
    except ApiError as e:
        return {'status_code': e.status_code, 'body': {'error': str(e)}}
    except Exception as e:
        return {'status_code': 500, 'body': {'error': str(e)}}

    # Return structured patient info
    result = {
        "first_name": data.get("FirstName", ""),
        "last_name": data.get("LastName", ""),
        "medical_record_number": data.get("MedicalRecordNumber", ""),
        "dob": data.get("DOB", ""),
        "address": data.get("Address", ""),
        "address_line2": data.get("AddressLine2", ""),
        "patient_phone": data.get("PatientPhone", ""),
        "email_address": data.get("EmailAddress", ""),
        "physician": data.get("Physician", ""),
        "physician_phone": data.get("PhysicianPhone", ""),
        "physician_fax": data.get("PhysicianFax", ""),
        "insurance": data.get("Insurance", ""),
        "pharmacy_name": data.get("PharmacyName", ""),
        "pharmacy_phone": data.get("PharmacyPhone", ""),
        "branch": data.get("Branch", ""),
        "soc_date": data.get("SOCDate", ""),
        "frequency": data.get("Frequency", "").strip(),
        "referral_source": data.get("ReferralSource", "").strip(),
    }

    return {'status_code': 200, 'body': result}


# === PRIVATE ===

class AuthError(Exception):
    pass


class ApiError(Exception):
    def __init__(self, message, status_code=500):
        super().__init__(message)
        self.status_code = status_code


def _call_api(patient_id, episode_id, cookie_header, ehr_token, session_cache_key):
    """Fetch patient info from the EHR API."""
    base_url = BASE_URL

    params = {
        "sessionCacheKey": session_cache_key,
        "method": "getPatientInfoClick",
        "patientKey": patient_id,
        "episodeKey": episode_id,
        "masterKey": patient_id,
        "_": str(int(time.time() * 1000)),
    }

    api_headers = {
        "Cookie": cookie_header,
        "Accept": "application/json, text/javascript, */*; q=0.01",
        "Accept-Encoding": "gzip, deflate, br, zstd",
        "Accept-Language": "en-US,en;q=0.9",
        "Cache-Control": "no-cache",
        "Connection": "keep-alive",
        "Content-Type": "application/x-www-form-urlencoded",
        "Host": "kinnser.net",
        "Origin": base_url,
        "Pragma": "no-cache",
        "Referer": f"{base_url}/AM/Patient/EditEpisode.cfm?sessionCacheKey={session_cache_key}&Episodekey={episode_id}",
        "Sec-Fetch-Dest": "empty",
        "Sec-Fetch-Mode": "cors",
        "Sec-Fetch-Site": "same-origin",
        "X-Requested-With": "XMLHttpRequest",
        "token": ehr_token,
    }

    # Use proxy if available in environment
    proxy = os.environ.get("PROXY_URL") or os.environ.get("HTTP_PROXY") or os.environ.get("HTTPS_PROXY")
    proxy_kwargs = {"proxy": proxy} if proxy else {}

    response = requests.get(
        f"{base_url}/AM/Patient/EpisodeManagerProxy.cfc",
        params=params,
        headers=api_headers,
        impersonate="chrome110",
        timeout=30,
        **proxy_kwargs,
    )

    # Check for auth failure
    if response.status_code == 401:
        raise AuthError('Session expired')
    if response.status_code == 403:
        raise AuthError('Access blocked - session may need refresh')
    if response.status_code == 302 or "logout.cfm" in response.url:
        raise AuthError('Session expired')

    if response.status_code != 200:
        raise ApiError(f'API returned status {response.status_code}', response.status_code)

    # Strip the // JSON security prefix
    body_text = response.text
    if body_text.startswith("//"):
        body_text = body_text[2:]

    try:
        data = json.loads(body_text)
    except json.JSONDecodeError:
        # If we get HTML back (login page), treat as auth failure
        if "<html" in response.text.lower() or "login" in response.text.lower():
            raise AuthError('Session expired')
        raise ApiError('Failed to parse response JSON')

    return data