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

MediBot/MediBot_docx_decoder.py

@@ -1,80 +1,303 @@
-"""
-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
+import re
+from lxml import etree
+import zipfile
+from datetime import datetime
+import os
+import sys
+from collections import OrderedDict
+
+# Add parent directory of the project to the Python path
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(project_dir)
+
+try:
+    import MediLink_ConfigLoader
+except ImportError:
+    from MediLink import MediLink_ConfigLoader
 
 def parse_docx(filepath):
-    # Open the .docx file
-    doc = Document(filepath)
+    try:
+        doc = Document(filepath)  # Open the .docx file
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error opening document: {}".format(e))  # Log error
+        return {}
+
+    patient_data = OrderedDict()  # Initialize OrderedDict to store data
+    MediLink_ConfigLoader.log("Extracting Date of Service from {}".format(filepath), level="DEBUG")
+    
+    date_of_service = extract_date_of_service(filepath)  # Extract date of service
+    MediLink_ConfigLoader.log("Date of Service recorded as: {}".format(date_of_service), level="DEBUG")
+
+    for table in doc.tables:  # Iterate over tables in the document
+        for row in table.rows:
+            cells = [cell.text.strip() for cell in row.cells]
+            if len(cells) > 4 and cells[3].startswith('#'):
+                try:
+                    patient_id = parse_patient_id(cells[3])
+                    diagnosis_code = parse_diagnosis_code(cells[4])
+                    left_or_right_eye = parse_left_or_right_eye(cells[4])
+                    femto_yes_or_no = parse_femto_yes_or_no(cells[4])
+
+                    if patient_id not in patient_data:
+                        patient_data[patient_id] = {}
+
+                    if date_of_service in patient_data[patient_id]:
+                        MediLink_ConfigLoader.log("Duplicate entry for patient ID {} on date {}. Skipping.".format(patient_id, date_of_service))
+                    else:
+                        patient_data[patient_id][date_of_service] = [diagnosis_code, left_or_right_eye, femto_yes_or_no]
+                except Exception as e:
+                    MediLink_ConfigLoader.log("Error processing row: {}. Error: {}".format(cells, e))
+    
+    # Validation steps
+    validate_unknown_entries(patient_data)
+    validate_diagnostic_code(patient_data)
     
-    # Initialize the dictionary to store data
-    patient_data = {}
+    return patient_data
+
+def validate_unknown_entries(patient_data):
+    for patient_id, dates in list(patient_data.items()):
+        for date, details in list(dates.items()):
+            if 'Unknown' in details:
+                warning_message = "Warning: 'Unknown' entry found. Patient ID: {}, Date: {}, Details: {}".format(patient_id, date, details)
+                MediLink_ConfigLoader.log(warning_message, level="WARNING")
+                print(warning_message)
+                del patient_data[patient_id][date]
+        if not patient_data[patient_id]:  # If no dates left for the patient, remove the patient
+            del patient_data[patient_id]
+
+def validate_diagnostic_code(patient_data):
+    for patient_id, dates in patient_data.items():
+        for date, details in dates.items():
+            diagnostic_code, eye, _ = details
+            if diagnostic_code[-1].isdigit():
+                if eye == 'Left' and not diagnostic_code.endswith('2'):
+                    log_and_warn(patient_id, date, diagnostic_code, eye)
+                elif eye == 'Right' and not diagnostic_code.endswith('1'):
+                    log_and_warn(patient_id, date, diagnostic_code, eye)
+
+def log_and_warn(patient_id, date, diagnostic_code, eye):
+    warning_message = (
+        "Warning: Mismatch found for Patient ID: {}, Date: {}, "
+        "Diagnostic Code: {}, Eye: {}".format(patient_id, date, diagnostic_code, eye)
+    )
+    MediLink_ConfigLoader.log(warning_message, level="WARNING")
+    print(warning_message)
+
+# Extract and parse the date of service from the .docx file
+def extract_date_of_service(docx_path):
+    extract_to = "extracted_docx"
+    try:
+        if not os.path.exists(extract_to):
+            os.makedirs(extract_to)
+        with zipfile.ZipFile(docx_path, 'r') as docx:
+            docx.extractall(extract_to)
+            MediLink_ConfigLoader.log("Extracted DOCX to: {}".format(extract_to), level="DEBUG")
+
+        file_path = find_text_in_xml(extract_to, "Surgery Schedule")
+        if file_path:
+            return extract_date_from_file(file_path)
+        else:
+            MediLink_ConfigLoader.log("Target text 'Surgery Schedule' not found in any XML files.", level="WARNING")
+            return None
+    finally:
+        # Clean up the extracted files
+        remove_directory(extract_to)
+        MediLink_ConfigLoader.log("Cleaned up extracted files in: {}".format(extract_to), level="DEBUG")
+
+def remove_directory(path):
+    if os.path.exists(path):
+        for root, dirs, files in os.walk(path, topdown=False):
+            for name in files:
+                os.remove(os.path.join(root, name))
+            for name in dirs:
+                os.rmdir(os.path.join(root, name))
+        os.rmdir(path)
+
+# Find the target text in the extracted XML files
+def find_text_in_xml(directory, target_text):
+    for root_dir, dirs, files in os.walk(directory):
+        for file in files:
+            if file.endswith('.xml'):
+                file_path = os.path.join(root_dir, file)
+                try:
+                    tree = etree.parse(file_path)
+                    root = tree.getroot()
+                    namespaces = {'w': 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'} # hardcoded for XP handling BUG
+                    for elem in root.xpath('//w:t', namespaces=namespaces):
+                        if elem.text and target_text in elem.text:
+                            MediLink_ConfigLoader.log("Found target text in file: {}".format(file_path), level="DEBUG")
+                            return file_path
+                except Exception as e:
+                    MediLink_ConfigLoader.log("Error parsing XML file {}: {}".format(file_path, e))
+                    print("Error parsing XML file {}: {}".format(file_path, e))
+    return None
+
+# Normalize month and day abbreviations
+def normalize_text(text):
+    month_map = {
+        'JAN': 'JANUARY', 'FEB': 'FEBRUARY', 'MAR': 'MARCH', 'APR': 'APRIL', 
+        'MAY': 'MAY', 'JUN': 'JUNE', 'JUL': 'JULY', 'AUG': 'AUGUST', 
+        'SEP': 'SEPTEMBER', 'OCT': 'OCTOBER', 'NOV': 'NOVEMBER', 'DEC': 'DECEMBER'
+    }
+    day_map = {
+        'MON': 'MONDAY', 'TUE': 'TUESDAY', 'WED': 'WEDNESDAY', 'THU': 'THURSDAY', 
+        'FRI': 'FRIDAY', 'SAT': 'SATURDAY', 'SUN': 'SUNDAY'
+    }
     
-    # Assuming the first table contains the required data
-    table = doc.tables[0]
+    for abbr, full in month_map.items():
+        text = re.sub(r'\b' + abbr + r'\b', full, text, flags=re.IGNORECASE)
+    for abbr, full in day_map.items():
+        text = re.sub(r'\b' + abbr + r'\b', full, text, flags=re.IGNORECASE)
     
-    # Iterate over the rows in the table
-    for row in table.rows[1:]:  # Skip header row if it exists
-        cells = row.cells
+    return text
+
+def reassemble_year(text):
+    # First, handle the most common case where a 4-digit year is split as (3,1), (1,3), or (2,2)
+    text = re.sub(r'(\d{3}) (\d{1})', r'\1\2', text)
+    text = re.sub(r'(\d{1}) (\d{3})', r'\1\2', text)
+    text = re.sub(r'(\d{2}) (\d{2})', r'\1\2', text)
+    
+    # Handle the less common cases where the year might be split as (1,1,2) or (2,1,1) or (1,2,1)
+    parts = re.findall(r'\b(\d{1,2})\b', text)
+    if len(parts) >= 4:
+        for i in range(len(parts) - 3):
+            candidate = ''.join(parts[i:i + 4])
+            if len(candidate) == 4 and candidate.isdigit():
+                combined_year = candidate
+                text = re.sub(r'\b' + r'\b \b'.join(parts[i:i + 4]) + r'\b', combined_year, text)
+                break
+    
+    return text
+
+# Extract and parse the date from the file
+def extract_date_from_file(file_path):
+    try:
+        tree = etree.parse(file_path)
+        root = tree.getroot()
+        collected_text = []
+        
+        namespaces = {'w': 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'} # hardcoded for XP handling BUG
+        for elem in root.xpath('//w:t', namespaces=namespaces):
+            if elem.text:
+                collected_text.append(elem.text.strip())
         
-        # 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())
+        for elem in root.iter():
+            if elem.tag.endswith('t') and elem.text:
+                collected_text.append(elem.text.strip())
+
+        combined_text = ' '.join(collected_text)
+        combined_text = reassemble_year(combined_text) # Fix OCR splitting years
+        # combined_text = re.sub(r'(\d{3}) (\d{1})', r'\1\2', combined_text) # initial year regex.
+        combined_text = normalize_text(combined_text)  # Normalize abbreviations
+        combined_text = re.sub(r',', '', combined_text)  # Remove commas if they exist
+
+        # Log the combined text
+        MediLink_ConfigLoader.log("Combined text: {}".format(combined_text), level="DEBUG")
+        # print("DEBUG: Combined text: {}".format(combined_text))
+        
+        day_week_pattern = r"(MONDAY|TUESDAY|WEDNESDAY|THURSDAY|FRIDAY|SATURDAY|SUNDAY)"
+        month_day_pattern = r"(JANUARY|FEBRUARY|MARCH|APRIL|MAY|JUNE|JULY|AUGUST|SEPTEMBER|OCTOBER|NOVEMBER|DECEMBER) \d{1,2}"
+        year_pattern = r"\d{4}"
+
+        day_of_week = re.search(day_week_pattern, combined_text, re.IGNORECASE)
+        month_day = re.search(month_day_pattern, combined_text, re.IGNORECASE)
+        year_match = re.search(year_pattern, combined_text, re.IGNORECASE)
         
-        # Construct the dictionary entry
-        patient_data[patient_id] = [diagnosis_code, left_or_right_eye, femto_yes_or_no]
+        # Log the results of the regex searches
+        MediLink_ConfigLoader.log("Day of week found: {}".format(day_of_week.group() if day_of_week else 'None'), level="DEBUG")
+        MediLink_ConfigLoader.log("Month and day found: {}".format(month_day.group() if month_day else 'None'), level="DEBUG")
+        MediLink_ConfigLoader.log("Year found: {}".format(year_match.group() if year_match else 'None'), level="DEBUG")
+
+        if day_of_week and month_day and year_match:
+            date_str = "{} {} {}".format(day_of_week.group(), month_day.group(), year_match.group())
+            try:
+                date_obj = datetime.strptime(date_str, '%A %B %d %Y')
+                return date_obj.strftime('%m-%d-%Y')
+            except ValueError as e:
+                MediLink_ConfigLoader.log("Error converting date: {}. Error: {}".format(date_str, e), level="ERROR")
+        else:
+            MediLink_ConfigLoader.log("Date components not found or incomplete in the text. Combined text: {}, Day of week: {}, Month and day: {}, Year: {}"
+                .format(combined_text, 
+                        day_of_week.group() if day_of_week else 'None', 
+                        month_day.group() if month_day else 'None', 
+                        year_match.group() if year_match else 'None'),
+                level="WARNING")
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error extracting date from file: {}. Error: {}".format(file_path, e))
+        print("Error extracting date from file: {}. Error: {}".format(file_path, e))
     
-    return patient_data
+    return None
 
 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]
+    try:
+        return text.split()[0].lstrip('#')  # Extract patient ID number (removing the '#')
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error parsing patient ID: {}. Error: {}".format(text, e))
+        return None
 
 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
+    try:
+        # Regular expression to find all ICD-10 codes starting with 'H' and containing a period
+        pattern = re.compile(r'H\d{2}\.\d+')
+        matches = pattern.findall(text)
+        
+        if matches:
+            return matches[0]  # Return the first match
+        else:
+            # Fallback to original method if no match is found
+            if '(' in text and ')' in text:  # Extract the diagnosis code before the '/'
+                full_code = text[text.index('(')+1:text.index(')')]
+                return full_code.split('/')[0]
+            return text.split('/')[0]
+    
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error parsing diagnosis code: {}. Error: {}".format(text, e))
+        return "Unknown"
 
 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:
+    try:
+        if 'LEFT EYE' in text.upper():
+            return 'Left'
+        elif 'RIGHT EYE' in text.upper():
+            return 'Right'
+        else:
+            return 'Unknown'
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error parsing left or right eye: {}. Error: {}".format(text, e))
         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'
+    try:
+        if 'FEMTO' in text.upper():
+            return True
+        else:
+            return False
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error parsing femto yes or no: {}. Error: {}".format(text, e))
+        return False
+
+def rotate_docx_files(directory):
+    # List all files in the directory
+    files = os.listdir(directory)
+
+    # Filter files that contain "DR" and "SS" in the filename
+    filtered_files = [file for file in files if "DR" in file and "SS" in file]
+
+    # Iterate through filtered files
+    for filename in filtered_files:
+        filepath = os.path.join(directory, filename)
+        # Parse each document and print the resulting dictionary
+        patient_data_dict = parse_docx(filepath)
+        print("Data from file '{}':".format(filename))
+        import pprint
+        pprint.pprint(patient_data_dict)
+        print()
 
-# Placeholder function call (replace 'path_to_docx' with the actual file path)
-filepath = 'path_to_docx'
-patient_data_dict = parse_docx(filepath)
+def main():
+    # Call the function with the directory containing your .docx files
+    directory = "C:\\Users\\danie\\Downloads\\"
+    rotate_docx_files(directory)
 
-# Print the resulting dictionary
-print(patient_data_dict)
+if __name__ == "__main__":
+    main()

MediLink/MediLink.py

@@ -2,7 +2,7 @@ import os
 import MediLink_Down
 import MediLink_Up
 import MediLink_ConfigLoader
-import MediLink_837p_encoder
+import MediLink_DataMgmt
 
 # For UI Functions
 import os
@@ -18,93 +18,54 @@ 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:
-
-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 (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.
-
-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):
+# Retrieve insurance options with codes and descriptions
+config, _ = MediLink_ConfigLoader.load_configuration()
+insurance_options = config['MediLink_Config'].get('insurance_options')
+    
+def collect_detailed_patient_data(selected_files, config, crosswalk):
     """
-    Detects new files in the specified directory and prepares detailed patient data for processing,
-    including suggestions for endpoints based on insurance provider information found in the config.
+    Collects detailed patient data from the selected files.
     
-    :param directory_path: Path to the directory containing files to be detected.
+    :param selected_files: List of selected file paths.
     :param config: Configuration settings loaded from a JSON file.
-    :return: A tuple containing a list of new file paths and the detailed patient data.
+    :param crosswalk: Crosswalk data for mapping purposes.
+    :return: A list of detailed patient data.
     """
-    new_files = detect_new_files(directory_path)
-    if not new_files:
-        print("    No new claims detected. Check Medisoft claims output.\n")
-        return False, []
-
-    detailed_patient_data = []  # Initialize list for detailed patient data
-    for file_path in new_files:
+    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 just the list of new files and the enriched detailed patient data
-    return new_files, detailed_patient_data
+    return detailed_patient_data
 
-def detect_new_files(directory_path, file_extension='.DAT'):
+def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_mapping=None):
     """
-    Scans the specified directory for new files with a given extension.
+    Enriches the detailed patient data with insurance type based on patient ID.
+
+    Parameters:
+    - detailed_patient_data: List of dictionaries containing detailed patient data.
+    - patient_insurance_mapping: Dictionary mapping patient IDs to their insurance types.
+
+    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):
     """
@@ -127,8 +88,8 @@ def extract_and_suggest_endpoint(file_path, config, crosswalk):
     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))
+    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')
         
@@ -174,25 +135,6 @@ 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']
@@ -239,7 +181,7 @@ def user_decision_on_suggestions(detailed_patient_data, config):
     
     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.
+    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)
@@ -249,20 +191,11 @@ 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.
@@ -323,14 +256,14 @@ def main_menu():
     # Normalize the directory path for file operations.
     directory_path = os.path.normpath(config['MediLink_Config']['inputFilePath'])
 
-    # Detect new files and collect detailed patient data if available.
-    new_files, detailed_patient_data = detect_and_display_file_summaries(directory_path, config, crosswalk)
+    # Detect files and determine if a new file is flagged.
+    all_files, file_flagged = MediLink_DataMgmt.detect_new_files(directory_path)
 
     while True:
         # Define the menu options. Base options include checking remittances and exiting the program.
         options = ["Check for new remittances", "Exit"]
-        # If new files are detected, add the option to submit claims.
-        if new_files:
+        # If any files are detected, add the option to submit claims.
+        if all_files:
             options.insert(1, "Submit claims")
 
         # Display the dynamically adjusted menu options.
@@ -341,11 +274,22 @@ def main_menu():
         if choice == '1':
             # Handle remittance checking.
             check_for_new_remittances(config)
-        elif choice == '2' and new_files:
-            # Handle the claims submission flow if new files are present.
+        elif choice == '2' and all_files:
+            # Handle the claims submission flow if any files are present.
+            if file_flagged:
+                # Extract the newest single latest file from the list if a new file is flagged.
+                selected_files = [max(all_files, key=os.path.getctime)]
+            else:
+                # Prompt the user to select files if no new file is flagged.
+                selected_files = MediLink_UI.user_select_files(all_files)
+
+            # Collect detailed patient data for selected files.
+            detailed_patient_data = collect_detailed_patient_data(selected_files, config, crosswalk)
+            
+            # Process the claims submission.
             handle_submission(detailed_patient_data, config)
-        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.
+        elif choice == '3' or (choice == '2' and not all_files):
+            # Exit the program if the user chooses to exit or if no files are present.
             MediLink_UI.display_exit_message()
             break
         else:
@@ -357,13 +301,29 @@ 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():