medicafe 0.250725.18__py3-none-any.whl → 0.250728.0__py3-none-any.whl

MediBot/update_medicafe.py

@@ -190,6 +190,31 @@ def ensure_dependencies():
                 print("Warning: Failed to install {}.".format(package_name))
                 time.sleep(2)  # Pause for 2 seconds after failure message
 
+def check_for_updates_only():
+    """
+    Check if a new version is available without performing the upgrade.
+    Returns a simple status message for batch script consumption.
+    """
+    if not check_internet_connection():
+        print("ERROR")
+        return
+    
+    package = "medicafe"
+    current_version = get_installed_version(package)
+    if not current_version:
+        print("ERROR")
+        return
+    
+    latest_version = get_latest_version(package)
+    if not latest_version:
+        print("ERROR")
+        return
+    
+    if compare_versions(latest_version, current_version) > 0:
+        print("UPDATE_AVAILABLE:" + latest_version)
+    else:
+        print("UP_TO_DATE")
+
 def main():
     # Ensure internet connection before proceeding
     if not check_internet_connection():
@@ -243,4 +268,7 @@ def main():
         sys.exit(1)
 
 if __name__ == "__main__":
-    main()
+    if len(sys.argv) > 1 and sys.argv[1] == "--check-only":
+        check_for_updates_only()
+    else:
+        main()

MediLink/MediLink.py

@@ -58,6 +58,11 @@ def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_map
     - Enriched detailed patient data with insurance type added.
     
     TODO: Implement a function to provide `patient_insurance_mapping` from a reliable source.
+    This is going to be coming soon as an API feature from United Healthcare. We'll be able to get insurance types directly via their API.
+    So, while we won't be able to do it for all payerIDs, we'll be able to do it for the ones that are supported by UHC.
+    So, we'll need a way to augment the associated menu here so that the user is aware of which insurance types are already pulled from
+    UHC and which ones are not yet supported so they know which ones they need to edit. It is possible that we may want to isolate the 
+    patient data that is already pulled from UHC so that the user can see which ones are already using the enriched data.
     """
     if patient_insurance_type_mapping is None:
         MediLink_ConfigLoader.log("No Patient:Insurance-Type mapping available.", level="WARNING")
@@ -221,14 +226,12 @@ def process_endpoint(endpoint_key, endpoint_info, config):
         MediLink_ConfigLoader.log("Error processing endpoint {}: {}".format(endpoint_key, e), level="ERROR")
         return [], []
 
-def user_decision_on_suggestions(detailed_patient_data, config, insurance_edited):
+def user_decision_on_suggestions(detailed_patient_data, config, insurance_edited, crosswalk):
     """
     Presents the user with all patient summaries and suggested endpoints,
     then asks for confirmation to proceed with all or specify adjustments manually.
     
-    BUG (Med suggested_endpoint) The display summary suggested_endpoint key isn't updating per the user's decision 
-    although the user decision is persisting. Possibly consider making the current/suggested/confirmed endpoint 
-    part of a class that the user can interact with via these menus? Probably better handling that way.
+    FIXED: Display now properly shows effective endpoints (user preferences over original suggestions)
     """
     if insurance_edited:
         # Display summaries only if insurance types were edited
@@ -247,18 +250,16 @@ def user_decision_on_suggestions(detailed_patient_data, config, insurance_edited
 
     # If the user agrees to proceed with all suggested endpoints, confirm them.
     if proceed:
-        return MediLink_DataMgmt.confirm_all_suggested_endpoints(detailed_patient_data)
+        return MediLink_DataMgmt.confirm_all_suggested_endpoints(detailed_patient_data), crosswalk
     # Otherwise, allow the user to adjust the endpoints manually.
     else:
-        return select_and_adjust_files(detailed_patient_data, config)
+        return select_and_adjust_files(detailed_patient_data, config, crosswalk)
    
-def select_and_adjust_files(detailed_patient_data, config):
+def select_and_adjust_files(detailed_patient_data, config, crosswalk):
     """
     Allows users to select patients and adjust their endpoints by interfacing with UI functions.
     
-    BUG (Med suggested_endpoint) After the user is done making their selection (probably via a class?), 
-    Then suggested_endpoint should update to persist the user selection as priority over its original suggestion. 
-    Which means the crosswalk should persist the change in the endpoint as well.
+    FIXED: Now properly updates suggested_endpoint and persists user preferences to crosswalk.
     """
     # Display options for patients
     MediLink_UI.display_patient_options(detailed_patient_data)
@@ -268,11 +269,12 @@ def select_and_adjust_files(detailed_patient_data, config):
     
     # Get an ordered list of endpoint keys
     endpoint_keys = list(config['MediLink_Config']['endpoints'].keys())
-
+    
     # Iterate over each selected index and process endpoint changes
     for i in selected_indices:
         data = detailed_patient_data[i]
-        MediLink_UI.display_patient_for_adjustment(data['patient_name'], data.get('suggested_endpoint', 'N/A'))
+        current_effective_endpoint = get_effective_endpoint(data)
+        MediLink_UI.display_patient_for_adjustment(data['patient_name'], current_effective_endpoint)
         
         endpoint_change = MediLink_UI.get_endpoint_decision()
         if endpoint_change == 'y':
@@ -281,17 +283,132 @@ def select_and_adjust_files(detailed_patient_data, config):
             
             if 0 <= endpoint_index < len(endpoint_keys):
                 selected_endpoint_key = endpoint_keys[endpoint_index]
-                data['confirmed_endpoint'] = selected_endpoint_key
                 print("Endpoint changed to {0} for patient {1}.".format(config['MediLink_Config']['endpoints'][selected_endpoint_key]['name'], data['patient_name']))
-                # BUG (Med, Crosswalk & suggested_endpoint) Probably update crosswalk and suggested endpoint here??? Not quite, because the user could be changing multiple patients 
-                # at the same time and that would interrupt the flow.
-                # TODO This needs to make its way to save_crosswalk but with a user confirmation about updating for all the future patients from that insurance company. (or maybe that flow needs to be within save_crosswalk?)
+                
+                # Use the new endpoint management system
+                updated_crosswalk = update_suggested_endpoint_with_user_preference(
+                    detailed_patient_data, i, selected_endpoint_key, config, crosswalk
+                )
+                if updated_crosswalk:
+                    crosswalk = updated_crosswalk
             else:
-                print("Invalid selection. Keeping the suggested endpoint.")
+                print("Invalid selection. Keeping the current endpoint.")
+                data['confirmed_endpoint'] = current_effective_endpoint
         else:
-            data['confirmed_endpoint'] = data.get('suggested_endpoint', 'N/A')
+            data['confirmed_endpoint'] = current_effective_endpoint
+
+    return detailed_patient_data, crosswalk
+
+def update_suggested_endpoint_with_user_preference(detailed_patient_data, patient_index, new_endpoint, config, crosswalk):
+    """
+    Updates the suggested endpoint for a patient and optionally updates the crosswalk 
+    for future patients with the same insurance.
+    
+    :param detailed_patient_data: List of patient data dictionaries
+    :param patient_index: Index of the patient being updated
+    :param new_endpoint: The new endpoint selected by the user
+    :param config: Configuration settings
+    :param crosswalk: Crosswalk data for in-memory updates
+    :return: Updated crosswalk if changes were made, None otherwise
+    """
+    data = detailed_patient_data[patient_index]
+    original_suggested = data.get('suggested_endpoint')
+    
+    # Update the patient's endpoint preference
+    data['user_preferred_endpoint'] = new_endpoint
+    data['confirmed_endpoint'] = new_endpoint
+    
+    # If user changed from the original suggestion, offer to update crosswalk
+    if original_suggested != new_endpoint:
+        primary_insurance = data.get('primary_insurance')
+        patient_name = data.get('patient_name')
+        
+        print("\nYou changed the endpoint for {} from {} to {}.".format(patient_name, original_suggested, new_endpoint))
+        update_future = input("Would you like to use {} as the default endpoint for future patients with {}? (Y/N): ".format(new_endpoint, primary_insurance)).strip().lower()
+        
+        if update_future in ['y', 'yes']:
+            # Find the payer ID associated with this insurance
+            insurance_to_id = load_insurance_data_from_mains(config)
+            insurance_id = insurance_to_id.get(primary_insurance)
+            
+            if insurance_id:
+                # Find the payer ID in crosswalk and update it
+                updated = False
+                for payer_id, payer_data in crosswalk.get('payer_id', {}).items():
+                    medisoft_ids = [str(id) for id in payer_data.get('medisoft_id', [])]
+                    if str(insurance_id) in medisoft_ids:
+                        # Update the crosswalk in memory
+                        crosswalk['payer_id'][payer_id]['endpoint'] = new_endpoint
+                        MediLink_ConfigLoader.log("Updated crosswalk in memory: Payer ID {} ({}) now defaults to {}".format(payer_id, primary_insurance, new_endpoint), level="INFO")
+                        
+                        # Update suggested_endpoint for other patients with same insurance in current batch
+                        for other_data in detailed_patient_data:
+                            if (other_data.get('primary_insurance') == primary_insurance and 
+                                'user_preferred_endpoint' not in other_data):
+                                other_data['suggested_endpoint'] = new_endpoint
+                        
+                        updated = True
+                        break
+                
+                if updated:
+                    # Save the updated crosswalk to disk immediately using API bypass mode
+                    if save_crosswalk_immediately(config, crosswalk):
+                        print("Updated default endpoint for {} to {}".format(primary_insurance, new_endpoint))
+                    else:
+                        print("Updated endpoint preference (will be saved during next crosswalk update)")
+                    return crosswalk
+                else:
+                    MediLink_ConfigLoader.log("Could not find payer ID in crosswalk for insurance {}".format(primary_insurance), level="WARNING")
+            else:
+                MediLink_ConfigLoader.log("Could not find insurance ID for {} to update crosswalk".format(primary_insurance), level="WARNING")
+    
+    return None
+
+def save_crosswalk_immediately(config, crosswalk):
+    """
+    Saves the crosswalk to disk immediately using API bypass mode.
+    
+    :param config: Configuration settings
+    :param crosswalk: Crosswalk data to save
+    :return: True if saved successfully, False otherwise
+    """
+    try:
+        # Import the crosswalk library
+        from MediBot import MediBot_Crosswalk_Library
+        
+        # Save using API bypass mode (no client needed, skip API operations)
+        success = MediBot_Crosswalk_Library.save_crosswalk(None, config, crosswalk, skip_api_operations=True)
+        
+        if success:
+            MediLink_ConfigLoader.log("Successfully saved crosswalk with updated endpoint preferences", level="INFO")
+        else:
+            MediLink_ConfigLoader.log("Failed to save crosswalk - preferences will be saved during next crosswalk update", level="WARNING")
+            
+        return success
+        
+    except ImportError:
+        MediLink_ConfigLoader.log("Could not import MediBot_Crosswalk_Library for saving crosswalk", level="ERROR")
+        return False
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error saving crosswalk: {}".format(e), level="ERROR")
+        return False
+
+def get_effective_endpoint(patient_data):
+    """
+    Returns the most appropriate endpoint for a patient based on the hierarchy:
+    1. Confirmed endpoint (final decision)
+    2. User preferred endpoint (if user made a change)
+    3. Original suggested endpoint
+    4. Default (AVAILITY)
+    
+    :param patient_data: Individual patient data dictionary
+    :return: The effective endpoint to use for this patient
+    """
+    return (patient_data.get('confirmed_endpoint') or 
+            patient_data.get('user_preferred_endpoint') or 
+            patient_data.get('suggested_endpoint', 'AVAILITY'))
+
 
-    return detailed_patient_data
 
 def main_menu():
     """
@@ -303,8 +420,26 @@ def main_menu():
     
     # Check to make sure payer_id key is available in crosswalk, otherwise, go through that crosswalk initialization flow
     if 'payer_id' not in crosswalk:
-        print("Crosswalk 'payer_id' not found. Please run MediBot_Preprocessor.py with the --update-crosswalk argument.")
-        exit() # BUG Halting the script execution here for now, should be handled in the preprocessor script.
+        print("\n" + "="*60)
+        print("SETUP REQUIRED: Payer Information Database Missing")
+        print("="*60)
+        print("\nThe system needs to build a database of insurance company information")
+        print("before it can process claims. This is a one-time setup requirement.")
+        print("\nThis typically happens when:")
+        print("• You're running MediLink for the first time")
+        print("• The payer database was accidentally deleted or corrupted")
+        print("• You're using a new installation of the system")
+        print("\nTO FIX THIS:")
+        print("1. Open a command prompt/terminal")
+        print("2. Navigate to the MediCafe directory")
+        print("3. Run: python MediBot/MediBot_Preprocessor.py --update-crosswalk")
+        print("4. Wait for the process to complete (this may take a few minutes)")
+        print("5. Return here and restart MediLink")
+        print("\nThis will download and build the insurance company database.")
+        print("="*60)
+        print("\nPress Enter to exit...")
+        input()
+        return  # Graceful exit instead of abrupt halt
     
     # Check if the application is in test mode
     if config.get("MediLink_Config", {}).get("TestMode", False):
@@ -378,7 +513,11 @@ def handle_submission(detailed_patient_data, config, crosswalk):
                 print("Returning to bulk edit insurance types.")
     
     # Initiate user interaction to confirm or adjust suggested endpoints.
-    adjusted_data = user_decision_on_suggestions(detailed_patient_data, config, insurance_edited)
+    adjusted_data, updated_crosswalk = user_decision_on_suggestions(detailed_patient_data, config, insurance_edited, crosswalk)
+    
+    # Update crosswalk reference if it was modified
+    if updated_crosswalk:
+        crosswalk = updated_crosswalk
     
     # Confirm all remaining suggested endpoints.
     confirmed_data = MediLink_DataMgmt.confirm_all_suggested_endpoints(adjusted_data)

MediLink/MediLink_837p_encoder.py

@@ -28,6 +28,16 @@ except (ImportError, SystemError):
         import MediLink_837p_encoder_library
     except ImportError:
         from MediLink import MediLink_837p_encoder_library
+
+# Safe import for API client - works in multiple contexts
+try:
+    from . import MediLink_API_v3
+except (ImportError, SystemError):
+    try:
+        import MediLink_API_v3
+    except ImportError:
+        from MediLink import MediLink_API_v3
+
 # TODO (COB ENHANCEMENT): Import COB library when implementing Medicare and secondary claim support
 # import MediLink_837p_cob_library
 #from tqdm import tqdm
@@ -192,7 +202,7 @@ def write_output_file(document_segments, output_directory, endpoint_key, input_f
         MediLink_ConfigLoader.log("Error: Failed to write output file. {}".format(e), config, level="ERROR")
         return None
 
-def process_single_file(file_path, config, endpoint_key, transaction_set_control_number, crosswalk): # BUG Duplicate function name??
+def process_single_file(file_path, config, endpoint_key, transaction_set_control_number, crosswalk, client):
     """
     Process the claim data from a file into the 837P format.
 
@@ -201,6 +211,8 @@ def process_single_file(file_path, config, endpoint_key, transaction_set_control
         config (dict): Configuration settings loaded from a JSON file.
         endpoint_key (str): The key representing the endpoint for which the claim is being processed.
         transaction_set_control_number (int): The starting transaction set control number for 837P segments.
+        crosswalk (dict): Crosswalk data for payer information.
+        client: API client for payer name resolution.
 
     Returns:
         tuple: A tuple containing the formatted claim segments and the next transaction set control number.
@@ -213,7 +225,7 @@ def process_single_file(file_path, config, endpoint_key, transaction_set_control
             return None, transaction_set_control_number  # Halt processing if the user chooses
 
     # Process each valid claim
-    formatted_claims, transaction_set_control_number = format_claims(valid_claims, config, endpoint_key, transaction_set_control_number, crosswalk)
+    formatted_claims, transaction_set_control_number = format_claims(valid_claims, config, endpoint_key, transaction_set_control_number, crosswalk, client)
 
     formatted_claims_str = '\n'.join(formatted_claims)  # Join formatted claims into a single string
     return formatted_claims_str, transaction_set_control_number
@@ -247,7 +259,7 @@ def read_and_validate_claims(file_path, config):
 
     return valid_claims, validation_errors
 
-def format_claims(parsed_data_list, config, endpoint, starting_transaction_set_control_number, crosswalk):
+def format_claims(parsed_data_list, config, endpoint, starting_transaction_set_control_number, crosswalk, client):
     """
     Formats a list of parsed claim data into 837P segments.
 
@@ -256,6 +268,8 @@ def format_claims(parsed_data_list, config, endpoint, starting_transaction_set_c
     - config: Configuration settings loaded from a JSON file.
     - endpoint: The endpoint key representing the specific endpoint.
     - starting_transaction_set_control_number: Starting transaction set control number for 837P segments.
+    - crosswalk: Crosswalk data for payer information.
+    - client: API client for payer name resolution.
 
     Returns:
     - A list of formatted 837P claims and the next transaction set control number.
@@ -264,7 +278,7 @@ def format_claims(parsed_data_list, config, endpoint, starting_transaction_set_c
     transaction_set_control_number = starting_transaction_set_control_number
 
     for parsed_data in parsed_data_list:
-        formatted_claim = format_single_claim(parsed_data, config, endpoint, transaction_set_control_number, crosswalk)
+        formatted_claim = format_single_claim(parsed_data, config, endpoint, transaction_set_control_number, crosswalk, client)
         formatted_claims.append(formatted_claim)
         transaction_set_control_number += 1  # Increment for each successfully processed claim
 
@@ -342,7 +356,7 @@ def validate_claim_data(parsed_data, config, required_fields=[]):
 
     return True, []
 
-def process_and_write_file(file_path, config, endpoint, crosswalk, starting_tscn=1):
+def process_and_write_file(file_path, config, endpoint, crosswalk, client, starting_tscn=1):
     """        
     Process a single file, create complete 837P document with headers and trailers, and write to output file.
 
@@ -350,11 +364,13 @@ def process_and_write_file(file_path, config, endpoint, crosswalk, starting_tscn
     - file_path: Path to the .DAT file to be processed.
     - config: Configuration settings.
     - endpoint: Endpoint key.
+    - crosswalk: Crosswalk data for payer information.
+    - client: API client for payer name resolution.
     - starting_tscn: Starting Transaction Set Control Number.
     """
     print("Processing: {}".format(file_path))
     MediLink_ConfigLoader.log("Processing: {}".format(file_path))
-    formatted_data, transaction_set_control_number = process_single_file(file_path, config, endpoint, starting_tscn, crosswalk)
+    formatted_data, transaction_set_control_number = process_single_file(file_path, config, endpoint, starting_tscn, crosswalk, client)
     isa_header, gs_header, ge_trailer, iea_trailer = MediLink_837p_encoder_library.create_interchange_elements(config, endpoint, transaction_set_control_number - 1)
     
     # Combine everything into a single document
@@ -371,7 +387,6 @@ def process_and_write_file(file_path, config, endpoint, crosswalk, starting_tscn
     print("File processed. Output saved to: {}".format(output_file_path))
 
 def main():
-    # BUG (MAJOR) THIS NEEDS THE API CLIENT TO BE PASSED INTO THE FUNCTION FOR SINGLE FILE PROCESSING.
     """
     Converts fixed-width files to 837P format for health claim submissions.
 
@@ -418,10 +433,13 @@ def main():
     config, crosswalk = MediLink_ConfigLoader.load_configuration()
     config = config.get('MediLink_Config', config)
     
-    process_dat_files(args.path, config, args.endpoint, args.is_directory, crosswalk)
+    # Create API client for payer name resolution
+    client = MediLink_API_v3.APIClient()
+    
+    process_dat_files(args.path, config, args.endpoint, args.is_directory, crosswalk, client)
     print("Conversion complete.")
 
-def process_dat_files(path, config, endpoint, is_directory, crosswalk):
+def process_dat_files(path, config, endpoint, is_directory, crosswalk, client):
     """
     Processes either a single file or all files within a directory.
 
@@ -430,6 +448,8 @@ def process_dat_files(path, config, endpoint, is_directory, crosswalk):
     - config: Configuration settings loaded from a JSON file.
     - endpoint: The endpoint for which the conversion is intended.
     - is_directory: Boolean flag indicating if the path is a directory.
+    - crosswalk: Crosswalk data for payer information.
+    - client: API client for payer name resolution.
 
     Returns:
     - None
@@ -439,10 +459,10 @@ def process_dat_files(path, config, endpoint, is_directory, crosswalk):
         for file_name in os.listdir(path):
             if file_name.endswith(".DAT"):
                 file_path = os.path.join(path, file_name)
-                process_and_write_file(file_path, config, endpoint, crosswalk)
+                process_and_write_file(file_path, config, endpoint, crosswalk, client)
     else:
         MediLink_ConfigLoader.log("Processing the single file: {}".format(path))
-        process_and_write_file(path, config, endpoint, crosswalk)
+        process_and_write_file(path, config, endpoint, crosswalk, client)
 
 if __name__ == "__main__":
     main()

MediLink/MediLink_837p_encoder_library.py

@@ -188,7 +188,11 @@ def create_1000A_submitter_name_segment(patient_data, config, endpoint):
     entity_type_qualifier = '1' if submitter_first_name else '2' # Make sure that this is correct. Original default was 2.
     
     # Construct NM1 segment for the submitter
-    nm1_segment = "NM1*41*{}*{}*****{}*{}~".format(entity_type_qualifier, submitter_name, submitter_id_qualifier, submitter_id) # BUG - need to check submitter_name because this is written as fixed ****** which implies a single entry and not a first and last name. This is weird.
+    # EDI NM1 Segment Format: NM1*41*{entity_type}*{org_name}*{first}*{middle}*{prefix}*{suffix}*{id_qualifier}*{id}~
+    # For organizational submitters (entity_type=2), we use the organization name in NM1-03 and leave individual name fields blank
+    # TODO: For individual submitters (entity_type=1), we would need to parse submitter_name into first/last components
+    # Current implementation works in production - claims are being paid successfully
+    nm1_segment = "NM1*41*{}*{}*****{}*{}~".format(entity_type_qualifier, submitter_name, submitter_id_qualifier, submitter_id)
     
     # Construct PER segment for the submitter's contact information
     per_segment = "PER*IC*{}*TE*{}~".format(contact_name, contact_telephone_number)

MediLink/MediLink_API_v3.py

@@ -73,7 +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.
+        # Token refresh flow validation has been implemented in get_access_token() to prevent unnecessary token pickup
         log_message = "No valid token found for {}".format(endpoint_name)
         MediLink_ConfigLoader.log(log_message, level="INFO")
 
@@ -123,8 +123,29 @@ class APIClient(BaseAPIClient):
             MediLink_ConfigLoader.log("Cached token expires at {}".format(expires_at), level="DEBUG")
             return cached_token
         
+        # Validate that we actually need a token before fetching
+        # Check if the endpoint configuration exists and is valid
+        try:
+            endpoint_config = self.config['MediLink_Config']['endpoints'][endpoint_name]
+            if not endpoint_config:
+                MediLink_ConfigLoader.log("No configuration found for endpoint: {}".format(endpoint_name), level="ERROR")
+                return None
+                
+            # Validate required configuration fields
+            required_fields = ['token_url', 'client_id', 'client_secret']
+            missing_fields = [field for field in required_fields if field not in endpoint_config]
+            if missing_fields:
+                MediLink_ConfigLoader.log("Missing required configuration fields for {}: {}".format(endpoint_name, missing_fields), level="ERROR")
+                return None
+                
+        except KeyError:
+            MediLink_ConfigLoader.log("Endpoint {} not found in configuration".format(endpoint_name), level="ERROR")
+            return None
+        except Exception as e:
+            MediLink_ConfigLoader.log("Error validating endpoint configuration for {}: {}".format(endpoint_name, str(e)), level="ERROR")
+            return None
+        
         # If no valid token, fetch a new one
-        endpoint_config = self.config['MediLink_Config']['endpoints'][endpoint_name]
         token_url = endpoint_config['token_url']
         data = {
             'grant_type': 'client_credentials',
@@ -138,15 +159,22 @@ class APIClient(BaseAPIClient):
 
         headers = {'Content-Type': 'application/x-www-form-urlencoded'}
 
-        response = requests.post(token_url, headers=headers, data=data)
-        response.raise_for_status()
-        token_data = response.json()
-        access_token = token_data['access_token']
-        expires_in = token_data.get('expires_in', 3600)
-
-        self.token_cache.set(endpoint_name, access_token, expires_in, current_time)
-        MediLink_ConfigLoader.log("Obtained NEW token for endpoint: {}".format(endpoint_name), level="INFO")
-        return access_token
+        try:
+            response = requests.post(token_url, headers=headers, data=data)
+            response.raise_for_status()
+            token_data = response.json()
+            access_token = token_data['access_token']
+            expires_in = token_data.get('expires_in', 3600)
+
+            self.token_cache.set(endpoint_name, access_token, expires_in, current_time)
+            MediLink_ConfigLoader.log("Obtained NEW token for endpoint: {}".format(endpoint_name), level="INFO")
+            return access_token
+        except requests.exceptions.RequestException as e:
+            MediLink_ConfigLoader.log("Failed to obtain token for {}: {}".format(endpoint_name, str(e)), level="ERROR")
+            return None
+        except (KeyError, ValueError) as e:
+            MediLink_ConfigLoader.log("Invalid token response for {}: {}".format(endpoint_name, str(e)), level="ERROR")
+            return None
 
     def make_api_call(self, endpoint_name, call_type, url_extension="", params=None, data=None, headers=None):
         token = self.get_access_token(endpoint_name)
@@ -334,9 +362,13 @@ def fetch_payer_name_from_api(client, payer_id, config, primary_endpoint='AVAILI
         MediLink_ConfigLoader.log(error_message, level="ERROR")
         exit(1)  # Exit the script
     
-    # BUG Force AVAILITY until I can get a payer-list api from any of the other endpoints. 
-    MediLink_ConfigLoader.log("[Fetch payer name from API] Overriding {} with AVAILITY.".format(primary_endpoint), level="DEBUG")
-    primary_endpoint = 'AVAILITY'
+    # TODO: FUTURE IMPLEMENTATION - Remove AVAILITY default when other endpoints have payer-list APIs
+    # Currently defaulting to AVAILITY as it's the only endpoint with confirmed payer-list functionality
+    # In the future, this should be removed and the system should dynamically detect which endpoints
+    # have payer-list capabilities and use them accordingly.
+    if primary_endpoint != 'AVAILITY':
+        MediLink_ConfigLoader.log("[Fetch payer name from API] Overriding {} with AVAILITY (default until multi-endpoint payer-list support is implemented).".format(primary_endpoint), level="DEBUG")
+        primary_endpoint = 'AVAILITY'
     
     try:
         endpoints = config['MediLink_Config']['endpoints']
@@ -360,10 +392,36 @@ def fetch_payer_name_from_api(client, payer_id, config, primary_endpoint='AVAILI
         MediLink_ConfigLoader.log(error_message, level="ERROR")
         print(error_message)
     
-    # Define endpoint rotation logic
-    endpoint_order = ([primary_endpoint] + 
-                      [endpoint for endpoint in endpoints if endpoint != primary_endpoint]
-                      if primary_endpoint in endpoints else list(endpoints.keys()))
+    # FUTURE IMPLEMENTATION: Dynamic endpoint selection based on payer-list availability
+    # This will replace the hardcoded AVAILITY default when other endpoints have payer-list APIs
+    # The logic should:
+    # 1. Check all endpoints for 'payer_list_endpoint' configuration
+    # 2. Prioritize endpoints that have confirmed payer-list functionality
+    # 3. Fall back to endpoints with basic payer lookup if available
+    # 4. Use AVAILITY as final fallback
+    
+    # Define endpoint rotation logic with payer-list capability detection
+    available_endpoints = []
+    
+    # Check which endpoints have payer-list functionality configured
+    for endpoint_name, endpoint_config in endpoints.items():
+        if 'payer_list_endpoint' in endpoint_config:
+            available_endpoints.append(endpoint_name)
+            MediLink_ConfigLoader.log("Found payer-list endpoint for {}: {}".format(endpoint_name, endpoint_config['payer_list_endpoint']), level="DEBUG")
+    
+    # If no endpoints have payer-list configured, fall back to AVAILITY
+    if not available_endpoints:
+        MediLink_ConfigLoader.log("No endpoints with payer-list configuration found, using AVAILITY as fallback", level="INFO")
+        available_endpoints = ['AVAILITY']
+    
+    # Prioritize the primary endpoint if it has payer-list capability
+    if primary_endpoint in available_endpoints:
+        endpoint_order = [primary_endpoint] + [ep for ep in available_endpoints if ep != primary_endpoint]
+    else:
+        # If primary endpoint doesn't have payer-list, use available endpoints in order
+        endpoint_order = available_endpoints
+    
+    MediLink_ConfigLoader.log("Endpoint order for payer lookup: {}".format(endpoint_order), level="DEBUG")
 
     for endpoint_name in endpoint_order:
         try:

MediLink/MediLink_DataMgmt.py

@@ -596,8 +596,10 @@ def organize_patient_data_by_endpoint(detailed_patient_data):
     """
     organized = {}
     for data in detailed_patient_data:
-        # Retrieve confirmed endpoint from each patient's data
-        endpoint = data['confirmed_endpoint'] if 'confirmed_endpoint' in data else data['suggested_endpoint']
+        # Retrieve endpoint in priority order: confirmed -> user_preferred -> suggested
+        endpoint = (data.get('confirmed_endpoint') or 
+                   data.get('user_preferred_endpoint') or 
+                   data.get('suggested_endpoint', 'AVAILITY'))
         # Initialize a list for the endpoint if it doesn't exist
         if endpoint not in organized:
             organized[endpoint] = []

MediLink/MediLink_UI.py

@@ -131,12 +131,17 @@ def display_file_summary(index, summary):
     # Add header row if it's the first index
     if index == 1:
         print("{:<3} {:5} {:<10} {:20} {:15} {:2} {:20}".format(
-            "No.", "Date", "ID", "Name", "Primary Ins.", "IT", "Suggested Endpoint"
+            "No.", "Date", "ID", "Name", "Primary Ins.", "IT", "Current Endpoint"
         ))
         print("-"*80)
 
     # Check if insurance_type is available; if not, set a default placeholder (this should already be '12' at this point)
     insurance_type = summary.get('insurance_type', '--')
+    
+    # Get the effective endpoint (confirmed > user preference > suggestion > default)
+    effective_endpoint = (summary.get('confirmed_endpoint') or 
+                         summary.get('user_preferred_endpoint') or 
+                         summary.get('suggested_endpoint', 'AVAILITY'))
 
     # Displays the summary of a file.
     print("{:02d}. {:5} ({:<8}) {:20} {:15} {:2} {:20}".format(
@@ -146,7 +151,7 @@ def display_file_summary(index, summary):
         summary['patient_name'][:20],
         summary['primary_insurance'][:15],
         insurance_type[:2],
-        summary['suggested_endpoint'][:20])
+        effective_endpoint[:20])
     )
 
 def user_select_files(file_list):