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

MediLink/MediLink_837p_encoder.py

@@ -7,31 +7,6 @@ from MediLink_DataMgmt import parse_fixed_width_data, read_fixed_width_data
 import MediLink_837p_encoder_library
 #from tqdm import tqdm
 
-"""
-Single File Processing Flow:
-
-This flow is triggered when the -d (directory) flag is not set. It handles the conversion of a single file specified by the -p flag.
-It directly processes the single file specified, without the need to iterate over a directory.
-The conversion initializes and processes this single file, appending the necessary EDI segments, and directly writes the output once processing is complete.
-
-Batch Directory Processing Flow:
-
-Activated when the -d flag is set, indicating that the -p flag points to a directory rather than a single file.
-Iterates over all files in the specified directory, processing only those that end with the ".DAT" extension.
-Each file is processed in sequence, with each undergoing a full cycle of reading, processing, and output file generation as in the single file flow.
-
-Development Task List:
-
-- [ ] 1. File Path Management: Enhance the handling of input paths to efficiently manage both individual files and directories, accommodating a range of file processing scenarios.
-- [ ] 2. User Interface Improvement: Advance the CLI for intuitive user interaction, offering clear options for file processing and real-time progress updates.
-- [ ] 3. Validation and Logging: Strengthen validation processes for input data, incorporating thorough checks against business rules and enhanced detailed logging for improved traceability and troubleshooting.
-- [ ] 4. Batch Processing and Output Handling: Enhance output file management to support efficient batch operations, including systematic naming and organization for output files.
-- [ ] 5. Comprehensive Documentation: Maintain up-to-date and detailed documentation within the codebase, ensuring all functions and complex logic are clearly explained.
-- [ ] 6. De-persisting Intermediate Files.
-- [ ] 7. Determination of Relationship to Patient for insurance holder. Can Compare Insured Name & closeness of DOB (usually spouse [2], child [3]). 
-- [ ] 8. Consolidation of certain functions needs to happen here.
-"""
-
 def format_single_claim(patient_data, config, endpoint, transaction_set_control_number):
     """
     Formats a single claim into 837P segments based on the provided patient data and endpoint.
@@ -196,9 +171,9 @@ def read_and_validate_claims(file_path, config):
     validation_errors = []  # List to store validation errors
 
     # Iterate over data in the file
-    for personal_info, insurance_info, service_info in read_fixed_width_data(file_path):
+    for personal_info, insurance_info, service_info, service_info_2, service_info_3 in read_fixed_width_data(file_path):
         # Parse data into a usable format
-        parsed_data = parse_fixed_width_data(personal_info, insurance_info, service_info, config.get('MediLink_Config', config))
+        parsed_data = parse_fixed_width_data(personal_info, insurance_info, service_info, service_info_2, service_info_3, config.get('MediLink_Config', config))
         # Validate the parsed data
         is_valid, errors = validate_claim_data(parsed_data, config)
         if is_valid:
@@ -263,7 +238,7 @@ def validate_claim_data(parsed_data, config, required_fields=[]):
         ]
     """    
     errors = []
-    MediLink_ConfigLoader.log("Starting claim vata validation...")
+    MediLink_ConfigLoader.log("Starting claim data validation...")
     if not required_fields:
         # If no required fields are specified, assume validation is true
         return True, []

MediLink/MediLink_837p_encoder_library.py

@@ -1,10 +1,11 @@
 from datetime import datetime
 import sys
-from MediLink import MediLink_ConfigLoader
+from MediLink import MediLink_ConfigLoader, MediLink_UI
 
 # Add parent directory of the project to the Python path
 import sys
 import os
+
 project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 sys.path.append(project_dir)
 
@@ -13,19 +14,6 @@ load_insurance_data_from_mains = MediBot_Preprocessor_lib.load_insurance_data_fr
 from MediBot import MediBot_Crosswalk_Library
 from MediLink_API_v2 import fetch_payer_name_from_api
 
-"""
-- [ ] 1. Code Refactoring: Increase modularity and clarity, particularly in segment creation functions (e.g., `create_st_segment`, `create_nm1_billing_provider_segment`), for better maintenance and readability.
-- [ ] 2. Endpoint Support: Extend support within segment creation for additional endpoints with attention to their unique claim submission requirements.
-- [ ] 3. Payer Identification Mechanism: Refine the mechanism for dynamically identifying payers, leveraging payer mappings and integrating with external APIs like Availity for precise payer information retrieval.
-- [ ] 4. Adherence to Endpoint-Specific Standards: Implement and verify the compliance of claim data formatting and inclusion based on the specific demands of each target endpoint within the segment creation logic.
-- [ ] 5. De-persisting Intermediate Files.
-- [ ] 6. Get an API for Optum "Entered As". 
-- [ ] 7. (MED) Add Authorization Number 
-- [X] 8. (HIGH) Interchange number should be 000HHMMSS instead of fixed constant.
-- [ ] 9. Upgrade Interchange formation to consolidate the batch processor and also de-risk batch 
-         interchange number matching for multiple .DAT.
-"""
-
 # Converts date format from one format to another.
 def convert_date_format(date_str):
     # Parse the input date string into a datetime object using the input format    
@@ -520,7 +508,17 @@ def insurance_type_selection(parsed_data):
     - str: The insurance type code selected by the user.
     
     """
-    print("\nHorrible Temporary Menu: Select the insurance type for patient {}: ".format(parsed_data['LAST']))
+    MediLink_ConfigLoader.log("insurance_type_selection(parsed_data): {}".format(parsed_data), level="DEBUG")
+    
+    # Check if insurance type is already assigned and is valid
+    insurance_type_code = parsed_data.get('insurance_type')
+    if insurance_type_code and len(insurance_type_code) == 2 and insurance_type_code.isalnum():
+        MediLink_ConfigLoader.log("Insurance type already assigned: {}".format(insurance_type_code), level="DEBUG")
+        return insurance_type_code
+    elif insurance_type_code:
+        MediLink_ConfigLoader.log("Invalid insurance type: {}".format(insurance_type_code), level="WARNING")
+    
+    print("\nInsurance Type Validation Error: Select the insurance type for patient {}: ".format(parsed_data['LAST']))
 
     # Define insurance options with codes and descriptions
     insurance_options = {
@@ -549,22 +547,13 @@ def insurance_type_selection(parsed_data):
         "ZZ": "Mutually Defined"
     }
 
-    # Function to display full list of insurance options
-    def display_insurance_options(options):
-        print("Insurance Type Options:")
-        # Sorting the dictionary keys to ensure consistent order
-        sorted_keys = sorted(options.keys())
-        for code in sorted_keys:
-            description = options[code]
-            print("{} - {}".format(code, description))
-
     def prompt_display_insurance_options():
         # Prompt to display full list
         display_full_list = input("Do you want to see the full list of insurance options? (yes/no): ").strip().lower()
 
         # Display full list if user confirms
         if display_full_list in ['yes', 'y']:
-            display_insurance_options(insurance_options)
+            MediLink_UI.display_insurance_options(insurance_options)
 
     # Horrible menu
     prompt_display_insurance_options()

MediLink/MediLink_APIs.py

@@ -1,3 +1,5 @@
+# Unused archive backup. This has been superceded by API_v2
+
 import time
 import requests
 try:

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,63 @@
+# 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
+
+def process_file(file_path, output_directory):
+    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)
+        fieldnames = ['Date of Service', 'Check EFT', 'Chart Number', 'Payer Address', 'Amount Paid', 
+                      'Adjustment Amount', 'Allowed Amount', 'Write Off', 'Patient Responsibility', 'Charge']
+    elif file_type == '277':
+        records = parse_277_content(content)
+        fieldnames = ['Clearing House', 'Received Date', 'Claim Status Tracking #', 'Billed Amt', 'Date of Service', 
+                      'Last', 'First', 'Acknowledged Amt', 'Status']
+    else:
+        raise ValueError("Unsupported file type: {}".format(file_type))
+
+    output_file_path = os.path.join(output_directory, os.path.basename(file_path) + '_decoded.csv')
+    write_records_to_csv(records, output_file_path, fieldnames)
+    print("Decoded data written to {}".format(output_file_path))
+
+def determine_file_type(file_path):
+    if file_path.endswith('.era'):
+        return 'ERA'
+    elif file_path.endswith('.277'):
+        return '277'
+    else:
+        raise ValueError("Unsupported file type for file: {}".format(file_path))
+    
+def read_file(file_path):
+    with open(file_path, 'r') as file:
+        content = file.read().replace('\n', '')
+    return content
+
+def write_records_to_csv(records, output_file_path, fieldnames):
+    with open(output_file_path, 'w', newline='') as csvfile:
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+        for record in records:
+            writer.writerow(record)
+
+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['output_directory']
+    for file_path in files:
+        try:
+            process_file(file_path, output_directory)
+        except Exception as e:
+            log("Failed to process {}: {}".format(file_path, e), 'error')