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

MediLink/MediLink_Down.py

@@ -0,0 +1,128 @@
+import os
+import argparse
+import shutil
+from datetime import datetime
+import glob
+import MediLink_ERA_decoder
+from MediLink_DataMgmt import operate_winscp
+import MediLink_ConfigLoader
+
+"""
+We need to make another function that figures out claim rejections and tries to solve them.
+
+1. Config File Path Adjustment: Ensure the configuration file's path is adaptable for various environments, or clearly document the process for setting this path.
+2. Logging Enhancements: Improve the logging mechanism to offer comprehensive insights through both file and console outputs, aiding in troubleshooting and operational monitoring.
+3. CSV Output Refinement: Update the CSV output structure to include essential ERA data such as Payer Address, ensuring completeness and accuracy of information.
+4. CSV Consolidation Logic: Develop logic for intelligently consolidating CSV outputs from batch-processed ERA files, ensuring coherent and comprehensive data aggregation.
+5. Secure Endpoint Authentication: Establish a secure method for inputting and storing endpoint authentication details, enhancing script security.
+6. Automated Endpoint Processing: Integrate automated looping through configured endpoints for ERA file retrieval, maximizing efficiency and reducing manual oversight.
+7. Configuration Key Accuracy: Audit the script to correct any inaccuracies in configuration key references, ensuring seamless configuration data retrieval.
+"""
+
+# Because I can't figure out how to get it to work directly in the WinSCP command.
+# And on the Windows XP machine apparently the default path is C:\\ ...
+# This needs to get fixed. Ugh.
+def move_downloaded_files(local_storage_path):
+    # Define the target directory for storing downloaded files
+    local_response_directory = os.path.join(local_storage_path, "responses")
+    
+    if not os.path.exists(local_response_directory):
+        os.makedirs(local_response_directory)
+    
+    # Identify all downloaded .era files in the current directory
+    # downloaded_files = [f for f in os.listdir('.') if f.endswith('.era')]
+    downloaded_files = [f for f in os.listdir('C:\\Users\\danie\\OneDrive\\Documents') if f.endswith('.era')]
+    
+    # Move each file to the local_response_directory
+    for file in downloaded_files:
+        source_path = os.path.join('C:\\Users\\danie\\OneDrive\\Documents', file)
+        # source_path = os.path.join('.', file)    for the XP machine? -- This whole thing needs repaired. 
+        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))
+
+def find_era_files(era_file_path):
+    """
+    Find all files matching the era_file_path pattern.
+    This function normalizes the path and supports wildcard patterns.
+    """
+    # Normalize the path to handle slashes correctly
+    normalized_path = os.path.normpath(era_file_path)
+
+    # Handling different wildcard scenarios
+    if "*" in normalized_path:
+        # Use glob to find all files matching the pattern
+        matching_files = glob.glob(normalized_path)
+        # Normalize paths in the resulting list
+        return [os.path.normpath(file) for file in matching_files]
+    else:
+        # Single file specified, return it in a list if it exists
+        return [normalized_path] if os.path.exists(normalized_path) else []
+
+def main(desired_endpoint='AVAILITY'):
+    parser = argparse.ArgumentParser(description="Process ERA 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") # Default handling of json path
+    parser.add_argument('--desired_endpoint', type=str, help='The desired endpoint key from the configuration.', default=desired_endpoint)
+    parser.add_argument('--era_file_path', type=str, help='Optional: Specify a path to an ERA file for direct translation.', default=None)
+    args = parser.parse_args()
+    
+    # Setup Logger, Load configuration and output directory
+    config, _ = MediLink_ConfigLoader.load_configuration(args.config_path)
+    local_storage_path = config['MediLink_Config']['local_storage_path']
+    output_directory = os.path.join(local_storage_path, "translated_csvs")
+     
+    # Direct ERA file translation if a file path is provided
+    if args.era_file_path:
+        era_files = find_era_files(args.era_file_path)
+        if era_files:
+            era_files_str = ', '.join(era_files)
+            MediLink_ConfigLoader.log("Translating ERA files: {}".format(era_files_str))
+            MediLink_ERA_decoder.translate_era_to_csv(era_files, output_directory)
+            # Instead of returning a single CSV file path, consolidate here
+            consolidate_csv_path = MediLink_ERA_decoder.consolidate_csvs(output_directory)
+            MediLink_ConfigLoader.log("Translation and consolidation completed.")
+            return consolidate_csv_path
+        else:
+            MediLink_ConfigLoader.log("No ERA files found matching: {}".format(args.era_file_path))
+            return
+    
+    # TODO (Low Remit) This probably needs to be built into a loop that cycles through all 3 endpoints. 
+    # I think the uploader has something like this implemented already since it sends to all the endpoints.
+    # The loop should use the tdqa or whatever the progress bar is called.
+    # print("Please wait...\n")
+    
+    # Validate endpoint key
+    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))
+        endpoint_key = 'AVAILITY'
+    
+    # Retrieve endpoint configuration and local storage path
+    endpoint_config = config['MediLink_Config']['endpoints'][endpoint_key]
+    local_storage_path = config['MediLink_Config']['local_storage_path']
+        
+    # Download ERA files from the configured endpoint
+    downloaded_files = operate_winscp("download", None, endpoint_config, local_storage_path, config)
+
+    # Translate downloaded ERA files to CSV format
+    translated_csv_paths = []
+    for file in downloaded_files:
+        # TODO (Low Remit) This needs to add functionality for differentiating between ERA, 277, IBT or 
+        # whatever else might be included in the download folders.
+        MediLink_ERA_decoder.translate_era_to_csv([file], output_directory)
+        csv_file_path = os.path.join(output_directory, os.path.basename(file) + '.csv')
+        translated_csv_paths.append(csv_file_path)
+        MediLink_ConfigLoader.log("Translated ERA to CSV: {}".format(csv_file_path))
+    
+    # Consolidate new CSVs
+    consolidate_csv_path = MediLink_ERA_decoder.consolidate_csvs(output_directory)
+    
+    # Return the list of translated CSV file paths
+    return consolidate_csv_path
+
+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.")

MediLink/MediLink_ERA_decoder.py

@@ -0,0 +1,192 @@
+import os
+import sys
+import csv
+from MediLink_ConfigLoader import load_configuration, log
+from MediLink_DataMgmt import consolidate_csvs
+
+
+"""
+1. ERA File Processing: Implement robust mechanisms for reading and parsing ERA files, addressing potential file integrity issues and accommodating scenarios with multiple payer addresses within a single ERA.
+2. Wildcard File Processing: Enable effective batch processing of ERA files using wildcard patterns in the `--era_file_path` argument, resulting in a unified CSV output.
+3. Date of Service Parsing: Enhance the parsing logic for 'Date of Service' to accommodate different segment identifiers, improving data extraction reliability.
+4. Payer Address Extraction: Fine-tune the logic for extracting payer and provider addresses from ERA files, ensuring only relevant information is captured.
+5. De-persisting Intermediate Files.
+"""
+
+# ERA Parser
+def parse_era_content(content):
+    extracted_data = []
+    normalized_content = content.replace('~\n', '~')
+    lines = normalized_content.split('~')
+    
+    # Reset these values for each new CLP segment
+    record = {}
+    check_eft, payer_address = None, None
+    allowed_amount, write_off, patient_responsibility, adjustment_amount = 0, 0, 0, 0
+    is_payer_section = False  # Flag to identify payer section for accurate address capture
+    
+    for line in lines:
+        segments = line.split('*')
+        
+        if segments[0] == 'TRN' and len(segments) > 2:
+            check_eft = segments[2]
+            
+        # Determine the start and end of the payer section to correctly capture the payer's address
+        if segments[0] == 'N1':
+            if segments[1] == 'PR':  # Payer information starts
+                is_payer_section = True
+                # payer_name = segments[2]  # Can capture payer name here if needed
+            elif segments[1] == 'PE':  # Provider information starts, ending payer section
+                is_payer_section = False
+        
+        # Correctly capture payer address only within payer section
+        if is_payer_section and segments[0] == 'N3' and len(segments) > 1:
+            payer_address = segments[1]
+        
+        if segments[0] == 'CLP' and len(segments) >= 5:
+            if record:
+                if adjustment_amount == 0 and (write_off > 0 or patient_responsibility > 0):
+                    adjustment_amount = write_off + patient_responsibility
+
+                # Finalize and append the current record before starting a new one
+                record.update({
+                    # 'Payer Name': payer_name,
+                    'Payer Address': payer_address,
+                    'Allowed Amount': allowed_amount,
+                    'Write Off': write_off,
+                    'Patient Responsibility': patient_responsibility,
+                    'Adjustment Amount': adjustment_amount, 
+                })
+                extracted_data.append(record)
+                
+                # Reset variables for the next record
+                allowed_amount, write_off, patient_responsibility, adjustment_amount = 0, 0, 0, 0
+                # payer_address = None  # Reset address for the next CLP segment if it changes within one ERA file (so no. disable.)
+            
+            # Initialize a new record
+            record = {
+                'Check EFT': check_eft,
+                'Chart Number': segments[1],
+                'Payer Address': payer_address,
+                'Amount Paid': segments[4],
+                'Charge': segments[3],  # Total submitted charges for the claim
+            }
+        
+        elif segments[0] == 'CAS':
+            # Parsing CAS segments for Write Off and Patient Responsibility
+            if segments[1] == 'CO':  # Write Off
+                write_off += float(segments[3])
+            elif segments[1] == 'PR':  # Patient Responsibility
+                patient_responsibility += float(segments[3])
+            elif segments[1] == 'OA':  # Capture Adjustment Amount from CAS*OA segment
+                adjustment_amount += float(segments[3])
+        
+        elif segments[0] == 'AMT' and segments[1] == 'B6':
+            # Allowed Amount from AMT segment
+            allowed_amount += float(segments[2])
+        
+        elif segments[0] == 'DTM' and (segments[1] == '232' or segments[1] == '472'):
+            record['Date of Service'] = segments[2]
+    
+
+    if record:
+    # Final record handling
+        if adjustment_amount == 0 and (write_off > 0 or patient_responsibility > 0):
+            adjustment_amount = write_off + patient_responsibility
+        # Append the last record
+        record.update({
+            'Allowed Amount': allowed_amount,
+            'Write Off': write_off,
+            'Patient Responsibility': patient_responsibility,
+            'Adjustment Amount': adjustment_amount, 
+        })
+        extracted_data.append(record)
+        
+    return extracted_data
+
+def translate_era_to_csv(files, output_directory):
+    if not os.path.exists(output_directory):
+        os.makedirs(output_directory)
+    
+    for file_path in files:
+        # Ensure the file is read correctly
+        with open(file_path, 'r') as era_file:
+            era_content = era_file.read()
+        
+        data = parse_era_content(era_content)
+        # print("Parsed Data: ", data)  # DEBUG
+        
+        csv_file_path = os.path.join(output_directory, os.path.basename(file_path) + '.csv')
+        
+        try:
+            # Open the CSV file with explicit newline handling
+            with open(csv_file_path, 'w', newline='') as csv_file:
+                fieldnames = ['Date of Service',
+                              'Check EFT', 
+                              'Chart Number', 
+                              'Payer Address', 
+                              'Amount Paid', 
+                              'Adjustment Amount',
+                              'Allowed Amount',
+                              'Write Off',
+                              'Patient Responsibility',
+                              'Charge'
+                              ]
+                writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
+                
+                writer.writeheader()
+                for record in data:
+                    
+                    # print("Writing record: ", record)
+                    
+                    writer.writerow({
+                        'Date of Service': record.get('Date of Service', ''),
+                        'Check EFT': record.get('Check EFT', ''),
+                        'Chart Number': record.get('Chart Number', ''),
+                        'Payer Address': record.get('Payer Address', ''),
+                        'Amount Paid': record.get('Amount Paid', ''),
+                        'Adjustment Amount': record.get('Adjustment Amount', ''),
+                        'Allowed Amount': record.get('Allowed Amount', ''),
+                        'Write Off': record.get('Write Off', ''),
+                        'Patient Responsibility': record.get('Patient Responsibility', ''),
+                        'Charge': record.get('Charge', ''),
+                    })
+                # Explicitly flush data to ensure it's written
+                csv_file.flush()
+        except Exception as e:
+            print("Error writing CSV: ", e)
+
+# User Interface
+def user_confirm_overwrite(chart_numbers):
+    """Asks the user for confirmation to overwrite an existing file, showing Chart Numbers."""
+    print("The following Chart Numbers are in the existing file:")
+    for number in chart_numbers:
+        print(number)
+    return input("The file already exists. Do you want to overwrite it? (y/n): ").strip().lower() == 'y'
+
+if __name__ == "__main__":
+    # Load configuration
+    
+    config, _ = load_configuration()
+    
+    # Setup logger
+    local_storage_path = config['MediLink_Config']['local_storage_path']
+    
+    # Define output directory
+    output_directory = os.path.join(local_storage_path, "translated_csvs")
+    
+    # Retrieve ERA files from command line arguments
+    files = sys.argv[1:]  # Exclude the script name
+    if not files:
+        log("No ERA files provided as arguments.")
+        sys.exit(1)
+
+    # Translate ERA files to CSV format
+    translate_era_to_csv(files, output_directory)
+    
+    # Consolidate CSVs
+    consolidate_csv_path = consolidate_csvs(output_directory)
+    if consolidate_csv_path:
+        print("Consolidated CSV File Created: {}".format(consolidate_csv_path))
+    else:
+        print("No CSV file was created.")

MediLink/MediLink_Gmail.py

@@ -0,0 +1,100 @@
+"""
+This documentation outlines the current functionality and development insights of a Google Apps Script and associated 
+client-side Python script designed to facilitate the automated retrieval of secured content from emails. The system 
+enables users to extract links and one-time passwords (OTPs) from emails, initiating and managing secure email interactions 
+without manual intervention.
+
+**Current Functionality:**
+1. **Google Apps Script (Server-side)**:
+    - Handles HTTP GET requests, routing them based on the 'action' parameter to perform tasks like retrieving stored 
+        OTPs, extracting links from emails, and retrieving email subjects for user selection.
+    - Utilizes Gmail search queries to find relevant emails based on sender and date criteria, then extracts data like 
+        subjects or specific links contained within these emails.
+    - Supports interactive selection of emails via a web app, allowing users to choose an email from a list and extract 
+        a specific link.
+    - Employs properties service to store and retrieve data like links and OTPs securely.
+
+2. **HTML Client (Server-side)**:
+    - Provides a user interface for selecting emails from a list, triggered by server-side scripts.
+    - Includes JavaScript to handle client-server communication and user interactions, such as selecting an email and 
+        extracting a link.
+
+3. **Python Script (Client-side)**:
+    - Interfaces with the server-side web app to initiate processes like link retrieval.
+    - Manages opening URLs in the user's browser, allowing for interaction with the web app directly from the client-side 
+        environment.
+
+**Future Work:**
+- [ ] Consider disabling OTP triggers for now since we don't really use it for the present implementation. The phone solution works.
+- [ ] Implement and troubleshoot the OTP extraction and validation system to fully automate the secured content retrieval process.
+- [X] Gmail Server-side Authentication flow & Webapp build
+- [X] Upgrade to handle multiple possible emails selection
+- [ ] Augment to detect Surgery Schedule emails with doc attachments that don't require OTP.
+- [X] Upgrade Gmail query to only get emails with the protected links.
+- [ ] Something that goes here that I forgot.
+
+**Technical Challenges and Solutions:**
+1. **Authentication Limitations on XP Systems:**
+    - **Challenge:** The XP operating system could not perform authentication natively outside a browser, and available 
+        libraries were not capable of handling dynamic authentication.
+    - **Solution:** We centralized all user interactions within an HTML page served by Google Apps Script, thereby 
+        eliminating the need for complex client-side operations. The client-side script was simplified to merely opening URLs, reducing the complexity and potential for errors.
+
+2. **Secure Data Handling:**
+    - **Challenge:** Initially, handling sensitive data such as OTPs and integrating with O365 protected emails was complex 
+        due to security requirements and the transient nature of such data. The solution had to accommodate the specific 
+        security protocols of Microsoft's environment without direct interaction.
+    - **Solution:** Utilizing Google Apps Script’s property service to store OTPs temporarily and securely. Additionally, 
+        we addressed O365 integration by ensuring the browser handled email links directly, respecting Microsoft's security 
+        constraints like x-frame options, thus maintaining functionality without compromising security.
+
+3. **User Interaction and Workflow Streamlining:**
+    - **Challenge:** Managing the workflow from email selection to secure content access required multiple steps that could 
+        potentially confuse the user. The application also had to be efficient under low-bandwidth constraints, and initially, 
+        XP could not download attachments directly, requiring manual user intervention.
+    - **Solution:** The introduction of an interactive web app interface enabled users to select emails directly through a 
+        user-friendly list, significantly simplifying the workflow and minimizing user errors. This method also streamlined 
+        the process, making it suitable for low-bandwidth environments and circumventing the need for full email client loads.
+"""
+import sys
+import subprocess
+import webbrowser
+from MediLink_ConfigLoader import log
+
+def open_browser_with_executable(url, browser_path=None):
+    """
+    Opens a browser with the specified URL using a provided browser executable path or the default browser.
+    """
+    try:
+        if browser_path:
+            log("Attempting to open URL with provided executable: {} {}".format(browser_path, url))
+            # Try to open the browser using subprocess.Popen
+            process = subprocess.Popen([browser_path, url], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            stdout, stderr = process.communicate()
+            if process.returncode == 0:
+                log("Browser opened with provided executable path using subprocess.Popen.")
+            else:
+                log("Browser failed to open using subprocess.Popen. Return code: {}. Stderr: {}".format(process.returncode, stderr))
+        else:
+            # Fall back to the default browser if no specific path is provided
+            log("No browser path provided. Attempting to open URL with default browser: {}".format(url))
+            webbrowser.open(url)
+            log("Default browser opened.")
+    except Exception as e:
+        log("Failed to open browser: {}".format(e))
+
+def initiate_link_retrieval():
+    """
+    Opens the web application through a direct URL that includes the action parameter.
+    """
+    log("Initiating link retrieval process.")
+    # Direct URL that includes the action parameter to load the HTML content directly
+    url = "https://script.google.com/macros/s/AKfycbzlq8d32mDlLdtFxgL_zvLJernlGPB64ftyxyH8F1nNlr3P-VBH6Yd0NGa1pbBc5AozvQ/exec?action=get_link"
+    try:
+        browser_path = sys.argv[1] if len(sys.argv) > 1 else None
+        open_browser_with_executable(url, browser_path)
+    except Exception as e:
+        log("Error during link retrieval initiation: {}".format(e))
+
+if __name__ == "__main__":
+    initiate_link_retrieval()

MediLink/MediLink_Mailer.py

@@ -0,0 +1,7 @@
+"""
+This is the tool that is going to pull from Medisoft the "REFUND TO PATIENT" amounts and addresses and whatever
+and talk to either Bill.com or a BOA BillPay for Business service or CheckIssuing or something to send automated 
+refund checks to patients.
+
+Also, this tool should be able to do mailed invoicing for "BILL TO PATIENT" to bill a patient as well.
+"""

MediLink/MediLink_Scheduler.py

@@ -0,0 +1,173 @@
+"""
+MediLink Scheduler: A medical claim scheduling and management system that integrates functionalities from MediScheduler and MediLink to optimize medical claim submissions based on patient deductible status, insurance provider deadlines, and a 90-day submission window. It leverages real-time data from insurance APIs for dynamic scheduling to maximize insurance payments by aligning claim submission with deductible fulfillment.
+
+Features:
+- Deductible Optimization: Determines optimal submission times based on deductible fulfillment to maximize reimbursements.
+- Dynamic Scheduling: Updates claim submission timelines in response to changes in deductible status and insurance coverage data.
+- Secure Data Handling: Ensures the security of sensitive patient data through encryption and HIPAA-compliant practices.
+- Integration with MediLink Systems: Seamlessly formats, submits, and tracks claims across MediLink and associated systems.
+- Robust Error Handling and Notifications: Implements mechanisms for error detection and user alerts regarding scheduling and submission errors.
+
+Main Functionalities:
+1. Configuration and System Initialization:
+   - Configures and establishes secure connections to insurance APIs.
+   - Loads encrypted system settings and initializes subsystems for logging, data encryption, and notifications.
+
+2. Scheduler Integration:
+   - Enhances MediLink's main menu to include an option for "Optimize and Schedule Submissions".
+   - This option is visible only when there are new or imminent claims, activating the scheduling function for these claims.
+
+3. Scheduling Process:
+   - Identifies new or urgent claims.
+   - Fetches real-time deductible information from insurance APIs.
+   - Computes remaining deductible and determines suitable submission dates.
+   - Schedules claims with consideration for deductible status and the 90-day deadline, updating a scheduling log with details.
+
+4. User Dashboard Update:
+   - Displays scheduled submissions, including deductible statuses and scheduled dates.
+   - Allows users to manually adjust or override automated scheduling decisions.
+
+5. Pre-Submission Checks:
+   - Daily verification of claims ready for submission.
+   - Prepares 837P claim files and finalizes submission details with user confirmation.
+   - Securely transmits data to insurance providers and logs all submission activities.
+
+6. Direct Submission Handling:
+   - Uses MediLink_Up.submit_claims to manage final claim submissions.
+   - Ensures that all scheduled claims are submitted with requisite details.
+
+7. Data Security:
+   - Applies encryption to any new data storage or sensitive data involved in the scheduling process.
+   - Maintains compliance with HIPAA and relevant security standards.
+
+8. Error Management and Alerts:
+   - Extends error handling capabilities to include specific scheduling and submission issues.
+   - Enhances notifications for reminders and updates on deductible status.
+
+9. Integration with MediLink Logging and Error Handling:
+   - Integrates scheduler operations into MediLink’s existing logging and error management frameworks.
+
+10. Maintenance and Data Cleanup:
+    - Regularly refreshes insurance data mappings and updates deductible information.
+    - Manages cleanup of processed claims to maintain database integrity and performance.
+
+11. User Interface Improvements:
+    - Updates UI to ensure user-friendliness and provides clear operational feedback.
+    - Revises help documentation to reflect new functionalities and guides for scheduling tasks.
+
+Database Management:
+- Maintains a JSON-based database for patient billing data, labeled as patient_billing_db, storing information from various sources (Z.dat file, APIs, SFTP).
+- Database content includes claim statuses, deductible details, error logs, and identifiers for billing readiness.
+- Facilitates efficient tracking and processing of claims, with considerations for integrating individual patient data in batched submissions.
+- Stays on the local machine in a defined secure location per config, ensuring HIPAA compliance without the need for data encryption at rest.
+
+Note: Potential for data corruption or synchronization issues due to system limitations; backup and manual verification measures are advised.
+
+Crosswalk Example:
+    "payer_id": {
+        "87726": {
+            "medisoft_medicare_id": [],
+            "medisoft_id": [
+                "320"
+            ],
+            "endpoint": "OPTUMEDI"
+        },
+        "60054": {
+            "medisoft_medicare_id": [],
+            "medisoft_id": [
+                "369"
+            ],
+            "endpoint": "OPTUMEDI"
+        },
+        "00590": {
+            "medisoft_medicare_id": [],
+            "medisoft_id": [
+                "317"
+            ],
+            "endpoint": "OPTUMEDI"
+        },
+        
+
+Crosswalk add:
+- submit_buffer_maria per payer_id
+- submit_limit_days per payer_id
+- deductible_max = $2500.
+- submit limit buffer = 15 days before final.
+
+MediLink_Scheduler logic to produce dates of submission:
+deductible slows it until a max limit ($2500), then send anyway.
+after maria buffer, before submit (-15?) limit day.
+Maria collects pre-payment, this is a factor, needs to be somehow accounted for in the process where a quantity gets pre-assigned to a patient so we know when to submit the claim.
+
+Date last reviewed, Insurance Type, In network, Annual Deductable Remaining, Recieved pre-payment amount, Check# or 'Cash'.
+
+In the future those pre-payments should be either eCheck, Zelle or by CC + 5% surcharge.
+
+"""
+
+
+# JSON DB structure draft.
+{
+  "patients": {
+    "patient_id": {
+      "first_name": "John",
+      "last_name": "Doe",
+      "date_of_birth": "1985-07-12",
+      "insurance_details": {
+        "provider_id": "XYZ123",
+        "policy_number": "P123456789",
+        "coverage_start_date": "2020-01-01"
+      },
+      "contact_info": {
+        "email": "john.doe@example.com",
+        "phone": "555-1234"
+      }
+    }
+  },
+  "claims": {
+    "claim_id": {
+      "patient_id": "patient_id",
+      "date_of_service": "2023-04-01",
+      "status": "pending",
+      "scheduled_submission_date": "2023-04-15",
+      "actual_submission_date": null,
+      "billing_amount": 500.00,
+      "deductible_applied": 100.00,
+      "covered_amount": 400.00
+    }
+  },
+  "insurance_providers": {
+    "provider_id": {
+      "name": "InsuranceCorp",
+      "contact_details": {
+        "phone": "555-6789",
+        "email": "support@insurancecorp.com"
+      },
+      "endpoint": "https://api.insurancecorp.com"
+    }
+  },
+  "system_configuration": {
+    "last_update": "2023-04-18",
+    "backup_frequency": "daily",
+    "data_encryption_key": "encrypted_key_value"
+  },
+  "logs": {
+    "log_id": {
+      "timestamp": "2023-04-18T12:34:56",
+      "event_type": "error",
+      "description": "Failed to connect to insurance API",
+      "related_claim_id": "claim_id"
+    }
+  },
+   "billing_queue": {
+   "patient_id": "claim_id"
+    },
+   "submitted_837p_batches": {
+   "batch_id": {
+      "timestamp": "2023-04-20T09:00:00",
+      "patients": ["patient_id1", "patient_id2", ...],
+      "endpoint": "clearinghouse_endpoint",
+      "status": "submitted"
+   }
+  }
+}

MediLink/MediLink_StatusCheck.py

@@ -0,0 +1,4 @@
+"""
+Checks and updates the status of submitted medical claims using API endpoints.
+Integrates with MediLink_Down and MediPost to retrieve and process ERAs and other relevant response data from insurance providers.
+"""