medicafe 0.250708.0__tar.gz → 0.250711.0__tar.gz

{medicafe-0.250708.0 → medicafe-0.250711.0}/MediLink/MediLink_API_v3.py

@@ -73,6 +73,7 @@ class TokenCache:
                 return token_info['access_token']
 
         # Log cache miss
+        # BUG In the future, check the token refresh flow here to make sure we're not picking up unnecessary tokens.
         log_message = "No valid token found for {}".format(endpoint_name)
         MediLink_ConfigLoader.log(log_message, level="INFO")
 

{medicafe-0.250708.0 → medicafe-0.250711.0}/MediLink/MediLink_Deductible.py

@@ -212,47 +212,196 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
         MediLink_ConfigLoader.log("Error: {}".format(e), level="ERROR")
     return None
 
-# Function to extract required fields and display in a tabular format
-def display_eligibility_info(data, dob, member_id, output_file):
-    if data is None:
-        return
+# Helper functions to extract data from different API response formats
+# BUG the API response is coming through correctly but the parsers below are not correctly extracting the super_connector variables.
+
+def extract_legacy_patient_info(policy):
+    """Extract patient information from legacy API response format"""
+    patient_info = policy.get("patientInfo", [{}])[0]
+    return {
+        'lastName': patient_info.get("lastName", ""),
+        'firstName': patient_info.get("firstName", ""),
+        'middleName': patient_info.get("middleName", "")
+    }
 
-    for policy in data.get("memberPolicies", []):
-        # Skip non-medical policies
-        if policy.get("policyInfo", {}).get("coverageType", "") != "Medical":
-            continue
+def extract_super_connector_patient_info(eligibility_data):
+    """Extract patient information from Super Connector API response format"""
+    if not eligibility_data:
+        return {'lastName': '', 'firstName': '', 'middleName': ''}
+    
+    # The response structure is flat at the top level
+    return {
+        'lastName': eligibility_data.get("lastName", ""),
+        'firstName': eligibility_data.get("firstName", ""),
+        'middleName': eligibility_data.get("middleName", "")
+    }
 
-        patient_info = policy.get("patientInfo", [{}])[0]
-        lastName = patient_info.get("lastName", "")
-        firstName = patient_info.get("firstName", "")
-        middleName = patient_info.get("middleName", "")
-
-        # Check if the remaining amount is per individual first, then fallback to family
-        deductible_info = policy.get("deductibleInfo", {})
-        if 'individual' in deductible_info:
-            remaining_amount = deductible_info['individual']['inNetwork'].get("remainingAmount", "")
-        elif 'family' in deductible_info:
-            remaining_amount = deductible_info['family']['inNetwork'].get("remainingAmount", "")
-        else:
-            remaining_amount = ""
+def extract_legacy_remaining_amount(policy):
+    """Extract remaining amount from legacy API response format"""
+    deductible_info = policy.get("deductibleInfo", {})
+    if 'individual' in deductible_info:
+        return deductible_info['individual']['inNetwork'].get("remainingAmount", "")
+    elif 'family' in deductible_info:
+        return deductible_info['family']['inNetwork'].get("remainingAmount", "")
+    else:
+        return ""
+
+def extract_super_connector_remaining_amount(eligibility_data):
+    """Extract remaining amount from Super Connector API response format"""
+    if not eligibility_data:
+        return ""
+    
+    # First, check top-level metYearToDateAmount which might indicate deductible met
+    met_amount = eligibility_data.get('metYearToDateAmount')
+    if met_amount is not None:
+        return str(met_amount)
+    
+    # Navigate to the rawGraphQLResponse structure
+    raw_response = eligibility_data.get('rawGraphQLResponse', {})
+    if not raw_response:
+        return ""
+    
+    data = raw_response.get('data', {})
+    check_eligibility = data.get('checkEligibility', {})
+    eligibility_list = check_eligibility.get('eligibility', [])
+    
+    if not eligibility_list:
+        return ""
+    
+    first_eligibility = eligibility_list[0]
+    service_levels = first_eligibility.get('serviceLevels', [])
+    
+    # Look for deductible information in service levels
+    for service_level in service_levels:
+        individual_services = service_level.get('individual', [])
+        for individual in individual_services:
+            services = individual.get('services', [])
+            for service in services:
+                # Look for deductible-related information
+                if service.get('service') == 'deductible' or 'deductible' in service.get('text', '').lower():
+                    return service.get('remainingAmount', "")
+                
+                # Check the message.deductible.text field for deductible information
+                message = service.get('message', {})
+                deductible_msg = message.get('deductible', {})
+                if deductible_msg and deductible_msg.get('text'):
+                    return deductible_msg.get('text', "")
+    
+    # If no specific deductible found, try to get from plan levels
+    plan_levels = first_eligibility.get('eligibilityInfo', {}).get('planLevels', [])
+    for plan_level in plan_levels:
+        if plan_level.get('level') == 'deductibleInfo/outOfPocket/coPayMax':
+            individual_levels = plan_level.get('individual', [])
+            if individual_levels:
+                return individual_levels[0].get('remainingAmount', "")
+    
+    return ""
+
+def extract_legacy_insurance_info(policy):
+    """Extract insurance information from legacy API response format"""
+    insurance_info = policy.get("insuranceInfo", {})
+    return {
+        'insuranceType': insurance_info.get("insuranceType", ""),
+        'insuranceTypeCode': insurance_info.get("insuranceTypeCode", ""),
+        'memberId': insurance_info.get("memberId", ""),
+        'payerId': insurance_info.get("payerId", "")
+    }
 
-        insurance_info = policy.get("insuranceInfo", {})
-        ins_insuranceType = insurance_info.get("insuranceType", "")
-        ins_insuranceTypeCode = insurance_info.get("insuranceTypeCode", "")
-        ins_memberID = insurance_info.get("memberId", "")
-        ins_payerID = insurance_info.get("payerId", "")
+def extract_super_connector_insurance_info(eligibility_data):
+    """Extract insurance information from Super Connector API response format"""
+    if not eligibility_data:
+        return {'insuranceType': '', 'insuranceTypeCode': '', 'memberId': '', 'payerId': ''}
+    
+    # Get coverage type from coverageTypes array at the top level
+    coverage_types = eligibility_data.get('coverageTypes', [])
+    insurance_type = ""
+    if coverage_types:
+        insurance_type = coverage_types[0].get('description', '')
+    
+    return {
+        'insuranceType': insurance_type,
+        'insuranceTypeCode': eligibility_data.get("productServiceCode", ""),
+        'memberId': eligibility_data.get("subscriberId", ""),
+        'payerId': eligibility_data.get("legalEntityCode", "")
+    }
 
-        policy_info = policy.get("policyInfo", {})
-        policy_status = policy_info.get("policyStatus", "")
+def extract_legacy_policy_status(policy):
+    """Extract policy status from legacy API response format"""
+    policy_info = policy.get("policyInfo", {})
+    return policy_info.get("policyStatus", "")
 
-        patient_name = "{} {} {}".format(firstName, middleName, lastName).strip()[:20]
+def extract_super_connector_policy_status(eligibility_data):
+    """Extract policy status from Super Connector API response format"""
+    if not eligibility_data:
+        return ""
+    
+    # Policy status is at the top level
+    return eligibility_data.get("policyStatus", "")
+
+def is_legacy_response_format(data):
+    """Determine if the response is in legacy format (has memberPolicies)"""
+    return data is not None and "memberPolicies" in data
+
+def is_super_connector_response_format(data):
+    """Determine if the response is in Super Connector format (has rawGraphQLResponse)"""
+    return data is not None and "rawGraphQLResponse" in data
+
+# Function to extract required fields and display in a tabular format
+def display_eligibility_info(data, dob, member_id, output_file):
+    if data is None:
+        return
+
+    # Determine which API response format we're dealing with
+    if is_legacy_response_format(data):
+        # Handle legacy API response format
+        for policy in data.get("memberPolicies", []):
+            # Skip non-medical policies
+            if policy.get("policyInfo", {}).get("coverageType", "") != "Medical":
+                continue
+
+            patient_info = extract_legacy_patient_info(policy)
+            remaining_amount = extract_legacy_remaining_amount(policy)
+            insurance_info = extract_legacy_insurance_info(policy)
+            policy_status = extract_legacy_policy_status(policy)
+
+            patient_name = "{} {} {}".format(
+                patient_info['firstName'], 
+                patient_info['middleName'], 
+                patient_info['lastName']
+            ).strip()[:20]
+
+            # Display patient information in a table row format
+            table_row = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
+                patient_name, dob, insurance_info['insuranceType'], 
+                insurance_info['payerId'], policy_status, remaining_amount)
+            output_file.write(table_row + "\n")
+            print(table_row)  # Print to console for progressive display
+
+    elif is_super_connector_response_format(data):
+        # Handle Super Connector API response format
+        patient_info = extract_super_connector_patient_info(data)
+        remaining_amount = extract_super_connector_remaining_amount(data)
+        insurance_info = extract_super_connector_insurance_info(data)
+        policy_status = extract_super_connector_policy_status(data)
+
+        patient_name = "{} {} {}".format(
+            patient_info['firstName'], 
+            patient_info['middleName'], 
+            patient_info['lastName']
+        ).strip()[:20]
 
         # Display patient information in a table row format
         table_row = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
-            patient_name, dob, ins_insuranceType, ins_payerID, policy_status, remaining_amount)
+            patient_name, dob, insurance_info['insuranceType'], 
+            insurance_info['payerId'], policy_status, remaining_amount)
         output_file.write(table_row + "\n")
         print(table_row)  # Print to console for progressive display
 
+    else:
+        # Unknown response format - log for debugging
+        MediLink_ConfigLoader.log("Unknown response format in display_eligibility_info", level="WARNING")
+        MediLink_ConfigLoader.log("Response structure: {}".format(json.dumps(data, indent=2)), level="DEBUG")
+
 # Main Execution Flow
 if __name__ == "__main__":
     # Step 1: Handle Manual Deductible Lookups

{medicafe-0.250708.0/medicafe.egg-info → medicafe-0.250711.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: medicafe
-Version: 0.250708.0
+Version: 0.250711.0
 Summary: MediCafe
 Home-page: https://github.com/katanada2
 Author: Daniel Vidaud

{medicafe-0.250708.0 → medicafe-0.250711.0/medicafe.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: medicafe
-Version: 0.250708.0
+Version: 0.250711.0
 Summary: MediCafe
 Home-page: https://github.com/katanada2
 Author: Daniel Vidaud

{medicafe-0.250708.0 → medicafe-0.250711.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='medicafe',
-    version="0.250708.0",
+    version="0.250711.0",
     description='MediCafe',
     long_description="""
     # Project Overview: MediCafe