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

MediLink/MediLink_DataMgmt.py

@@ -1,21 +1,25 @@
+# MediLink_DataMgmt.py
 import csv
 import os
 from datetime import datetime, timedelta
+import re
 import subprocess 
 
 # Need this for running Medibot and MediLink
 try:
     import MediLink_ConfigLoader
+    import MediLink_UI
 except ImportError:
     from . import MediLink_ConfigLoader
+    from . import MediLink_UI
 
-# Helper function to slice and strip values
-def slice_data(data, slices):
+# Helper function to slice and strip values with optional key suffix
+def slice_data(data, slices, suffix=''):
     # Convert slices list to a tuple for slicing operation
-    return {key: data[slice(*slices[key])].strip() for key in slices}
+    return {key + suffix: data[slice(*slices[key])].strip() for key in slices}
 
 # Function to parse fixed-width Medisoft output and extract claim data
-def parse_fixed_width_data(personal_info, insurance_info, service_info, config=None):
+def parse_fixed_width_data(personal_info, insurance_info, service_info, service_info_2=None, service_info_3=None, config=None):
     
     # Make sure we have the right config
     if not config:  # Checks if config is None or an empty dictionary
@@ -35,6 +39,12 @@ def parse_fixed_width_data(personal_info, insurance_info, service_info, config=N
     parsed_data.update(slice_data(insurance_info, insurance_slices))
     parsed_data.update(slice_data(service_info, service_slices))
     
+    if service_info_2:
+        parsed_data.update(slice_data(service_info_2, service_slices, suffix='_2'))
+    
+    if service_info_3:
+        parsed_data.update(slice_data(service_info_3, service_slices, suffix='_3'))
+    
     MediLink_ConfigLoader.log("Successfully parsed data from segments", config, level="INFO")
     
     return parsed_data
@@ -46,18 +56,32 @@ def read_fixed_width_data(file_path):
     MediLink_ConfigLoader.log("Starting to read fixed width data...")
     with open(file_path, 'r') as file:
         lines_buffer = []  # Buffer to hold lines for current patient data
+        
+        def yield_record(buffer):
+            personal_info = buffer[0]
+            insurance_info = buffer[1]
+            service_info = buffer[2]
+            service_info_2 = buffer[3] if len(buffer) > 3 else None
+            service_info_3 = buffer[4] if len(buffer) > 4 else None
+            MediLink_ConfigLoader.log("Successfully read data from file: {}".format(file_path), level="INFO")
+            return personal_info, insurance_info, service_info, service_info_2, service_info_3
+        
         for line in file:
             stripped_line = line.strip()
-            if stripped_line:  # Only process non-empty lines
+            if stripped_line:
                 lines_buffer.append(stripped_line)
-                # Once we have 3 lines of data, yield them as a patient record
-                if len(lines_buffer) == 3:
-                    personal_info, insurance_info, service_info = lines_buffer
-                    MediLink_ConfigLoader.log("Successfully read data from file: {}".format(file_path), level="INFO")
-                    yield personal_info, insurance_info, service_info
-                    lines_buffer.clear()  # Reset buffer for the next patient record
-            # If the line is blank but we have already started collecting a patient record,
-            # we continue without resetting the buffer, effectively skipping blank lines.
+                if 3 <= len(lines_buffer) <= 5:
+                    next_line = file.readline().strip()
+                    if not next_line:
+                        yield yield_record(lines_buffer)
+                        lines_buffer.clear()
+            else:
+                if len(lines_buffer) >= 3:
+                    yield yield_record(lines_buffer)
+                    lines_buffer.clear()
+                    
+        if lines_buffer:  # Yield any remaining buffer if file ends without a blank line
+            yield yield_record(lines_buffer)
 
 # TODO (Refactor) Consider consolidating with the other read_fixed_with_data 
 def read_general_fixed_width_data(file_path, slices):
@@ -68,21 +92,34 @@ def read_general_fixed_width_data(file_path, slices):
             insurance_name = {key: line[start:end].strip() for key, (start, end) in slices.items()}
             yield insurance_name, line_number
 
-def consolidate_csvs(source_directory):
+def consolidate_csvs(source_directory, file_prefix="Consolidated", interactive=False):
     """
-    This default overwrites any existing CSV for the same day. We want this for the automated runs but want to switch through 
-    the user interaction option if we're running interactive. This has not been implemented, but the helper function exists.
+    Consolidate CSV files in the source directory into a single CSV file.
+    
+    Parameters:
+        source_directory (str): The directory containing the CSV files to consolidate.
+        file_prefix (str): The prefix for the consolidated file's name.
+        interactive (bool): If True, prompt the user for confirmation before overwriting existing files.
+    
+    Returns:
+        str: The filepath of the consolidated CSV file, or None if no files were consolidated.
     """
     today = datetime.now()
-    consolidated_filename = today.strftime("ERA_%m%d%y.csv")
+    consolidated_filename = "{}_{}.csv".format(file_prefix, today.strftime("%m%d%y"))
     consolidated_filepath = os.path.join(source_directory, consolidated_filename)
 
     consolidated_data = []
     header_saved = False
+    expected_header = None
 
     # Check if the file already exists and log the action
     if os.path.exists(consolidated_filepath):
-        MediLink_ConfigLoader.log("The file {} already exists. It will be overwritten.".format(consolidated_filename))
+        MediLink_ConfigLoader.log("The file {} already exists. It will be overwritten.".format(consolidated_filename), level="INFO")
+        if interactive:
+            overwrite = input("The file {} already exists. Do you want to overwrite it? (y/n): ".format(consolidated_filename)).strip().lower()
+            if overwrite != 'y':
+                MediLink_ConfigLoader.log("User opted not to overwrite the file {}.".format(consolidated_filename), level="INFO")
+                return None
 
     for filename in os.listdir(source_directory):
         filepath = os.path.join(source_directory, filename)
@@ -94,26 +131,38 @@ def consolidate_csvs(source_directory):
         if modification_time < today - timedelta(days=1):
             continue  # Skip files not modified in the last day
 
-        # Read and append data from each CSV
-        with open(filepath, 'r', newline='') as csvfile:
-            reader = csv.reader(csvfile)
-            header = next(reader)  # Assumes all CSV files have the same header
-            if not header_saved:  # Save header from the first file
-                consolidated_data.append(header)
-                header_saved = True
-            consolidated_data.extend(row for row in reader)
+        try:
+            with open(filepath, 'r') as csvfile:
+                reader = csv.reader(csvfile)
+                header = next(reader)  # Read the header
+                if not header_saved:
+                    expected_header = header
+                    consolidated_data.append(header)
+                    header_saved = True
+                elif header != expected_header:
+                    MediLink_ConfigLoader.log("Header mismatch in file {}. Skipping file.".format(filepath), level="WARNING")
+                    continue
 
-        # Delete the source file after its contents have been added to the consolidation list
-        os.remove(filepath)
+                consolidated_data.extend(row for row in reader)
+        except StopIteration:
+            MediLink_ConfigLoader.log("File {} is empty or contains only header. Skipping file.".format(filepath), level="WARNING")
+            continue
+        except Exception as e:
+            MediLink_ConfigLoader.log("Error processing file {}: {}".format(filepath, e), level="ERROR")
+            continue
 
-    # Write consolidated data to a new or existing CSV file, overwriting it if it exists
-    with open(consolidated_filepath, 'w', newline='') as csvfile:
-        writer = csv.writer(csvfile)
-        writer.writerows(consolidated_data)
+        os.remove(filepath)
+        MediLink_ConfigLoader.log("Deleted source file after consolidation: {}".format(filepath), level="INFO")
 
-    MediLink_ConfigLoader.log("Consolidated CSVs into {}".format(consolidated_filepath))
-    
-    return consolidated_filepath
+    if consolidated_data:
+        with open(consolidated_filepath, 'w') as csvfile:
+            writer = csv.writer(csvfile)
+            writer.writerows(consolidated_data)
+        MediLink_ConfigLoader.log("Consolidated CSVs into {}".format(consolidated_filepath), level="INFO")
+        return consolidated_filepath
+    else:
+        MediLink_ConfigLoader.log("No valid CSV files were found for consolidation.", level="INFO")
+        return None
 
 def operate_winscp(operation_type, files, endpoint_config, local_storage_path, config):
     """
@@ -161,9 +210,20 @@ def operate_winscp(operation_type, files, endpoint_config, local_storage_path, c
     winscp_log_path = os.path.join(local_storage_path, log_filename)
 
     # Session and directory setup
-    session_name = endpoint_config.get('session_name', '')
-    remote_directory = endpoint_config['remote_directory_up'] if operation_type == "upload" else endpoint_config['remote_directory_down']
-
+    try:
+        session_name = endpoint_config.get('session_name', '')
+        if operation_type == "upload":
+            remote_directory = endpoint_config['remote_directory_up']
+        else:
+            remote_directory = endpoint_config['remote_directory_down']
+    except KeyError as e:
+        # Log the missing key information
+        missing_key = str(e)
+        message = "KeyError: Endpoint config is missing key: {}".format(missing_key)
+        MediLink_ConfigLoader.log(message)
+        # Set default values or handle the situation accordingly
+        session_name = ''
+        remote_directory = ''
     # Command building
     command = [
         winscp_path,
@@ -195,15 +255,18 @@ def operate_winscp(operation_type, files, endpoint_config, local_storage_path, c
         # TestMode is enabled, do not execute the command
         print("Test Mode is enabled! WinSCP Command not executed.")
         MediLink_ConfigLoader.log("Test Mode is enabled! WinSCP Command not executed.")
-        MediLink_ConfigLoader.log("TEST MODE: Simulating WinSCP Upload File List.")
+        MediLink_ConfigLoader.log("TEST MODE: Simulating WinSCP {} File List.".format(operation_type))
         uploaded_files = []
-        for file_path in files:
-            normalized_path = os.path.normpath(file_path)
-            if os.path.exists(normalized_path):  # Check if the file exists before appending
-                uploaded_files.append(normalized_path)
-            else:
-                MediLink_ConfigLoader.log("TEST MODE: Failed to upload file: {} does not exist.".format(normalized_path))
-        return uploaded_files
+        if files is not None:  # Check if files is not None
+            for file_path in files:
+                normalized_path = os.path.normpath(file_path)
+                if os.path.exists(normalized_path):  # Check if the file exists before appending
+                    uploaded_files.append(normalized_path)
+                else:
+                    MediLink_ConfigLoader.log("TEST MODE: Failed to {} file: {} does not exist.".format(operation_type, normalized_path))
+        else:
+            MediLink_ConfigLoader.log("TEST MODE: No files to upload.")
+        return uploaded_files if files is not None else []
     else:
         # TestMode is not enabled, execute the command
         process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False)
@@ -233,26 +296,119 @@ def operate_winscp(operation_type, files, endpoint_config, local_storage_path, c
         MediLink_ConfigLoader.log("Failed to {} files. Details: {}".format(operation_type, stderr.decode('utf-8')))
         return []  # Return empty list to indicate failure. BUG check to make sure this doesn't break something else.
 
-# UNUSED CSV Functions
-"""
-def remove_blank_rows_from_csv(csv_file_path):
-    with open(csv_file_path, 'r') as csv_file:
-        # Read the CSV file and filter out any empty rows
-        rows = [row for row in csv.reader(csv_file) if any(field.strip() for field in row)]
+def detect_new_files(directory_path, file_extension='.DAT'):
+    """
+    Scans the specified directory for new files with a given extension and adds a timestamp if needed.
+    
+    :param directory_path: Path to the directory containing files to be detected.
+    :param file_extension: Extension of the files to detect.
+    :return: A tuple containing a list of paths to new files detected in the directory and a flag indicating if a new file was just renamed.
+    """
+    MediLink_ConfigLoader.log("Scanning directory: {}".format(directory_path), level="INFO")
+    detected_file_paths = []
+    file_flagged = False
     
-    # Write the filtered rows back to the CSV file
-    with open(csv_file_path, 'w', newline='') as csv_file:
-        writer = csv.writer(csv_file)
-        writer.writerows(rows)
-
-def list_chart_numbers_in_existing_file(filepath):
-    # Lists the Chart Numbers contained in an existing CSV file.
-    chart_numbers = []
-    with open(filepath, 'r', newline='') as csvfile:
-        reader = csv.reader(csvfile)
-        next(reader)  # Skip header
-        for row in reader:
-            if len(row) > 2:  # Assuming Chart Number is in the 3rd column
-                chart_numbers.append(row[2])
-    return chart_numbers
-"""
+    try:
+        filenames = os.listdir(directory_path)
+        MediLink_ConfigLoader.log("Files in directory: {}".format(filenames), level="INFO")
+        
+        for filename in filenames:
+            MediLink_ConfigLoader.log("Checking file: {}".format(filename), level="INFO")
+            if filename.endswith(file_extension):
+                MediLink_ConfigLoader.log("File matches extension: {}".format(file_extension), level="INFO")
+                name, ext = os.path.splitext(filename)
+                MediLink_ConfigLoader.log("File name: {}, File extension: {}".format(name, ext), level="INFO")
+                
+                if not is_timestamped(name):
+                    MediLink_ConfigLoader.log("File is not timestamped: {}".format(filename), level="INFO")
+                    new_name = "{}_{}{}".format(name, datetime.now().strftime('%Y%m%d_%H%M%S'), ext)
+                    os.rename(os.path.join(directory_path, filename), os.path.join(directory_path, new_name))
+                    MediLink_ConfigLoader.log("Renamed file from {} to {}".format(filename, new_name), level="INFO")
+                    file_flagged = True
+                    filename = new_name
+                else:
+                    MediLink_ConfigLoader.log("File is already timestamped: {}".format(filename), level="INFO")
+                
+                file_path = os.path.join(directory_path, filename)
+                detected_file_paths.append(file_path)
+                MediLink_ConfigLoader.log("Detected file path: {}".format(file_path), level="INFO")
+    
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error occurred: {}".format(str(e)), level="INFO")
+    
+    MediLink_ConfigLoader.log("Detected files: {}".format(detected_file_paths), level="INFO")
+    MediLink_ConfigLoader.log("File flagged status: {}".format(file_flagged), level="INFO")
+    
+    return detected_file_paths, file_flagged
+
+def is_timestamped(name):
+    """
+    Checks if the given filename has a timestamp in the expected format.
+    
+    :param name: The name of the file without extension.
+    :return: True if the filename includes a timestamp, False otherwise.
+    """
+    # Regular expression to match timestamps in the format YYYYMMDD_HHMMSS
+    timestamp_pattern = re.compile(r'.*_\d{8}_\d{6}$')
+    return bool(timestamp_pattern.match(name))
+
+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 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 bulk_edit_insurance_types(detailed_patient_data, insurance_options):
+    # Allow user to edit insurance types in a table-like format with validation
+    print("Edit Insurance Type (Enter the 2-character code). Enter 'LIST' to display available insurance types.")
+
+    for data in detailed_patient_data:
+        current_insurance_type = data['insurance_type']
+        current_insurance_description = insurance_options.get(current_insurance_type, "Unknown")
+        print("({}) {:<25} | Current Ins. Type: {} - {}".format(
+            data['patient_id'], data['patient_name'], current_insurance_type, current_insurance_description))
+
+        while True:
+            new_insurance_type = input("Enter new insurance type (or press Enter to keep current): ").upper()
+            if new_insurance_type == 'LIST':
+                MediLink_UI.display_insurance_options(insurance_options)
+            elif not new_insurance_type or new_insurance_type in insurance_options:
+                if new_insurance_type:
+                    data['insurance_type'] = new_insurance_type
+                break
+            else:
+                print("Invalid insurance type. Please enter a valid 2-character code or type 'LIST' to see options.")
+
+def review_and_confirm_changes(detailed_patient_data, insurance_options):
+    # Review and confirm changes
+    print("\nReview changes:")
+    print("{:<20} {:<10} {:<30}".format("Patient Name", "Ins. Type", "Description"))
+    print("="*65)
+    for data in detailed_patient_data:
+        insurance_type = data['insurance_type']
+        insurance_description = insurance_options.get(insurance_type, "Unknown")
+        print("{:<20} {:<10} {:<30}".format(data['patient_name'], insurance_type, insurance_description))
+    confirm = input("\nConfirm changes? (y/n): ").strip().lower()
+    return confirm in ['y', 'yes', '']

MediLink/MediLink_Decoder.py

@@ -0,0 +1,165 @@
+# MediLink_Decoder.py
+import os
+import sys
+import csv
+from MediLink_ConfigLoader import load_configuration, log
+from MediLink_Parser import parse_era_content, parse_277_content, parse_277IBR_content, parse_277EBR_content, parse_dpt_content, parse_ebt_content, parse_ibt_content
+
+def process_file(file_path, output_directory, return_records=False):
+    if not os.path.exists(output_directory):
+        os.makedirs(output_directory)
+
+    file_type = determine_file_type(file_path)
+    content = read_file(file_path)
+    
+    if file_type == 'ERA':
+        records = parse_era_content(content)
+    elif file_type in ['277', '277IBR', '277EBR']:
+        records = parse_277_content(content) if file_type == '277' else parse_277IBR_content(content) if file_type == '277IBR' else parse_277EBR_content(content)
+    elif file_type == 'DPT':
+        records = parse_dpt_content(content)
+    elif file_type == 'EBT':
+        records = parse_ebt_content(content)
+    elif file_type == 'IBT':
+        records = parse_ibt_content(content)
+    else:
+        log("Unsupported file type: {}".format(file_type))
+        return []
+
+    formatted_records = format_records(records, file_type)
+    if not return_records:
+        display_table(formatted_records)
+        output_file_path = os.path.join(output_directory, os.path.basename(file_path) + '_decoded.csv')
+        write_records_to_csv(formatted_records, output_file_path)
+        log("Decoded data written to {}".format(output_file_path))
+    return formatted_records
+
+def determine_file_type(file_path):
+    if file_path.endswith('.era'):
+        return 'ERA'
+    elif file_path.endswith('.277'):
+        return '277'
+    elif file_path.endswith('.277ibr'):
+        return '277IBR'
+    elif file_path.endswith('.277ebr'):
+        return '277EBR'
+    elif file_path.endswith('.dpt'):
+        return 'DPT'
+    elif file_path.endswith('.ebt'):
+        return 'EBT'
+    elif file_path.endswith('.ibt'):
+        return 'IBT'
+    else:
+        log("Unsupported file type for file: {}".format(file_path))
+        return None
+
+def read_file(file_path):
+    with open(file_path, 'r') as file:
+        content = file.read()
+    return content
+
+def write_records_to_csv(records, output_file_path):
+    fieldnames = ['Claim #', 'Status', 'Patient', 'Proc.', 'Serv.', 'Allowed', 'Paid', 'Pt Resp', 'Charged']
+    with open(output_file_path, 'w', newline='') as csvfile:
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+        for record in records:
+            writer.writerow(record)
+
+def format_records(records, file_type):
+    formatted_records = []
+    for record in records:
+        if file_type == 'IBT':
+            formatted_record = {
+                'Claim #': record.get('Patient Control Number', ''),
+                'Status': record.get('Status', ''),
+                'Patient': record.get('Patient Name', ''),
+                'Proc.': format_date(record.get('To Date', '')),
+                'Serv.': format_date(record.get('From Date', '')),
+                'Allowed': '',
+                'Paid': '',
+                'Pt Resp': '',
+                'Charged': record.get('Charge', '')
+            }
+        else:
+            formatted_record = {
+                'Claim #': record.get('Chart Number', record.get('Claim Status Tracking #', record.get('Claim #', ''))),
+                'Status': record.get('claimStatus', record.get('Status', '')),
+                'Patient': record.get('memberInfo', {}).get('ptntFn', '') + ' ' + record.get('memberInfo', {}).get('ptntLn', '') if 'memberInfo' in record else record.get('Patient', ''),
+                'Proc.': format_date(record.get('processed_date', record.get('Received Date', ''))),
+                'Serv.': format_date(record.get('firstSrvcDt', record.get('Date of Service', ''))),
+                'Allowed': record.get('totalAllowdAmt', record.get('Allowed Amount', '')),
+                'Paid': record.get('totalPaidAmt', record.get('Amount Paid', '')),
+                'Pt Resp': record.get('totalPtntRespAmt', record.get('Patient Responsibility', '')),
+                'Charged': record.get('totalChargedAmt', record.get('Charge', ''))
+            }
+        formatted_records.append(formatted_record)
+    return formatted_records
+
+def format_date(date_str):
+    if date_str and len(date_str) >= 10:
+        return date_str[5:7] + '-' + date_str[8:10]  # Assuming date format is YYYY-MM-DD, this returns MM-DD
+    return ''
+
+def display_table(records):
+    # Define the new fieldnames and their respective widths
+    new_fieldnames = ['Claim #', 'Status', 'Patient', 'Proc.', 'Serv.', 'Allowed', 'Paid', 'Pt Resp', 'Charged']
+    col_widths = {field: len(field) for field in new_fieldnames}
+    
+    # Update column widths based on records
+    for record in records:
+        for field in new_fieldnames:
+            col_widths[field] = max(col_widths[field], len(str(record.get(field, ''))))
+    
+    # Create table header
+    header = " | ".join("{:<{}}".format(field, col_widths[field]) for field in new_fieldnames)
+    print(header)
+    print("-" * len(header))
+    
+    # Create table rows
+    for record in records:
+        row = " | ".join("{:<{}}".format(str(record.get(field, '')), col_widths[field]) for field in new_fieldnames)
+        print(row)
+
+def display_consolidated_records(records):
+    if not records:
+        return
+    
+    new_fieldnames = ['Claim #', 'Status', 'Patient', 'Proc.', 'Serv.', 'Allowed', 'Paid', 'Pt Resp', 'Charged']
+    col_widths = {field: len(field) for field in new_fieldnames}
+
+    for record in records:
+        for field in new_fieldnames:
+            col_widths[field] = max(col_widths[field], len(str(record.get(field, ''))))
+
+    header = " | ".join("{:<{}}".format(field, col_widths[field]) for field in new_fieldnames)
+    print(header)
+    print("-" * len(header))
+
+    for record in records:
+        row = " | ".join("{:<{}}".format(str(record.get(field, '')), col_widths[field]) for field in new_fieldnames)
+        print(row)
+
+if __name__ == "__main__":
+    config, _ = load_configuration()
+    
+    files = sys.argv[1:]
+    if not files:
+        log("No files provided as arguments.", 'error')
+        sys.exit(1)
+
+    output_directory = config['MediLink_Config'].get('local_storage_path')
+    all_records = []
+    for file_path in files:
+        try:
+            records = process_file(file_path, output_directory, return_records=True)
+            all_records.extend(records)
+        except Exception as e:
+            log("Failed to process {}: {}".format(file_path, e), 'error')
+    
+    display_consolidated_records(all_records)
+
+    if input("Do you want to export the consolidated records to a CSV file? (y/n): ").strip().lower() == 'y':
+        consolidated_csv_path = os.path.join(output_directory, "Consolidated_Records.csv")
+        write_records_to_csv(all_records, consolidated_csv_path)
+        log("Consolidated records written to {}".format(consolidated_csv_path))