medicafe 0.240419.2__py3-none-any.whl → 0.240517.0__py3-none-any.whl

MediBot/MediBot_dataformat_library.py

@@ -1,8 +1,32 @@
 import re
 from datetime import datetime
 import re  #for addresses
-from MediBot_Preprocessor import open_csv_for_editing, config, initialize
-from MediBot_UI import manage_script_pause
+
+# Add parent directory of the project to the Python path
+import os
+import sys
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(project_dir)
+
+try: 
+    from MediLink import MediLink_ConfigLoader
+    config, crosswalk = MediLink_ConfigLoader.load_configuration()
+except ImportError:
+    from MediLink_ConfigLoader import load_configuration
+    config, crosswalk = load_configuration()
+
+from MediBot_Preprocessor_lib import open_csv_for_editing, initialize
+from MediBot_UI import manage_script_pause, app_control
+
+
+"""
+- [X] (TEST) Address Formatting 30-character Limit:
+    (LOW) Address the issue where the format_street function in Medibot may produce addresses exceeding
+    the 30-character limit. Current stop-gap is removing period characters and the abbreviation "APT" 
+    surrounded by spaces from all records as a temporary solution. 
+    If the address still exceeds 30 characters, the function will attempt to remove spaces from right to left
+    until it reaches 30 significant digits or runs out of spaces, then truncate to 30 characters if necessary.
+"""
 
 # Bring in all the constants
 initialize(config)
@@ -11,11 +35,13 @@ initialize(config)
 def format_name(value):  
     if ',' in value:
         return value
-    hyphenated_name_pattern = r'(?P<First>[\w-]+)\s+(?P<Middle>[\w-]+)?\s+(?P<Last>[\w-]+)'
+    hyphenated_name_pattern = r'(?P<First>[\w-]+)\s+(?P<Middle>[\w-]?)\s+(?P<Last>[\w-]+)'
     match = re.match(hyphenated_name_pattern, value)
     if match:
         first_name = match.group('First')
         middle_name = match.group('Middle') or ''
+        if len(middle_name) > 1:
+            middle_name = middle_name[0]  # take only the first character
         last_name = match.group('Last')
         return '{}, {} {}'.format(last_name, first_name, middle_name).strip()
     parts = value.split()
@@ -43,70 +69,97 @@ def format_policy(value):
 def format_gender(value):
     return value[0].upper()
 
+def enforce_significant_length(output):
+    # Replace spaces with a placeholder that counts as one significant digit
+    temp_output = output.replace('{Space}', ' ')
+    
+    # Check if the number of significant digits exceeds 30
+    if len(temp_output) > 30:
+        
+        # First line of defense: Replace ' APT ' with ' #' if the original length is longer than 30 characters.
+        temp_output = temp_output.replace(' APT ', ' #')
+        
+        # Remove spaces in a controlled manner from right to left if still too long
+        while len(temp_output) > 30:
+            # Find the last space
+            last_space_index = temp_output.rfind(' ')
+            if last_space_index == -1:
+                break
+            # Remove the last space
+            temp_output = temp_output[:last_space_index] + temp_output[last_space_index+7:]
+
+        # If still greater than 30, truncate to 30 characters
+        if len(temp_output) > 30:
+            temp_output = temp_output[:30]
+
+    # Replace placeholder back with actual space for final return
+    return temp_output.replace(' ', '{Space}')
+
 def format_street(value, csv_data, reverse_mapping, parsed_address_components):
-    global script_paused
-    script_paused = False
+    # Temporarily disable script pause status
+    app_control.set_pause_status(False)
     
-    # Remove periods from the input (seems to be an XP-only issue?)
+    # Remove period characters.
     value = value.replace('.', '')
     
-    # Only proceed with parsing if a comma is present in the value
+    # Proceed only if there's a comma, indicating a likely full address
     if ',' in value:
         try:
-            # Access the common cities from the loaded configuration
+            MediLink_ConfigLoader.log("Attempting to resolve address via regex...")
+            # Retrieve common city names from configuration and prepare a regex pattern
             common_cities = config.get('cities', [])
-
-            # Convert cities to a case-insensitive regex pattern
             city_pattern = '|'.join(re.escape(city) for city in common_cities)
             city_regex_pattern = r'(?P<City>{})'.format(city_pattern)
             city_regex = re.compile(city_regex_pattern, re.IGNORECASE)
 
-            # Check if the address contains one of the common cities
+            # Search for a common city in the address
             city_match = city_regex.search(value)
                     
             if city_match:
-                city = city_match.group('City').upper()  # Normalize city name to uppercase
+                # Extract city name and partition the value around it
+                city = city_match.group('City').upper()
                 street, _, remainder = value.partition(city)
-
-                # Extract state and zip code from the remainder
+                
+                # Regex pattern to find state and zip code in the remainder
                 address_pattern = r',\s*(?P<State>[A-Z]{2})\s*(?P<Zip>\d{5}(?:-\d{4})?)?'
-
                 match = re.search(address_pattern, remainder)
-                    
+
                 if match:
-                    # Update global parsed address components
+                    # Update parsed address components
                     parsed_address_components['City'] = city
                     parsed_address_components['State'] = match.group('State')
                     parsed_address_components['Zip Code'] = match.group('Zip')
-                    
-                    return street.strip()  # Return formatted street address
+                    # Return formatted street address, enforcing significant length
+                    return enforce_significant_length(street.strip())
             else:
-                # Fallback to old regex
-                # value = street + ', ' + city + remainder
+                # Fallback regex for parsing addresses without a common city
                 address_pattern = r'(?P<Street>[\w\s]+),?\s+(?P<City>[\w\s]+),\s*(?P<State>[A-Z]{2})\s*(?P<Zip>\d{5}(-\d{4})?)'
                 match = re.match(address_pattern, value)
 
                 if match:
-                    # Update global parsed address components
+                    # Update parsed address components
                     parsed_address_components['City'] = match.group('City')
                     parsed_address_components['State'] = match.group('State')
                     parsed_address_components['Zip Code'] = match.group('Zip')
-
-                    return match.group('Street').strip()  # Return formatted street address
+                    # Return formatted street address, enforcing significant length
+                    return enforce_significant_length(match.group('Street').strip())
                     
         except Exception as e:
+            # Handle exceptions by logging and offering to correct data manually
             print("Address format error: Unable to parse address '{}'. Error: {}".format(value, e))
-            print("Please update the CSV file for this record.")
-            script_paused = True
-            open_csv_for_editing(CSV_FILE_PATH)  # Offer to open the CSV for manual correction
-            manage_script_pause(csv_data, e, reverse_mapping) 
-            return value.replace(' ', '{Space}')  # Fallback to return original value with spaces escaped
+            app_control.set_pause_status(True)
+            open_csv_for_editing(CSV_FILE_PATH)
+            manage_script_pause(csv_data, e, reverse_mapping)
+            # Return original value with spaces formatted, enforcing significant length
+            return enforce_significant_length(value.replace(' ', '{Space}'))
     else:
-        # If no comma is present, return the value as is, assuming it's just a street name
-        return value.replace(' ', '{Space}')
-    
-    # This return acts as a fallback in case the initial comma check passes but no address components are matched
-    return value.replace(' ', '{Space}')  
+        # If no comma is present, treat the input as a simple street name
+        formatted_value = value.replace(' ', '{Space}')
+        enforced_format = enforce_significant_length(formatted_value)
+        return enforced_format
+
+    # Fallback return in case no address components are matched even though a comma was present
+    return enforce_significant_length(value.replace(' ', '{Space}')) 
 
 def format_zip(value):
     # Ensure the value is a string, in case it's provided as an integer
@@ -138,7 +191,7 @@ def format_data(medisoft_field, value, csv_data, reverse_mapping, parsed_address
     elif medisoft_field == 'Secondary Group Number':
         formatted_value = format_policy(value)
     else:
-        formatted_value = value
+        formatted_value = str(value) # Ensure value is always a string
 
     formatted_value = formatted_value.replace(',', '{,}').replace(' ', '{Space}')
     ahk_command = 'SendInput, {}{{Enter}}'.format(formatted_value)

MediBot/MediBot_docx_decoder.py

@@ -0,0 +1,80 @@
+"""
+Using docx-utils 0.1.3,
+
+This script parses a .docx file containing a table of patient information and extracts
+relevant data into a dictionary. Each row in the table corresponds to a new patient, 
+and the data from each cell is parsed into specific variables. The resulting dictionary 
+uses the 'Patient ID Number' as keys and lists containing 'Diagnosis Code', 
+'Left or Right Eye', and 'Femto yes or no' as values.
+
+Functions:
+    parse_docx(filepath): Reads the .docx file and constructs the patient data dictionary.
+    parse_patient_id(text): Extracts the Patient ID Number from the text.
+    parse_diagnosis_code(text): Extracts the Diagnosis Code from the text.
+    parse_left_or_right_eye(text): Extracts the eye information (Left or Right) from the text.
+    parse_femto_yes_or_no(text): Extracts the Femto information (yes or no) from the text.
+"""
+
+from docx import Document
+
+def parse_docx(filepath):
+    # Open the .docx file
+    doc = Document(filepath)
+    
+    # Initialize the dictionary to store data
+    patient_data = {}
+    
+    # Assuming the first table contains the required data
+    table = doc.tables[0]
+    
+    # Iterate over the rows in the table
+    for row in table.rows[1:]:  # Skip header row if it exists
+        cells = row.cells
+        
+        # Extract and parse data from each cell
+        patient_id = parse_patient_id(cells[0].text.strip())
+        diagnosis_code = parse_diagnosis_code(cells[1].text.strip())
+        left_or_right_eye = parse_left_or_right_eye(cells[2].text.strip())
+        femto_yes_or_no = parse_femto_yes_or_no(cells[3].text.strip())
+        
+        # Construct the dictionary entry
+        patient_data[patient_id] = [diagnosis_code, left_or_right_eye, femto_yes_or_no]
+    
+    return patient_data
+
+def parse_patient_id(text):
+    # Implement parsing logic for Patient ID Number
+    # Example: Assume the ID is the first part of the text, separated by a space or newline
+    return text.split()[0]
+
+def parse_diagnosis_code(text):
+    # Implement parsing logic for Diagnosis Code
+    # Example: Extract the code from a known pattern or location in the text
+    return text.split(':')[1].strip() if ':' in text else text
+
+def parse_left_or_right_eye(text):
+    # Implement parsing logic for Left or Right Eye
+    # Example: Assume the text contains 'Left' or 'Right' and extract it
+    if 'Left' in text:
+        return 'Left'
+    elif 'Right' in text:
+        return 'Right'
+    else:
+        return 'Unknown'
+
+def parse_femto_yes_or_no(text):
+    # Implement parsing logic for Femto yes or no
+    # Example: Check for presence of keywords 'yes' or 'no'
+    if 'yes' in text.lower():
+        return 'Yes'
+    elif 'no' in text.lower():
+        return 'No'
+    else:
+        return 'Unknown'
+
+# Placeholder function call (replace 'path_to_docx' with the actual file path)
+filepath = 'path_to_docx'
+patient_data_dict = parse_docx(filepath)
+
+# Print the resulting dictionary
+print(patient_data_dict)

MediBot/update_medicafe.py

@@ -1,17 +1,55 @@
 import subprocess
 import sys
 from tqdm import tqdm
+import requests
+import time
+
+def check_internet_connection():
+    try:
+        requests.get("http://www.google.com", timeout=5)
+        return True
+    except requests.ConnectionError:
+        return False
 
 def upgrade_medicafe(package):
     try:
-        # Use tqdm to create a progress bar
-        with tqdm(total=100, desc="Upgrading %s" % package, unit="%") as progress_bar:
-            subprocess.check_call([sys.executable, '-m', 'pip', 'install', '--upgrade', package, '--no-deps', '--disable-pip-version-check'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-            # Update progress bar to 100% upon completion
-            progress_bar.update(100 - progress_bar.n)
-        print("Update successful.")
-    except subprocess.CalledProcessError:
-        print("Update failed. Please check your internet connection and try again later.")
+        # Check internet connection
+        if not check_internet_connection():
+            print("Error: No internet connection detected. Please check your internet connection and try again.")
+            sys.exit(1)
+        
+        total_progress = 200  # Total progress for two runs
+        
+        with tqdm(total=total_progress, desc="Upgrading %s" % package, unit="%") as progress_bar:
+            stdout_accumulator = b""
+            stderr_accumulator = b""
+            
+            for _ in range(2):  # Run pip install twice
+                process = subprocess.Popen([sys.executable, '-m', 'pip', 'install', '--upgrade', package, '--no-cache-dir', '--disable-pip-version-check', '--no-deps'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                stdout, stderr = process.communicate()
+                stdout_accumulator += stdout
+                stderr_accumulator += stderr
+                
+                if process.returncode != 0:
+                    # If the return code is non-zero, print error details
+                    print("Error: Upgrade failed. Details:")
+                    print("stdout:", stdout)
+                    print("stderr:", stderr)
+                    sys.exit(1)
+                
+                progress_bar.update(total_progress // 2)  # Update progress bar
+                
+                # Add a 3-second sleep between runs
+                time.sleep(3)
+                
+            progress_bar.update(total_progress // 2)  # Update progress bar
+            print("stdout:", stdout_accumulator.decode("utf-8"))
+            print("stderr:", stderr_accumulator.decode("utf-8"))
+            time.sleep(1)
+    except Exception as e:
+        # Log any other exceptions
+        print("Error:", e)
+        time.sleep(3)
         sys.exit(1)
 
 if __name__ == "__main__":

MediLink/MediLink.py

@@ -1,13 +1,22 @@
 import os
-import MediLink_ConfigLoader
-import MediLink_837p_encoder
-import logging
 import MediLink_Down
 import MediLink_Up
+import MediLink_ConfigLoader
+import MediLink_837p_encoder
 
 # For UI Functions
 import os
 import MediLink_UI  # Import UI module for handling all user interfaces
+from tqdm import tqdm
+
+# Add parent directory of the project to the Python path
+import sys
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(project_dir)
+
+from MediBot import MediBot_Preprocessor_lib
+load_insurance_data_from_mains = MediBot_Preprocessor_lib.load_insurance_data_from_mains
+from MediBot import MediBot_Crosswalk_Library
 
 """
 Development Tasks for Backend Enhancement in MediSoft Claims Submittal (MediLink) Script:
@@ -22,17 +31,43 @@ any new endpoint changes to Optum. May need to "de-confirm" patients, but leave
 confirmed endpoints. This should be similar logic to if the user made a mistake and wants to go back and fix it.
 These tasks involve backend enhancements such as dynamic configurations, file detection improvements, file transmission verification, automation of response file handling, and management of intermediate files and transmission failures.
 
-TODO Crosswalk should be to PayerID key vs Medisoft:Endpoint.
-TODO Availity has a response file that says "File was received at TIME. File was sent for processing." as a confirmation 
+TODO (Low) Availity has a response file that says "File was received at TIME. File was sent for processing." as a confirmation 
 that sits in the SendFiles folder after a submittal. 
 
+TODO (Crosswalk) When an endpoint is updated in the UI, the crosswalk should also be updated and saved for that payer ID because that payer ID
+would basically forever need to be going to that endpoint for any patient. the suggested_endpoint should eventually be always correct.
+
 BUG Suggested Endpoint when you say 'n' to proceed with transmission is not getting updated with the endpoint 
 that was selected previously by the user. However, when we go back to the confirmation list, we do have a persist of the assignment.
 This can be confusing for the user.
-"""
 
-# Setup basic logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s\n')
+MediLink
+| - import MediLink_Down
+|   - import MediLink_ERA_decoder
+|   |   - from MediLink_ConfigLoader import load_configuration
+|   |   |   - None
+|   |   - from MediLink_DataMgmt import consolidate_csvs
+|   |   |   - from MediLink import MediLink_ConfigLoader
+|   |           - None
+|   - from MediLink_DataMgmt import operate_winscp
+|       - from MediLink import MediLink_ConfigLoader
+|           - None
+| - import MediLink_Up
+|   - None
+| - import MediLink_ConfigLoader
+|   - None
+| - import MediLink_837p_encoder
+|   - import MediLink_ConfigLoader
+|   |   - None
+|   - from MediLink_DataMgmt import parse_fixed_width_data, read_fixed_width_data
+|       - from MediLink import MediLink_ConfigLoader
+|           - None
+|   - import MediLink_837p_encoder_library
+|       - from MediLink import MediLink_ConfigLoader
+|           - None
+| - import MediLink_UI
+|   - None
+"""
 
 def detect_and_display_file_summaries(directory_path, config, crosswalk):
     """
@@ -88,15 +123,42 @@ def extract_and_suggest_endpoint(file_path, config, crosswalk):
     """
     detailed_patient_data = []
     
-    for personal_info, insurance_info, service_info in MediLink_837p_encoder.read_fixed_width_data(file_path, config.get('MediLink_Config', {})):
-        parsed_data = MediLink_837p_encoder.parse_fixed_width_data(personal_info, insurance_info, service_info, config.get('MediLink_Config', {}))
+    # Load insurance data from MAINS to create a mapping from insurance names to their respective IDs
+    insurance_to_id = load_insurance_data_from_mains(config)
+    MediLink_ConfigLoader.log("Insurance data loaded from MAINS. {} insurance providers found.".format(len(insurance_to_id)))
+
+    for personal_info, insurance_info, service_info in MediLink_837p_encoder.read_fixed_width_data(file_path):
+        parsed_data = MediLink_837p_encoder.parse_fixed_width_data(personal_info, insurance_info, service_info, config.get('MediLink_Config', config))
         
         primary_insurance = parsed_data.get('INAME')
         
-        # TODO This suggested endpoint should be a payerid_to_endpoint_mapping.
-        suggested_endpoint = crosswalk['insurance_to_endpoint_mapping'].get(primary_insurance, 'AVAILITY')
+        # Retrieve the insurance ID associated with the primary insurance
+        insurance_id = insurance_to_id.get(primary_insurance)
+        MediLink_ConfigLoader.log("Primary insurance ID retrieved for '{}': {}".format(primary_insurance, insurance_id))
+
+        # Use insurance ID to retrieve the payer ID(s) associated with the insurance
+        payer_ids = []
+        if insurance_id:
+            for payer_id, payer_data in crosswalk.get('payer_id', {}).items():
+                medisoft_ids = [str(id) for id in payer_data.get('medisoft_id', [])]
+                # MediLink_ConfigLoader.log("Payer ID: {}, Medisoft IDs: {}".format(payer_id, medisoft_ids))
+                if str(insurance_id) in medisoft_ids:
+                    payer_ids.append(payer_id)
+        if payer_ids:
+            MediLink_ConfigLoader.log("Payer IDs retrieved for insurance '{}': {}".format(primary_insurance, payer_ids))
+        else:
+            MediLink_ConfigLoader.log("No payer IDs found for insurance '{}'".format(primary_insurance))
         
-        # Directly enrich detailed patient data with additional information and suggested endpoint
+        # Find the suggested endpoint from the crosswalk based on the payer IDs
+        suggested_endpoint = 'AVAILITY'  # Default endpoint if no matching payer IDs found
+        if payer_ids:
+            payer_id = payer_ids[0]  # Select the first payer ID
+            suggested_endpoint = crosswalk['payer_id'].get(payer_id, {}).get('endpoint', 'AVAILITY')
+            MediLink_ConfigLoader.log("Suggested endpoint for payer ID '{}': {}".format(payer_id, suggested_endpoint))
+        else:
+            MediLink_ConfigLoader.log("No suggested endpoint found for payer IDs: {}".format(payer_ids))
+
+        # Enrich detailed patient data with additional information and suggested endpoint
         detailed_data = parsed_data.copy()  # Copy parsed_data to avoid modifying the original dictionary
         detailed_data.update({
             'file_path': file_path,
@@ -134,20 +196,50 @@ def organize_patient_data_by_endpoint(detailed_patient_data):
 def check_for_new_remittances(config):
     print("\nChecking for new files across all endpoints...")
     endpoints = config['MediLink_Config']['endpoints']
-    for endpoint_key, endpoint_info in endpoints.items():
-        try:
-            # Pass the endpoint key to MediLink_Down.main() as an argument
-            ERA_path = MediLink_Down.main(desired_endpoint=endpoint_key)
-            # BUG This needs to check to see if this actually worked maybe winscplog before saying it completed successfully 
-            print("New remittances for {} completed successfully.".format(endpoint_info['name']))
-            print("Results saved to: {}\n".format(ERA_path))
-        except Exception as e:
-            print("An error occurred while checking remittances for {}: {}".format(endpoint_info['name'], e))
+    processed_endpoints = []
+    
+    if isinstance(endpoints, dict): # BUG This check can probably be removed later.
+        for endpoint_key, endpoint_info in tqdm(endpoints.items(), desc="Processing endpoints"):
+            if 'remote_directory_down' in endpoint_info:  # Check if the 'remote_directory_down' key exists
+                #print("Processing endpoint: ", endpoint_info['name']) 
+                # BUG (Debug and verbosity removal) this is really for debug only. Positive statements can be muted.
+                try:
+                    ERA_path = MediLink_Down.main(desired_endpoint=endpoint_key)
+                    processed_endpoints.append((endpoint_info['name'], ERA_path))
+                    MediLink_ConfigLoader.log("Results for {} saved to: {}".format(endpoint_info['name'], ERA_path))
+                    # TODO (Low SFTP - Download side) This needs to check to see if this actually worked maybe winscplog before saying it completed successfully 
+                    # Check if there is commonality with the upload side so we can use the same validation function.
+                except Exception as e:
+                    print("An error occurred while checking remittances for {}: {}".format(endpoint_info['name'], e))
+            else:
+                MediLink_ConfigLoader.log("Skipping endpoint '{}' as it does not have 'remote_directory_down' configured.".format(endpoint_info['name']))
+    else:
+        print("Error: Endpoint config is not a 'dictionary' as expected.")
+    # Check if all ERA paths are the same
+    unique_era_paths = set(path for _, path in processed_endpoints)
+    if len(unique_era_paths) == 1:
+        common_era_path = unique_era_paths.pop()  # Get the common ERA path
+        endpoints_list = ", ".join(endpoint for endpoint, _ in processed_endpoints)
+        print("\nProcessed Endpoints: {}".format(endpoints_list))
+        print("File located at: {}\n".format(common_era_path))
+        # TODO (MediPost) These prints will eventually be logs when MediPost is made.
+        
+    else:
+        if processed_endpoints:
+            print("\nProcessed Endpoints:")
+            for endpoint, path in processed_endpoints:
+                print("Endpoint: {}, ERA Path: {}".format(endpoint, path))
+        else:
+            print("No endpoints were processed.")
 
 def user_decision_on_suggestions(detailed_patient_data, config):
     """
     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.
     """
     # Display summaries of patient details and endpoints.
     MediLink_UI.display_patient_summaries(detailed_patient_data)
@@ -174,15 +266,19 @@ def confirm_all_suggested_endpoints(detailed_patient_data):
 def select_and_adjust_files(detailed_patient_data, config):
     """
     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.
     """
     # Display options for patients
     MediLink_UI.display_patient_options(detailed_patient_data)
 
     # Get user-selected indices for adjustment
     selected_indices = MediLink_UI.get_selected_indices(len(detailed_patient_data))
-
-    # Fetch endpoint names dynamically from the JSON config
-    endpoint_mapping = {str(i + 1): config['MediLink_Config']['endpoints'][endpoint]['name'] for i, endpoint in enumerate(config['MediLink_Config']['endpoints'])}
+    
+    # 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:
@@ -190,20 +286,20 @@ def select_and_adjust_files(detailed_patient_data, config):
         MediLink_UI.display_patient_for_adjustment(data['patient_name'], data.get('suggested_endpoint', 'N/A'))
         
         endpoint_change = MediLink_UI.get_endpoint_decision()
-
         if endpoint_change == 'y':
-            MediLink_UI.display_endpoint_options(endpoint_mapping)            
-            new_endpoint_choice = MediLink_UI.get_new_endpoint_choice()
+            MediLink_UI.display_endpoint_options(config['MediLink_Config']['endpoints'])
+            endpoint_index = int(MediLink_UI.get_new_endpoint_choice()) - 1  # Adjusting for zero-based index
             
-            if new_endpoint_choice in endpoint_mapping:
-                data['confirmed_endpoint'] = endpoint_mapping[new_endpoint_choice]
-                print("Endpoint changed to {0} for patient {1}.".format(data['confirmed_endpoint'], data['patient_name']))
+            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???
             else:
                 print("Invalid selection. Keeping the suggested endpoint.")
         else:
             data['confirmed_endpoint'] = data.get('suggested_endpoint', 'N/A')
 
-    # Return the updated data
     return detailed_patient_data
 
 def main_menu():
@@ -212,7 +308,14 @@ def main_menu():
     including loading configurations and managing user input for menu selections.
     """
     # Load configuration settings and display the initial welcome message.
-    config, crosswalk = MediLink_ConfigLoader.load_configuration() # BUG does this need an argument?
+    config, crosswalk = MediLink_ConfigLoader.load_configuration() 
+    
+    # Check to make sure payer_id key is available in crosswalk, otherwise, go through that crosswalk initialization flow
+    MediBot_Crosswalk_Library.check_and_initialize_crosswalk(config)
+    
+    # Check if the application is in test mode
+    if config.get("MediLink_Config", {}).get("TestMode", False):
+        print("\n--- MEDILINK TEST MODE --- \nTo enable full functionality, please update the config file \nand set 'TestMode' to 'false'.")
     
     # Display Welcome Message
     MediLink_UI.display_welcome()
@@ -265,7 +368,8 @@ def handle_submission(detailed_patient_data, config):
         if MediLink_Up.confirm_transmission(organized_data):
             if MediLink_Up.check_internet_connection():
                 # Submit claims if internet connectivity is confirmed.
-                MediLink_Up.submit_claims(organized_data, config)
+                _ = MediLink_Up.submit_claims(organized_data, config)
+                # TODO submit_claims will have a receipt return in the future.
             else:
                 # Notify the user of an internet connection error.
                 print("Internet connection error. Please ensure you're connected and try again.")