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

MediLink/MediLink_Decoder.py

@@ -3,9 +3,9 @@ import os
 import sys
 import csv
 from MediLink_ConfigLoader import load_configuration, log
-from MediLink_Parser import parse_era_content, parse_277_content
+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):
+def process_file(file_path, output_directory, return_records=False):
     if not os.path.exists(output_directory):
         os.makedirs(output_directory)
 
@@ -14,50 +14,152 @@ def process_file(file_path, output_directory):
     
     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']
+    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:
-        raise ValueError("Unsupported file type: {}".format(file_type))
+        log("Unsupported file type: {}".format(file_type))
+        return []
 
-    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))
+    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:
-        raise ValueError("Unsupported file type for file: {}".format(file_path))
-    
+        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().replace('\n', '')
+        content = file.read()
     return content
 
-def write_records_to_csv(records, output_file_path, fieldnames):
+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()
+    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']
+    output_directory = config['MediLink_Config'].get('local_storage_path')
+    all_records = []
     for file_path in files:
         try:
-            process_file(file_path, output_directory)
+            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')
+            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))

MediLink/MediLink_Deductible.py

@@ -0,0 +1,210 @@
+"""
+# Create a summary JSON
+summary = {
+    "Payer ID": ins_payerID,
+    "Provider": provider_last_name,
+    "Member ID": ins_memberID,
+    "Date of Birth": dob,
+    "Patient Name": patient_name,
+    "Patient Info": {
+        "DOB": dob,
+        "Address": "{} {}".format(patient_info.get("addressLine1", ""), patient_info.get("addressLine2", "")).strip(),
+        "City": patient_info.get("city", ""),
+        "State": patient_info.get("state", ""),
+        "ZIP": patient_info.get("zip", ""),
+        "Relationship": patient_info.get("relationship", "")
+    },
+    "Insurance Info": {
+        "Payer Name": insurance_info.get("payerName", ""),
+        "Payer ID": ins_payerID,
+        "Member ID": ins_memberID,
+        "Group Number": insurance_info.get("groupNumber", ""),
+        "Insurance Type": ins_insuranceType,
+        "Type Code": ins_insuranceTypeCode,
+        "Address": "{} {}".format(insurance_info.get("addressLine1", ""), insurance_info.get("addressLine2", "")).strip(),
+        "City": insurance_info.get("city", ""),
+        "State": insurance_info.get("state", ""),
+        "ZIP": insurance_info.get("zip", "")
+    },
+    "Policy Info": {
+        "Eligibility Dates": eligibilityDates,
+        "Policy Member ID": policy_info.get("memberId", ""),
+        "Policy Status": policy_status
+    },
+    "Deductible Info": {
+        "Remaining Amount": remaining_amount
+    }
+}
+
+# Print debug JSON
+# Uncomment below if you need to debug later
+# print("\nDebug JSON Summary:")
+# print(json.dumps(summary, indent=2))
+"""
+import MediLink_API_v3
+import os
+import sys
+from datetime import datetime
+import requests
+import json
+
+try:
+    from MediLink import MediLink_ConfigLoader
+except ImportError:
+    import MediLink_ConfigLoader
+
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(project_dir)
+
+try:
+    from MediBot import MediBot_Preprocessor_lib
+except ImportError:
+    import MediBot_Preprocessor_lib
+
+# Load configuration
+config, _ = MediLink_ConfigLoader.load_configuration()
+
+# Initialize the API client
+client = MediLink_API_v3.APIClient()
+
+# Get provider_last_name and npi from configuration
+provider_last_name = config['MediLink_Config'].get('default_billing_provider_last_name', 'Unknown')
+npi = config['MediLink_Config'].get('default_billing_provider_npi', 'Unknown')
+
+# Check if the provider_last_name is still 'Unknown'
+if provider_last_name == 'Unknown':
+    MediLink_ConfigLoader.log("Warning: provider_last_name was not found in the configuration.", level="WARNING")
+
+# Define the list of payer_id's to iterate over
+payer_ids = ['87726', '03432', '96385', '95467', '86050', '86047', '95378', '06111', '37602']
+
+# Get the latest CSV
+CSV_FILE_PATH = config.get('CSV_FILE_PATH', "")
+csv_data = MediBot_Preprocessor_lib.load_csv_data(CSV_FILE_PATH)
+
+# Only keep rows that contain a valid number from the payer_ids list
+valid_rows = [row for row in csv_data if str(row['Ins1 Payer ID']) in payer_ids]
+
+# Function to check if the date format is correct
+def validate_and_format_date(date_str):
+    for fmt in ('%Y-%m-%d', '%m/%d/%Y', '%d-%b-%Y', '%d-%m-%Y'):
+        try:
+            formatted_date = datetime.strptime(date_str, fmt).strftime('%Y-%m-%d')
+            return formatted_date
+        except ValueError:
+            continue
+    return None
+
+# List of patients with DOB and MemberID from CSV data
+patients = [
+    (validate_and_format_date(row['Patient DOB']), row['Primary Policy Number']) 
+    for row in valid_rows if validate_and_format_date(row['Patient DOB']) is not None
+]
+
+# Function to get eligibility information
+def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, member_id, npi):
+    try:
+        # Log the parameters being sent to the function
+        MediLink_ConfigLoader.log("Calling get_eligibility_v3 with parameters:", level="DEBUG")
+        MediLink_ConfigLoader.log("payer_id: {}".format(payer_id), level="DEBUG")
+        MediLink_ConfigLoader.log("provider_last_name: {}".format(provider_last_name), level="DEBUG")
+        MediLink_ConfigLoader.log("date_of_birth: {}".format(date_of_birth), level="DEBUG")
+        MediLink_ConfigLoader.log("member_id: {}".format(member_id), level="DEBUG")
+        MediLink_ConfigLoader.log("npi: {}".format(npi), level="DEBUG")
+
+        # Call the get_eligibility_v3 function
+        eligibility = MediLink_API_v3.get_eligibility_v3(
+            client, payer_id, provider_last_name, 'MemberIDDateOfBirth', date_of_birth, member_id, npi
+        )
+        
+        # Log the response
+        MediLink_ConfigLoader.log("Eligibility response: {}".format(json.dumps(eligibility, indent=4)), level="DEBUG")
+        
+        return eligibility
+    except requests.exceptions.HTTPError as e:
+        # Log the HTTP error response
+        MediLink_ConfigLoader.log("HTTPError: {}".format(e), level="ERROR")
+        MediLink_ConfigLoader.log("Response content: {}".format(e.response.content), level="ERROR")
+    except Exception as e:
+        # Log any other exceptions
+        MediLink_ConfigLoader.log("Error: {}".format(e), level="ERROR")
+    return None
+
+# Function to extract required fields and display in a tabular format
+def display_eligibility_info(data, dob, member_id, output_file):
+    if data is None:
+        return
+
+    for policy in data["memberPolicies"]:
+        # Skip non-medical policies
+        if policy["policyInfo"]["coverageType"] != "Medical":
+            continue
+
+        patient_info = policy["patientInfo"][0]
+        lastName = patient_info.get("lastName", "")
+        firstName = patient_info.get("firstName", "")
+        middleName = patient_info.get("middleName", "")
+
+        # Check if the remaining amount is per individual first, then fallback to family
+        if 'individual' in policy["deductibleInfo"]:
+            remaining_amount = policy["deductibleInfo"]["individual"]["inNetwork"].get("remainingAmount", "")
+        else:
+            remaining_amount = policy["deductibleInfo"]["family"]["inNetwork"].get("remainingAmount", "")
+
+        insurance_info = policy["insuranceInfo"]
+        ins_insuranceType = insurance_info.get("insuranceType", "")
+        ins_insuranceTypeCode = insurance_info.get("insuranceTypeCode", "")
+        ins_memberID = insurance_info.get("memberId", "")
+        ins_payerID = insurance_info.get("payerId", "")
+
+        policy_info = policy["policyInfo"]
+        policy_status = policy_info.get("policyStatus", "")
+
+        patient_name = "{} {} {}".format(firstName, middleName, lastName).strip()[:20]
+
+        # Display patient information in a table row format
+        table_row = "{:<20} | {:<10} | {:<40} | {:<5} | {:<15} | {:<15}".format(
+            patient_name, dob, ins_insuranceType, ins_payerID, policy_status, remaining_amount)
+        output_file.write(table_row + "\n")
+        print(table_row)  # Print to console for progressive display
+
+# Print the table header once before entering the loop
+output_file_path = os.path.join(os.getenv('TEMP'), 'eligibility_report.txt')
+with open(output_file_path, 'w') as output_file:
+    table_header = "{:<20} | {:<10} | {:<40} | {:<5} | {:<15} | {:<15}".format(
+        "Patient Name", "DOB", "Insurance Type", "PayID", "Policy Status", "Remaining Amt")
+    output_file.write(table_header + "\n")
+    output_file.write("-" * len(table_header) + "\n")
+    print(table_header)
+    print("-" * len(table_header))
+
+    # Set to keep track of processed patients
+    processed_patients = set()
+
+    # Loop through each payer_id and patient to call the API, then display the eligibility information
+    errors = []
+    for payer_id in payer_ids:
+        for dob, member_id in patients:
+            # Skip if this patient has already been processed
+            if (dob, member_id) in processed_patients:
+                continue
+            try:
+                eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, dob, member_id, npi)
+                if eligibility_data is not None:
+                    display_eligibility_info(eligibility_data, dob, member_id, output_file)  # Display as we get the result
+                    processed_patients.add((dob, member_id))  # Mark this patient as processed
+            except Exception as e:
+                errors.append((dob, member_id, str(e)))
+
+    # Display errors if any
+    if errors:
+        error_msg = "\nErrors encountered during API calls:\n"
+        output_file.write(error_msg)
+        print(error_msg)
+        for error in errors:
+            error_details = "DOB: {}, Member ID: {}, Error: {}\n".format(error[0], error[1], error[2])
+            output_file.write(error_details)
+            print(error_details)
+
+# Open the generated file in Notepad
+os.system('notepad.exe {}'.format(output_file_path))

MediLink/MediLink_Down.py

@@ -3,22 +3,11 @@ import os
 import argparse
 import shutil
 import glob
+import csv
 from MediLink_Decoder import process_file
-from MediLink_DataMgmt import operate_winscp, consolidate_csvs
-import MediLink_ConfigLoader
-# Import decoders for other file types
-
-"""
-Main triaging function for handling report downloads and processing from various endpoints. This function
-handles downloading reports, moving files, and decoding them into a readable format. The goal is to 
-provide detailed receipt and troubleshooting information for the claims.
-
-Key Enhancements:
-- Handle multiple file types (ERA, 277, etc.) and integrate respective decoders.
-- Support multi-endpoint processing.
-- Implement progress tracking for long-running operations.
-- Provide both consolidated CSV output and in-memory parsed data for real-time display.
-"""
+from MediLink_ConfigLoader import load_configuration, log
+from MediLink_DataMgmt import operate_winscp
+
 def move_downloaded_files(local_storage_path, config):
     local_response_directory = os.path.join(local_storage_path, "responses")
     
@@ -26,7 +15,7 @@ def move_downloaded_files(local_storage_path, config):
         os.makedirs(local_response_directory)
     
     download_dir = config['MediLink_Config']['local_storage_path']
-    file_extensions = ['.era', '.277']  # Extendable list of file extensions
+    file_extensions = ['.era', '.277', '.277ibr', '.277ebr', '.dpt', '.ebt', '.ibt', '.txt']  # Extendable list of file extensions
     
     for ext in file_extensions:
         downloaded_files = [f for f in os.listdir(download_dir) if f.endswith(ext)]
@@ -34,12 +23,13 @@ def move_downloaded_files(local_storage_path, config):
             source_path = os.path.join(download_dir, file)
             destination_path = os.path.join(local_response_directory, file)
             shutil.move(source_path, destination_path)
-            MediLink_ConfigLoader.log("Moved '{}' to '{}'".format(file, local_response_directory))
+            log("Moved '{}' to '{}'".format(file, local_response_directory))
 
 def find_files(file_path_pattern):
     normalized_path = os.path.normpath(file_path_pattern)
-
-    if "*" in normalized_path:
+    if os.path.isdir(normalized_path):
+        return [os.path.join(normalized_path, f) for f in os.listdir(normalized_path) if os.path.isfile(os.path.join(normalized_path, f))]
+    elif "*" in normalized_path:
         matching_files = glob.glob(normalized_path)
         return [os.path.normpath(file) for file in matching_files]
     else:
@@ -47,76 +37,117 @@ def find_files(file_path_pattern):
 
 def translate_files(files, output_directory):
     translated_files = []
+    consolidated_records = []
+    file_counts = {'.era': 0, '.277': 0, '.277ibr': 0, '.277ebr': 0, '.dpt': 0, '.ebt': 0, '.ibt': 0, '.txt': 0}
+
     for file in files:
+        ext = os.path.splitext(file)[1]
+        if ext in file_counts:
+            file_counts[ext] += 1
+
         try:
-            process_file(file, output_directory)
+            records = process_file(file, output_directory, return_records=True)
+            consolidated_records.extend(records)
             csv_file_path = os.path.join(output_directory, os.path.basename(file) + '_decoded.csv')
-            MediLink_ConfigLoader.log("Translated file to CSV: {}".format(csv_file_path), level="INFO")
+            log("Translated file to CSV: {}".format(csv_file_path), level="INFO")
             translated_files.append(csv_file_path)
         except ValueError as ve:
-            MediLink_ConfigLoader.log("Unsupported file type: {}".format(file), level="WARNING")
+            log("Unsupported file type: {}".format(file), level="WARNING")
         except Exception as e:
-            MediLink_ConfigLoader.log("Error processing file {}: {}".format(file, e), level="ERROR")
+            log("Error processing file {}: {}".format(file, e), level="ERROR")
     
-    consolidate_csv_path = consolidate_csvs(output_directory, file_prefix="Consolidated", interactive=True)
-    MediLink_ConfigLoader.log("Consolidated CSV path: {}".format(consolidate_csv_path), level="INFO")
-    return consolidate_csv_path, translated_files
+    print("Detected and processed file counts by type:")
+    for ext, count in file_counts.items():
+        print("{}: {} files detected".format(ext, count))
+
+    return consolidated_records, translated_files
 
 def display_translated_files(translated_files):
     print("\nTranslated Files Summary:")
     for file in translated_files:
-        print(" - {}",format(file))
+        print(" - {}".format(file))
 
-def main(desired_endpoint='AVAILITY'):
+def main():
     parser = argparse.ArgumentParser(description="Process files and convert them to CSV format.")
     parser.add_argument('--config_path', type=str, help='Path to the configuration JSON file', default="json/config.json")
-    parser.add_argument('--desired_endpoint', type=str, help='The desired endpoint key from the configuration.', default=desired_endpoint)
-    parser.add_argument('--file_path_pattern', type=str, help='Optional: Specify a path pattern for files for direct translation.', default=None)
+    parser.add_argument('--file_path_pattern', type=str, help='Path pattern or directory for files to process.', default=None)
     args = parser.parse_args()
-    
-    config, _ = MediLink_ConfigLoader.load_configuration(args.config_path)
+
+    config, _ = load_configuration(args.config_path)
+        
     local_storage_path = config['MediLink_Config']['local_storage_path']
     output_directory = os.path.join(local_storage_path, "translated_csvs")
-    
+
     if args.file_path_pattern:
-        files = find_files(args.file_path_pattern)
-        if files:
-            files_str = ', '.join(files)
-            MediLink_ConfigLoader.log("Translating files: {}".format(files_str), level="INFO")
-            consolidate_csv_path, translated_files = translate_files(files, output_directory)
-            MediLink_ConfigLoader.log("Translation and consolidation completed.", level="INFO")
-            display_translated_files(translated_files)
-            return consolidate_csv_path
-        else:
-            MediLink_ConfigLoader.log("No files found matching: {}".format(args.file_path_pattern), level="WARNING")
-            return
-    
-    endpoint_key = args.desired_endpoint
-    if endpoint_key not in config['MediLink_Config']['endpoints']:
-        MediLink_ConfigLoader.log("Endpoint '{}' not found in configuration. Using default 'AVAILITY'.".format(endpoint_key), level="WARNING")
-        endpoint_key = 'AVAILITY'
-    
-    endpoint_configs = [config['MediLink_Config']['endpoints'][key] for key in config['MediLink_Config']['endpoints']]
-    downloaded_files = []
+        process_files_by_pattern(args.file_path_pattern, output_directory)
+    else:
+        download_and_process_files(config, local_storage_path, output_directory)
+
+def process_files_by_pattern(file_path_pattern, output_directory):
+    files = find_files(file_path_pattern)
+    if files:
+        files_str = ', '.join(files)
+        log("Translating files: {}".format(files_str), level="INFO")
+        consolidated_records, translated_files = translate_files(files, output_directory)
+        log("Translation completed.", level="INFO")
+        if consolidated_records:
+            display_consolidated_records(consolidated_records)
+        prompt_csv_export(consolidated_records, output_directory)
+    else:
+        log("No files found matching: {}".format(file_path_pattern), level="WARNING")
 
+def download_and_process_files(config, local_storage_path, output_directory):
+    downloaded_files = download_files_from_endpoints(config, local_storage_path)
+    move_downloaded_files(local_storage_path, config)
+    consolidated_records, translated_files = translate_files(downloaded_files, output_directory)
+    if consolidated_records:
+        display_consolidated_records(consolidated_records)
+    prompt_csv_export(consolidated_records, output_directory)
+
+def download_files_from_endpoints(config, local_storage_path):
+    endpoint_configs = config['MediLink_Config']['endpoints'].values()
+    downloaded_files = []
     for endpoint_config in endpoint_configs:
         downloaded_files += operate_winscp("download", None, endpoint_config, local_storage_path, config)
+    return downloaded_files
+
+def display_consolidated_records(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}
     
-    move_downloaded_files(local_storage_path, config)
-    
-    # Implement progress tracking
-    # from tqdm import tqdm
-    # for file in tqdm(downloaded_files, desc="Translating files"):
-    #     translate_files([file], output_directory)
+    # 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, ''))))
     
-    consolidate_csv_path, translated_files = translate_files(downloaded_files, output_directory)
-    display_translated_files(translated_files)
+    # Create table header
+    header = " | ".join("{:<{}}".format(field, col_widths[field]) for field in new_fieldnames)
+    print(header)
+    print("-" * len(header))
     
-    return consolidate_csv_path
+    # 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 prompt_csv_export(records, output_directory):
+    if records:
+        user_input = input("Do you want to export the consolidated records to a CSV file? (y/n): ")
+        if user_input.lower() == 'y':
+            output_file_path = os.path.join(output_directory, "Consolidated_Records.csv")
+            write_records_to_csv(records, output_file_path)
+            log("Consolidated CSV file created at: {}".format(output_file_path), level="INFO")
+        else:
+            log("CSV export skipped by user.", level="INFO")
+
+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)
 
 if __name__ == "__main__":
-    consolidate_csv_path = main()
-    if consolidate_csv_path:
-        print("CSV File Created: {}".format(consolidate_csv_path))
-    else:
-        print("No CSV file was created.")
+    main()