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

MediLink/MediLink.py

@@ -1,38 +1,51 @@
 import os
-import MediLink_ConfigLoader
-import MediLink_837p_encoder
-import logging
 import MediLink_Down
 import MediLink_Up
+import MediLink_ConfigLoader
+import MediLink_837p_encoder
+import MediLink_DataMgmt
 
 # For UI Functions
 import os
 import MediLink_UI  # Import UI module for handling all user interfaces
-
-"""
-Development Tasks for Backend Enhancement in MediSoft Claims Submittal (MediLink) Script:
-
-Implement dynamic configurations for multiple endpoints (Availity, Optum, PNT Data) with environmental settings support.
-Enhance file detection with detailed logging and introduce integrity checks for pre-processing validation.
-Verify file transmissions via WinSCP log analysis for successful endpoint acknowledgments and secure data transfer.
-Automate response file handling from endpoints and integrate feedback into MediSoft with exception alerts.
-De-persisting Intermediate Files.
-When transmissions fail, there is some retaining of patient data in memory or something that seems to default
-any new endpoint changes to Optum. May need to "de-confirm" patients, but leave the suggested endpoints as the previously
-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 
-that sits in the SendFiles folder after a submittal. 
-
-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')
+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
+
+# Define insurance options with codes and descriptions. 
+# TODO This needs to move to the config file
+insurance_options = {
+    "11": "Other Non-Federal Programs",
+    "12": "Preferred Provider Organization (PPO)",
+    "13": "Point of Service (POS)",
+    "14": "Exclusive Provider Organization (EPO)",
+    "15": "Indemnity Insurance",
+    "16": "Health Maintenance Organization (HMO) Medicare Risk",
+    "17": "Dental Maintenance Organization",
+    "AM": "Automobile Medical",
+    "BL": "Blue Cross/Blue Shield",
+    "CH": "Champus",
+    "CI": "Commercial Insurance Co.",
+    "DS": "Disability",
+    "FI": "Federal Employees Program",
+    "HM": "Health Maintenance Organization",
+    "LM": "Liability Medical",
+    "MA": "Medicare Part A",
+    "MB": "Medicare Part B",
+    "MC": "Medicaid",
+    "OF": "Other Federal Program",
+    "TV": "Title V",
+    "VA": "Veterans Affairs Plan",
+    "WC": "Workers Compensation Health Claim",
+    "ZZ": "Mutually Defined"
+}
 
 def detect_and_display_file_summaries(directory_path, config, crosswalk):
     """
@@ -41,35 +54,61 @@ def detect_and_display_file_summaries(directory_path, config, crosswalk):
     
     :param directory_path: Path to the directory containing files to be detected.
     :param config: Configuration settings loaded from a JSON file.
+    :param crosswalk: Crosswalk data for mapping purposes.
     :return: A tuple containing a list of new file paths and the detailed patient data.
     """
-    new_files = detect_new_files(directory_path)
-    if not new_files:
-        print("    No new claims detected. Check Medisoft claims output.\n")
+    try:
+        new_files, file_flagged = MediLink_DataMgmt.detect_new_files(directory_path)
+        if not new_files:
+            print("No new claims detected. Check Medisoft claims output.")
+            MediLink_ConfigLoader.log("No new claims detected. Check Medisoft claims output.")
+            return False, []
+        
+        if not file_flagged:
+            selected_files = MediLink_UI.user_select_files(new_files)
+        else:
+            # Extract the newest single latest file from the list
+            selected_files = [max(new_files, key=os.path.getctime)]
+        
+        detailed_patient_data = []  # Initialize list for detailed patient data
+        for file_path in selected_files:
+            detailed_data = extract_and_suggest_endpoint(file_path, config, crosswalk)
+            detailed_patient_data.extend(detailed_data)  # Accumulate detailed data for processing
+            
+        # Enrich the detailed patient data with insurance type
+        detailed_patient_data = enrich_with_insurance_type(detailed_patient_data, insurance_options)
+        
+        # Display summaries and provide an option for bulk edit
+        MediLink_UI.display_patient_summaries(detailed_patient_data)
+
+        # Return the list of new files and the enriched detailed patient data
+        return selected_files, detailed_patient_data
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error in detect_and_display_file_summaries: {}".format(e))
         return False, []
 
-    detailed_patient_data = []  # Initialize list for detailed patient data
-    for file_path in new_files:
-        detailed_data = extract_and_suggest_endpoint(file_path, config, crosswalk)
-        detailed_patient_data.extend(detailed_data)  # Accumulate detailed data for processing
+def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_mapping=None):
+    """
+    Enriches the detailed patient data with insurance type based on patient ID.
 
-    # Return just the list of new files and the enriched detailed patient data
-    return new_files, detailed_patient_data
+    Parameters:
+    - detailed_patient_data: List of dictionaries containing detailed patient data.
+    - patient_insurance_mapping: Dictionary mapping patient IDs to their insurance types.
 
-def detect_new_files(directory_path, file_extension='.DAT'):
-    """
-    Scans the specified directory for new files with a given extension.
+    Returns:
+    - Enriched detailed patient data with insurance type added.
     
-    :param directory_path: Path to the directory containing files to be detected.
-    :param file_extension: Extension of the files to detect. Defaults to '.csv'.
-    :return: A list of paths to new files detected in the directory.
+    TODO: Implement a function to provide `patient_insurance_mapping` from a reliable source.
     """
-    detected_file_paths = []
-    for filename in os.listdir(directory_path):
-        if filename.endswith(file_extension):
-            file_path = os.path.join(directory_path, filename)
-            detected_file_paths.append(file_path)
-    return detected_file_paths
+    if patient_insurance_type_mapping is None:
+        MediLink_ConfigLoader.log("No Patient:Insurance-Type mapping available.")
+        patient_insurance_type_mapping = {}
+    
+    for data in detailed_patient_data:
+        patient_id = data.get('PATID') # I think this is the right name?
+        insurance_type = patient_insurance_type_mapping.get(patient_id, '12')  # Default to '12' (PPO)
+        data['insurance_type'] = insurance_type
+    return detailed_patient_data
 
 def extract_and_suggest_endpoint(file_path, config, crosswalk):
     """
@@ -88,15 +127,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, 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))
         
         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,
@@ -112,42 +178,53 @@ def extract_and_suggest_endpoint(file_path, config, crosswalk):
     # Return only the enriched detailed patient data, eliminating the need for a separate summary list
     return detailed_patient_data
 
-def organize_patient_data_by_endpoint(detailed_patient_data):
-    """
-    Organizes detailed patient data by their confirmed endpoints.
-    This simplifies processing and conversion per endpoint basis, ensuring that claims are generated and submitted
-    according to the endpoint-specific requirements.
-
-    :param detailed_patient_data: A list of dictionaries, each containing detailed patient data including confirmed endpoint.
-    :return: A dictionary with endpoints as keys and lists of detailed patient data as values for processing.
-    """
-    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']
-        # Initialize a list for the endpoint if it doesn't exist
-        if endpoint not in organized:
-            organized[endpoint] = []
-        organized[endpoint].append(data)
-    return organized
-
 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)
@@ -157,32 +234,27 @@ def user_decision_on_suggestions(detailed_patient_data, config):
 
     # If the user agrees to proceed with all suggested endpoints, confirm them.
     if proceed:
-        return confirm_all_suggested_endpoints(detailed_patient_data)
+        return MediLink_DataMgmt.confirm_all_suggested_endpoints(detailed_patient_data)
     # Otherwise, allow the user to adjust the endpoints manually.
     else:
         return select_and_adjust_files(detailed_patient_data, config)
-    
-def confirm_all_suggested_endpoints(detailed_patient_data):
-    """
-    Confirms all suggested endpoints for each patient's detailed data.
-    """
-    for data in detailed_patient_data:
-        if 'confirmed_endpoint' not in data:
-            data['confirmed_endpoint'] = data['suggested_endpoint']
-    return 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 +262,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 +284,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()
@@ -222,6 +301,9 @@ def main_menu():
 
     # Detect new files and collect detailed patient data if available.
     new_files, detailed_patient_data = detect_and_display_file_summaries(directory_path, config, crosswalk)
+    
+    if new_files:
+        handle_submission(detailed_patient_data, config)
 
     while True:
         # Define the menu options. Base options include checking remittances and exiting the program.
@@ -240,7 +322,7 @@ def main_menu():
             check_for_new_remittances(config)
         elif choice == '2' and new_files:
             # Handle the claims submission flow if new files are present.
-            handle_submission(detailed_patient_data, config)
+            handle_submission(detailed_patient_data, config) # Since we have the bulk edit, we should actually go there first 
         elif choice == '3' or (choice == '2' and not new_files):
             # Exit the program if the user chooses to exit or if no new files are present.
             MediLink_UI.display_exit_message()
@@ -254,18 +336,35 @@ def handle_submission(detailed_patient_data, config):
     Handles the submission process for claims based on detailed patient data.
     This function orchestrates the flow from user decision on endpoint suggestions to the actual submission of claims.
     """
+    # TODO If we get here via a user decline we end up not displaying the patient summary data, but this doesn't happen in the first round. Can be de-tangled later.
+    
+    # Ask the user if they want to edit insurance types
+    edit_insurance = input("Do you want to edit insurance types? (y/n): ").strip().lower()
+    if edit_insurance in ['y', 'yes', '']:
+        while True:
+            # Bulk edit insurance types
+            MediLink_DataMgmt.bulk_edit_insurance_types(detailed_patient_data, insurance_options)
+    
+            # Review and confirm changes
+            if MediLink_DataMgmt.review_and_confirm_changes(detailed_patient_data, insurance_options):
+                break  # Exit the loop if changes are confirmed
+            else:
+                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)
+    
     # Confirm all remaining suggested endpoints.
-    confirmed_data = confirm_all_suggested_endpoints(adjusted_data)
+    confirmed_data = MediLink_DataMgmt.confirm_all_suggested_endpoints(adjusted_data)
     if confirmed_data:  # Proceed if there are confirmed data entries.
         # Organize data by confirmed endpoints for submission.
-        organized_data = organize_patient_data_by_endpoint(confirmed_data)
+        organized_data = MediLink_DataMgmt.organize_patient_data_by_endpoint(confirmed_data)
         # Confirm transmission with the user and check for internet connectivity.
         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.")