medicafe 0.240716.2__tar.gz → 0.240809.0__tar.gz

{medicafe-0.240716.2 → medicafe-0.240809.0}/MediBot/MediBot.py

@@ -262,10 +262,21 @@ if __name__ == "__main__":
                 print("\nNOTE: The following patient(s) already EXIST in the system and \n      will be excluded from processing:")
                 # TODO ... not excluded anymore, because charges may need to be added. 
                 # So at this point in the processing, we should have already processed the surgery schedules and enriched the data with Charges.
+                # Find the corresponding rows in csv_data to get the surgery dates and store them along with patient info
+                patient_info = []
                 for patient_id, patient_name in existing_patients:
-                    print("(ID: {0}) {1}".format(patient_id, patient_name))
+                    surgery_date = next((row.get('Surgery Date', 'Unknown Date') for row in csv_data if row.get(reverse_mapping['Patient ID #2']) == patient_id), 'Unknown Date')
+                    patient_info.append((surgery_date, patient_name, patient_id))
+
+                # Sort by surgery date first and then by patient name
+                patient_info.sort(key=lambda x: (x[0], x[1]))
+
+                # Print the sorted patient info
+                for index, (surgery_date, patient_name, patient_id) in enumerate(patient_info):
+                    print("{0:03d}: {3:%m-%d} (ID: {2}) {1} ".format(index + 1, patient_name, patient_id, surgery_date))
+
                 # Update csv_data to exclude existing patients
-                # TODO This now has to be updated to handle patients that exist but need new charges added. 
+                # TODO This now has to be updated to handle patients that exist but need new charges added.
                 csv_data = [row for row in csv_data if row[reverse_mapping['Patient ID #2']] in patients_to_process]
             else:
                 print("\nSelected patient(s) are NEW patients and will be processed.")

{medicafe-0.240716.2 → medicafe-0.240809.0}/MediBot/MediBot_Preprocessor_lib.py

@@ -124,7 +124,8 @@ def sort_and_deduplicate(csv_data):
         if patient_id not in unique_patients or row['Surgery Date'] < unique_patients[patient_id]['Surgery Date']:
             unique_patients[patient_id] = row
     csv_data[:] = list(unique_patients.values())
-    # TODO Sorting, now that we're going to have the Surgery Schedules available, should be ordered as the patients show up on the schedule.
+    # TODO Sorting, now that we're going to have the Surgery Schedules available, should (or shouldn't?? 
+    # maybe we should build in the option as liek a 'setting' in the config) be ordered as the patients show up on the schedule.
     # If we don't have that surgery schedule yet for some reason, we should default to the current ordering strategy.
     csv_data.sort(key=lambda x: (x['Surgery Date'], x.get('Patient Last', '').strip()))
 
@@ -161,7 +162,16 @@ def update_insurance_ids(csv_data, crosswalk):
                 medisoft_ids = crosswalk['payer_id'][ins1_payer_id].get('medisoft_id', [])
                 if medisoft_ids:
                     medisoft_ids = [int(id) for id in medisoft_ids]
-                    # TODO Try to match OpenPM's Insurance Name to get a better match
+                    # TODO Try to match OpenPM's Insurance Name to get a better match. 
+                    # Potential approach:
+                    # 1. Retrieve the insurance name from the current row
+                    # insurance_name = row.get('Primary Insurnace', '').strip()
+                    # 2. Check if the insurance name exists in the subset of MAINS names associated with 
+                    # crosswalk medisoft ID values for the given payer ID.
+                    # 3. If an approximate match is found above a certain confidence, use the corresponding medisoft_id.
+                    # else: 4. If no match is found, default to the first medisoft_id
+                    #     row['Ins1 Insurance ID'] = medisoft_ids[0]
+                    
                     row['Ins1 Insurance ID'] = medisoft_ids[0] 
                     # MediLink_ConfigLoader.log("Ins1 Insurance ID '{}' used for Payer ID {} in crosswalk.".format(row.get('Ins1 Insurance ID', ''), ins1_payer_id))
             else:
@@ -367,6 +377,8 @@ def load_insurance_data_from_mains(config):
     # Retrieve MAINS path and slicing information from the configuration   
     # TODO (Low) For secondary insurance, this needs to be pulling from the correct MAINS (there are 2)
     # TODO (Low) Performance: There probably needs to be a dictionary proxy for MAINS that gets updated.
+    # Meh, this just has to be part of the new architecture plan where we make Medisoft a downstream 
+    # recipient from the db.
     mains_path = config['MAINS_MED_PATH']
     mains_slices = crosswalk['mains_mapping']['slices']
     

{medicafe-0.240716.2 → medicafe-0.240809.0}/MediLink/MediLink.py

@@ -58,7 +58,7 @@ def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_map
     TODO: Implement a function to provide `patient_insurance_mapping` from a reliable source.
     """
     if patient_insurance_type_mapping is None:
-        MediLink_ConfigLoader.log("No Patient:Insurance-Type mapping available.")
+        MediLink_ConfigLoader.log("No Patient:Insurance-Type mapping available.", level="WARNING")
         patient_insurance_type_mapping = {}
     
     for data in detailed_patient_data:
@@ -86,7 +86,7 @@ def extract_and_suggest_endpoint(file_path, config, crosswalk):
     
     # 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)))
+    MediLink_ConfigLoader.log("Insurance data loaded from MAINS. {} insurance providers found.".format(len(insurance_to_id)), level="INFO")
 
     for personal_info, insurance_info, service_info, service_info_2, service_info_3 in MediLink_DataMgmt.read_fixed_width_data(file_path):
         parsed_data = MediLink_DataMgmt.parse_fixed_width_data(personal_info, insurance_info, service_info, service_info_2, service_info_3, config.get('MediLink_Config', config))
@@ -148,13 +148,13 @@ def check_for_new_remittances(config):
                 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))
+                    MediLink_ConfigLoader.log("Results for {} saved to: {}".format(endpoint_info['name'], ERA_path), level="DEBUG")
                     # 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']))
+                MediLink_ConfigLoader.log("Skipping endpoint '{}' as it does not have 'remote_directory_down' configured.".format(endpoint_info['name']), level="WARNING")
     else:
         print("Error: Endpoint config is not a 'dictionary' as expected.")
     # Check if all ERA paths are the same

{medicafe-0.240716.2 → medicafe-0.240809.0}/MediLink/MediLink_837p_encoder.py

@@ -77,33 +77,27 @@ def format_single_claim(patient_data, config, endpoint, transaction_set_control_
 
     return formatted_837p
 
-def write_output_file(document_segments, output_directory, endpoint_key, input_file_path, config):
+def write_output_file(document_segments, output_directory, endpoint_key, input_file_path, config, suffix=""):
     """
     Writes formatted 837P document segments to an output file with a dynamically generated name.
-    
-    Development Roadmap:
-    - Ensure input `document_segments` is a non-empty list to avoid creating empty files.
-    - Verify `output_directory` exists and is writable before proceeding. Create the directory if it does not exist.
-    - Consider parameterizing the file naming convention or providing options for customization to accommodate different organizational needs.
-    - Implement error handling to gracefully manage file writing failures, potentially returning a status or error message alongside the file path.
-    - Incorporate logging directly within the function, accepting an optional `config` or `logger` parameter to facilitate tracking of the file writing process and outcomes.
-    - Update the return value to include both the path to the output file and any relevant status information (e.g., success flag, error message) to enhance downstream error handling and user feedback.
-    
+
     Parameters:
     - document_segments: List of strings, where each string is a segment of the 837P document to be written.
     - output_directory: String specifying the directory where the output file will be saved.
     - endpoint_key: String specifying the endpoint for which the claim is processed, used in naming the output file.
     - input_file_path: String specifying the path to the input file being processed, used in naming the output file.
-    
+    - config: Configuration settings for logging and other purposes.
+    - suffix: Optional string to differentiate filenames, useful for single-patient processing.
+
     Returns:
-    - String specifying the path to the successfully created output file. Consider returning a tuple (path, status) for enhanced error handling.
+    - String specifying the path to the successfully created output file, or None if an error occurred.
     """
-    # Check if document segments are empty
+    # Ensure the document segments are not empty
     if not document_segments:
         MediLink_ConfigLoader.log("Error: Empty document segments provided. No output file created.", config, level="ERROR")
         return None
     
-    # Check if the output directory exists and is writable
+    # Verify the output directory exists and is writable, create if necessary
     if not os.path.exists(output_directory):
         try:
             os.makedirs(output_directory)
@@ -114,13 +108,13 @@ def write_output_file(document_segments, output_directory, endpoint_key, input_f
         MediLink_ConfigLoader.log("Error: Output directory is not writable.", config, level="ERROR")
         return None
     
-    # Generate new output file path
+    # Generate the new output file path
     base_name = os.path.splitext(os.path.basename(input_file_path))[0]
     timestamp = datetime.now().strftime("%m%d%H%M")
-    new_output_file_name = "{}_{}_{}.txt".format(base_name, endpoint_key.lower(), timestamp)
+    new_output_file_name = "{}_{}_{}{}.txt".format(base_name, endpoint_key.lower(), timestamp, suffix)
     new_output_file_path = os.path.join(output_directory, new_output_file_name)
 
-    # Write formatted 837P document to the output file
+    # Write the document to the output file
     try:
         with open(new_output_file_path, 'w') as output_file:
             output_file.write('\n'.join(document_segments))
@@ -335,7 +329,7 @@ def main():
     parser.add_argument(
         "-e", "--endpoint", 
         required=True,
-        choices=["AVAILITY", "OPTUMEDI", "PNT_DATA"],
+        choices=["AVAILITY", "OPTUMEDI", "PNT_DATA", "UHCAPI"],
         help="Specify the endpoint for which the conversion is intended."
     )
     parser.add_argument(
@@ -388,9 +382,9 @@ if __name__ == "__main__":
 #######################################################################################
 
 def convert_files_for_submission(detailed_patient_data, config):
-    """    
+    """
     Processes detailed patient data for submission based on their confirmed endpoints,
-    generating a separate 837P file for each endpoint.
+    generating separate 837P files for each endpoint according to the configured submission type.
 
     Parameters:
     - detailed_patient_data: A list containing detailed patient data with endpoint information.
@@ -398,73 +392,93 @@ def convert_files_for_submission(detailed_patient_data, config):
 
     Returns:
     - A list of paths to the converted files ready for submission.
+
+    Note:
+    - This function currently supports batch and single-patient submissions based on the configuration.
+    - Future implementation may include progress tracking using tools like `tqdm`.
     """
 
     # Initialize a dictionary to hold patient data segregated by confirmed endpoints
     data_by_endpoint = {}
-        
-    # Populate the dictionary with patient data
+
+    # Group patient data by endpoint
     for data in detailed_patient_data:
-        endpoint = data['confirmed_endpoint']
-        if endpoint not in data_by_endpoint:
-            data_by_endpoint[endpoint] = []
-        data_by_endpoint[endpoint].append(data)
+        endpoint = data.get('confirmed_endpoint')
+        if endpoint:
+            if endpoint not in data_by_endpoint:
+                data_by_endpoint[endpoint] = []
+            data_by_endpoint[endpoint].append(data)
 
     # List to store paths of converted files for each endpoint
     converted_files_paths = []
 
-    # Determine the total number of unique endpoints for progress bar
-    # total_endpoints = len(data_by_endpoint)
-
     # Iterate over each endpoint and process its corresponding patient data
     for endpoint, patient_data_list in data_by_endpoint.items():
-        # tqdm(data_by_endpoint.items(), desc="Creating 837p(s)", total=total_endpoints, ascii=True)
-        # Each endpoint might have multiple patients' data to be processed into a single 837P file
-        if patient_data_list:
-            converted_path = process_claim(config['MediLink_Config'], endpoint, patient_data_list)
+        # Retrieve submission type from config; default to "batch" if not specified
+        submission_type = config.get('MediLink_Config', {}).get('endpoints', {}).get(endpoint, {}).get('submission_type', 'batch')
+
+        if submission_type == 'single':
+            # Process each patient's data individually for single-patient submissions
+            for patient_data in patient_data_list:
+                # Generate a unique suffix for each patient, e.g., using a truncated chart number
+                chart_number = patient_data.get('CHART', 'UNKNOWN')#[:5] truncation might cause collisions.
+                suffix = "_{}".format(chart_number)
+                # Process and convert each patient's data to a separate file
+                converted_path = process_claim(config, endpoint, [patient_data], suffix)
+                if converted_path:
+                    converted_files_paths.append(converted_path)
+        else:
+            # Process all patient data together for batch submissions
+            converted_path = process_claim(config, endpoint, patient_data_list)
             if converted_path:
                 converted_files_paths.append(converted_path)
-        
+
     return converted_files_paths
 
-def process_claim(config, endpoint, patient_data_list):
+def process_claim(config, endpoint, patient_data_list, suffix=""):
     """
     Processes patient data for a specified endpoint, converting it into the 837P format.
-    Generates a separate 837P file for each endpoint based on detailed patient data.
+    Can handle both batch and single-patient submissions.
 
     Parameters:
     - config: Configuration settings loaded from a JSON file.
-    - endpoint_key: The key representing the endpoint for which the data is being processed.
+    - endpoint: The key representing the endpoint for which the data is being processed.
     - patient_data_list: A list of dictionaries, each containing detailed patient data.
+    - suffix: An optional suffix to differentiate filenames for single-patient processing.
 
     Returns:
     - Path to the converted file, or None if an error occurs.
-    
-    TODO (LOW) Why are there duplicated interchange flows? Because the arg if we're doing a .dat directory or not. 
-    Although, that shouldn't be making duplicates of these interchange headers. That's still confusing and could end up making 
-    duplicate interchange headers because processing .dat in batch might be fast enough to be a problem.
     """
+    # Ensure we're accessing the correct configuration key
+    config = config.get('MediLink_Config', config)
+    
+    # Retrieve the output directory from the configuration
     output_directory = MediLink_837p_encoder_library.get_output_directory(config)
     if not output_directory:
         return None
 
-    # Initialize the transaction set control number and document segments
     transaction_set_control_number = 1
     document_segments = []
 
-    # Process each patient's data in the list
     for patient_data in patient_data_list:
-        # Validate each patient's data
+        # Validate each patient's data before processing
         is_valid, validation_errors = validate_claim_data(patient_data, config)
         if is_valid:
-            # Format the claim if data is valid
+            # Format the claim into 837P segments
             formatted_claim = format_single_claim(patient_data, config, endpoint, transaction_set_control_number)
             document_segments.append(formatted_claim)
             transaction_set_control_number += 1
         else:
+            # Log any validation errors encountered
+            MediLink_ConfigLoader.log("Validation errors for patient data: {}".format(validation_errors), config, level="ERROR")
             if MediLink_837p_encoder_library.handle_validation_errors(transaction_set_control_number, validation_errors, config):
                 continue # Skip the current patient
 
+    if not document_segments:
+        # If no valid segments were created, log the issue and return None
+        MediLink_ConfigLoader.log("No valid document segments created.", config, level="ERROR")
+        return None
+
     # Create interchange elements with the final transaction set control number
     isa_header, gs_header, ge_trailer, iea_trailer = MediLink_837p_encoder_library.create_interchange_elements(config, endpoint, transaction_set_control_number - 1)
 
@@ -473,5 +487,8 @@ def process_claim(config, endpoint, patient_data_list):
     document_segments.insert(0, isa_header)
     document_segments.extend([ge_trailer, iea_trailer])
 
-    # Write the complete 837P document to an output file and return its path
-    return write_output_file(document_segments, output_directory, endpoint, patient_data_list[0]['file_path'], config)
+    # Use the first patient's file path as a reference for output file naming
+    input_file_path = patient_data_list[0].get('file_path', 'UNKNOWN')
+    # Write the complete 837P document to an output file
+    converted_file_path = write_output_file(document_segments, output_directory, endpoint, input_file_path, config, suffix)
+    return converted_file_path

{medicafe-0.240716.2 → medicafe-0.240809.0}/MediLink/MediLink_837p_encoder_library.py

@@ -288,7 +288,7 @@ def resolve_payer_name(payer_id, config, primary_endpoint, insurance_name, parse
                     MediLink_ConfigLoader.log("API Resolved to standard insurance name: {} for corrected payer ID: {}".format(resolved_name, corrected_payer_id), config, level="INFO")
                     
                     confirmation = input("Is the standard insurance name '{}' correct? (yes/no): ".format(resolved_name)).strip().lower()
-                    
+                    # BUG There is duplication of code here.
                     if confirmation in ['yes', 'y']:
                         if MediBot_Crosswalk_Library.update_crosswalk_with_corrected_payer_id(payer_id, corrected_payer_id):
                             return resolved_name
@@ -309,11 +309,16 @@ def resolve_payer_name(payer_id, config, primary_endpoint, insurance_name, parse
 
 def prompt_user_for_payer_id(insurance_name):
     """
-    Prompts the user to input the payer ID manually.
+    Prompts the user to input the payer ID manually and ensures that a valid ID is provided.
     """
-    print("Manual intervention required: No payer ID found for insurance name '{}'.".format(insurance_name))
-    payer_id = input("Please enter the payer ID manually: ").strip()
-    return payer_id
+    while True:
+        print("Manual intervention required: No payer ID found for insurance name '{}'.".format(insurance_name))
+        payer_id = input("Please enter the payer ID manually: ").strip()
+        
+        if payer_id:
+            return payer_id
+        else:
+            print("Error: Payer ID cannot be empty. Please try again.")
 
 def build_nm1_segment(payer_name, payer_id):
     # Step 1: Build NM1 segment using payer name and ID
@@ -407,7 +412,7 @@ def handle_missing_payer_id(insurance_name, config):
     
     # Ask for user confirmation
     confirmation = input("Is the standard insurance name '{}' correct? (yes/no): ".format(standard_insurance_name)).strip().lower() or 'yes'
-    
+    # BUG There is duplication of code here.
     if confirmation in ['yes', 'y']:
         # Update the crosswalk with the new payer ID and insurance name mapping
         MediBot_Crosswalk_Library.update_crosswalk_with_new_payer_id(insurance_name, payer_id, config)
@@ -847,10 +852,17 @@ def winscp_validate_output_directory(output_directory):
 
 def get_output_directory(config):
     # Retrieve desired default output file path from config 
-    output_directory = config.get('outputFilePath', '')
+    output_directory = config.get('outputFilePath', '').strip()
     # BUG (Low SFTP) Add WinSCP validation because of the mishandling of spaces in paths. (This shouldn't need to exist.)
+    if not output_directory:
+        print("Output file path is not specified in the configuration.")
+        output_directory = input("Please enter a valid output directory path: ").strip()
+    
+    # Validate the directory path (checks for spaces and existence)
     output_directory = winscp_validate_output_directory(output_directory)
+    
     if not os.path.isdir(output_directory):
-        print("Output directory does not exist. Please check the configuration.")
+        print("Output directory does not exist or is not accessible. Please check the configuration.")
         return None
+    
     return output_directory

{medicafe-0.240716.2 → medicafe-0.240809.0}/MediLink/MediLink_API_v3.py

@@ -9,6 +9,14 @@ try:
 except ImportError:
     import MediLink_ConfigLoader
 
+"""
+TODO At some point it might make sense to test their acknoledgment endpoint. body is transactionId.
+This API is used to extract the claim acknowledgement details for the given transactionid which was 
+generated for 837 requests in claim submission process. Claims Acknowledgement (277CA) will provide 
+a status of claim-level acknowledgement of all claims received in the front-end processing system and 
+adjudication system.
+"""
+
 class ConfigLoader:
     @staticmethod
     def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..', 'json', 'config.json'), 
@@ -175,7 +183,7 @@ def fetch_payer_name_from_api(payer_id, config, primary_endpoint='AVAILITY'):
     raise ValueError(error_message)
 
 def get_claim_summary_by_provider(client, tin, first_service_date, last_service_date, payer_id, get_standard_error='false'):
-    endpoint_name = 'UHCApi'
+    endpoint_name = 'UHCAPI'
     url_extension = client.config['MediLink_Config']['endpoints'][endpoint_name]['additional_endpoints']['claim_summary_by_provider']
     headers = {
         'tin': tin,
@@ -188,7 +196,7 @@ def get_claim_summary_by_provider(client, tin, first_service_date, last_service_
     return client.make_api_call(endpoint_name, 'GET', url_extension, params=None, data=None, headers=headers)
 
 def get_eligibility(client, payer_id, provider_last_name, search_option, date_of_birth, member_id, npi):
-    endpoint_name = 'UHCApi'
+    endpoint_name = 'UHCAPI'
     url_extension = client.config['MediLink_Config']['endpoints'][endpoint_name]['additional_endpoints']['eligibility']
     url_extension = url_extension + '?payerID={}&providerLastName={}&searchOption={}&dateOfBirth={}&memberId={}&npi={}'.format(
         payer_id, provider_last_name, search_option, date_of_birth, member_id, npi)
@@ -210,7 +218,7 @@ def get_eligibility_v3(client, payer_id, provider_last_name, search_option, date
     if payer_id not in valid_payer_ids:
         raise ValueError("Invalid payer_id: {}. Must be one of: {}".format(payer_id, ", ".join(valid_payer_ids)))
     
-    endpoint_name = 'UHCApi'
+    endpoint_name = 'UHCAPI'
     url_extension = client.config['MediLink_Config']['endpoints'][endpoint_name]['additional_endpoints']['eligibility_v3']
     
     # Construct request body
@@ -253,6 +261,90 @@ def get_eligibility_v3(client, payer_id, provider_last_name, search_option, date
 
     return client.make_api_call(endpoint_name, 'POST', url_extension, params=None, data=body)
 
+def is_test_mode(client, body, endpoint_type):
+    """
+    Checks if Test Mode is enabled in the client's configuration and simulates the response if it is.
+
+    :param client: An instance of APIClient
+    :param body: The intended request body
+    :param endpoint_type: The type of endpoint being accessed ('claim_submission' or 'claim_details')
+    :return: A dummy response simulating the real API call if Test Mode is enabled, otherwise None
+    """
+    if client.config.get("MediLink_Config", {}).get("TestMode", True):
+        print("Test Mode is enabled! API Call not executed.")
+        print("\nIntended request body:", body)
+        MediLink_ConfigLoader.log("Test Mode is enabled! Simulating API response for {}.".format(endpoint_type), level="INFO")
+        MediLink_ConfigLoader.log("Intended request body: {}".format(body), level="INFO")
+
+        if endpoint_type == 'claim_submission':
+            dummy_response = {
+                "transactionId": "CS07180420240328013411240",  # This is the tID for the sandbox Claim Acknowledgement endpoint.
+                "x12ResponseData": "ISA*00* *00* *ZZ*TEST1234567890 *33*TEST *210101*0101*^*00501*000000001*0*P*:~GS*HC*TEST1234567890*TEST*20210101*0101*1*X*005010X222A1~ST*837*000000001*005010X222A1~BHT*0019*00*00001*20210101*0101*CH~NM1*41*2*TEST SUBMITTER*****46*TEST~PER*IC*TEST CONTACT*TE*1234567890~NM1*40*2*TEST RECEIVER*****46*TEST~HL*1**20*1~NM1*85*2*TEST PROVIDER*****XX*1234567890~N3*TEST ADDRESS~N4*TEST CITY*TEST STATE*12345~REF*EI*123456789~PER*IC*TEST PROVIDER*TE*1234567890~NM1*87*2~N3*TEST ADDRESS~N4*TEST CITY*TEST STATE*12345~HL*2*1*22*0~SBR*P*18*TEST GROUP******CI~NM1*IL*1*TEST PATIENT****MI*123456789~N3*TEST ADDRESS~N4*TEST CITY*TEST STATE*12345~DMG*D8*19800101*M~NM1*PR*2*TEST INSURANCE*****PI*12345~CLM*TESTCLAIM*100***12:B:1*Y*A*Y*Y*P~REF*D9*TESTREFERENCE~HI*ABK:TEST~NM1*DN*1*TEST DOCTOR****XX*1234567890~LX*1~SV1*HC:TEST*100*UN*1***1~DTP*472*RD8*20210101-20210101~REF*6R*TESTREFERENCE~SE*30*000000001~GE*1*1~IEA*1*000000001~",
+                "responseType": "dummy_response_837999",
+                "message": "Test Mode: Claim validated and sent for further processing"
+            }
+        elif endpoint_type == 'claim_details':
+            dummy_response = {
+                "responseType": "dummy_response_277CA-CH",
+                "x12ResponseData": "ISA*00* *00*  *ZZ*841162764 *ZZ*UB920086 *240318*0921*^*00501*000165687*0*T*:~GS*HN*841162764*UB920086*20240318*0921*0165687*X*005010X214~ST*277*000000006*005010X214~…………….. SE*116*000000006~GE*1*0165687~IEA*1*000165687~",
+                "statuscode": "000",
+                "message:": ""
+            }
+        return dummy_response
+    return None
+
+def submit_uhc_claim(client, x12_request_data):
+    """
+    Submits a UHC claim and retrieves the claim acknowledgement details.
+
+    This function first submits the claim using the provided x12 837p data. If the client is in Test Mode, 
+    it returns a simulated response. If Test Mode is not enabled, it submits the claim and then retrieves 
+    the claim acknowledgement details using the transaction ID from the initial response.
+
+    :param client: An instance of APIClient
+    :param x12_request_data: The x12 837p data as a string
+    :return: The final response containing the claim acknowledgement details or a dummy response if in Test Mode
+    """
+    endpoint_name = 'UHCAPI'
+    claim_submission_url = client.config['MediLink_Config']['endpoints'][endpoint_name]['additional_endpoints']['claim_submission']
+    claim_details_url = client.config['MediLink_Config']['endpoints'][endpoint_name]['additional_endpoints']['claim_details']
+
+    # Headers for the request
+    headers = {'Content-Type': 'application/json'} 
+
+    # Request body for claim submission
+    claim_body = {'x12RequestData': x12_request_data}
+
+    # Check if Test Mode is enabled and return simulated response if so
+    test_mode_response = is_test_mode(client, claim_body, 'claim_submission')
+    if test_mode_response:
+        return test_mode_response
+    
+    # Make the API call to submit the claim
+    try:
+        submission_response = client.make_api_call(endpoint_name, 'POST', claim_submission_url, data=claim_body, headers=headers)
+        
+        # Extract the transaction ID from the submission response
+        transaction_id = submission_response.get('transactionId')
+        if not transaction_id:
+            raise ValueError("transactionId not found in the submission response")
+        
+        # Prepare the request body for the claim acknowledgement retrieval
+        acknowledgement_body = {'transactionId': transaction_id}
+
+        # Check if Test Mode is enabled and return simulated response if so
+        test_mode_response = is_test_mode(client, acknowledgement_body, 'claim_details')
+        if test_mode_response:
+            return test_mode_response
+
+        # Make the API call to retrieve the claim acknowledgement details
+        acknowledgement_response = client.make_api_call(endpoint_name, 'POST', claim_details_url, data=acknowledgement_body, headers=headers)
+        return acknowledgement_response
+
+    except Exception as e:
+        print("Error during claim processing: {}".format(e))
+        raise
+
 if __name__ == "__main__":
     client = APIClient()
     
@@ -261,7 +353,8 @@ if __name__ == "__main__":
         'test_fetch_payer_name': False,
         'test_claim_summary': False,
         'test_eligibility': False,
-        'test_eligibility_v3': True,
+        'test_eligibility_v3': False,
+        'test_claim_submission': True,
     }
     
     try:
@@ -321,5 +414,16 @@ if __name__ == "__main__":
             except Exception as e:
                 print("Error in getting eligibility for {}: {}".format(patient['provider_last_name'], e))
         """
+        # Test 5: UHC Claim Submission
+        if test_config.get('test_claim_submission', False):
+            try:
+                x12_request_data = (
+                    "ISA*00* *00* *ZZ*BRT219991205 *33*87726 *170417*1344*^*00501*019160001*0*P*:~GS*HC*BRT219991205*B2BRTA*20170417*134455*19160001*X*005010X222A1~ST*837*000000001*005010X222A1~BHT*0019*00*00001*20170417*134455*CH~NM1*41*2*B00099999819*****46*BB2B~PER*IC*NO NAME*TE*1234567890~NM1*40*2*TIGER*****46*87726~HL*1**20*1~NM1*85*2*XYZ ADDRESS*****XX*1073511762~N3*123 CITY#680~N4*STATE*TG*98765~REF*EI*943319804~PER*IC*XYZ ADDRESS*TE*8008738385*TE*9142862043*FX*1234567890~NM1*87*2~N3*PO BOX 277500~N4*STATE*TS*303847000~HL*2*1*22*0~SBR*P*18*701648******CI~NM1*IL*1*FNAME*LNAME****MI*00123456789~N3*2020 CITY~N4*STATE*TG*80001~DMG*D8*19820220*M~NM1*PR*2*PROVIDER XYZ*****PI*87726~\nCLM*TOSRTA-SPL1*471***12:B:1*Y*A*Y*Y*P~REF*D9*H4HZMH0R4P0104~HI*ABK:Z12~NM1*DN*1*DN*SKO****XX*1255589300~LX*1~SV1*HC:73525*471*UN*1***1~DTP*472*RD8*0190701-20190701~REF*6R*2190476543Z1~SE*30*000000001~GE*1*19160001~IEA*1*019160001~"
+                )
+                response = submit_uhc_claim(client, x12_request_data)
+                print("\nTEST API: Claim Submission Response:\n", response)
+            except Exception as e:
+                print("\nTEST API: Error in Claim Submission Test:\n", e)
+    
     except Exception as e:
-        print("TEST API: Unexpected Error: {}".format(e))
+        print("TEST API: Unexpected Error: {}".format(e))

{medicafe-0.240716.2 → medicafe-0.240809.0}/MediLink/MediLink_ConfigLoader.py

@@ -17,7 +17,7 @@ def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..',
     Returns: A tuple containing dictionaries with configuration settings for the main config and crosswalk.
     """
     # TODO (Low Config Upgrade) The Medicare / Private differentiator flag probably needs to be pulled or passed to this.
-    # BUG Hardcode sucks.
+    # BUG Hardcode sucks. This should probably be some local env variable. 
     # Detect the operating system
     if platform.system() == 'Windows' and platform.release() == 'XP':
         # Use F: paths for Windows XP

{medicafe-0.240716.2 → medicafe-0.240809.0}/MediLink/MediLink_DataMgmt.py

@@ -219,11 +219,11 @@ def operate_winscp(operation_type, files, endpoint_config, local_storage_path, c
     except KeyError as e:
         # Log the missing key information
         missing_key = str(e)
-        message = "KeyError: Endpoint config is missing key: {}".format(missing_key)
+        message = "Critical Error: Endpoint config is missing key: {}".format(missing_key)
         MediLink_ConfigLoader.log(message)
-        # Set default values or handle the situation accordingly
-        session_name = ''
-        remote_directory = ''
+        # Raise an exception to halt execution
+        raise RuntimeError("Configuration error: The endpoint configuration is missing definitions for the required remote directories. Please check the configuration and try again.")
+
     # Command building
     command = [
         winscp_path,