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

MediLink/MediLink_Down.py

@@ -1,5 +1,4 @@
 import os
-import logging
 import argparse
 import shutil
 from datetime import datetime
@@ -20,28 +19,6 @@ We need to make another function that figures out claim rejections and tries to
 7. Configuration Key Accuracy: Audit the script to correct any inaccuracies in configuration key references, ensuring seamless configuration data retrieval.
 """
 
-# Setup basic logging
-def setup_logger(local_storage_path):
-    # Define a reasonable name for the log file, e.g., "MediLink_Down_Process.log"
-    log_filename = datetime.now().strftime("MediLink_Down_Process_%m%d%Y.log")
-    log_filepath = os.path.join(local_storage_path, log_filename)
-
-    for handler in logging.root.handlers[:]:
-        logging.root.removeHandler(handler)
-    
-    # Setup logging to file
-    logging.basicConfig(level=logging.INFO,
-                        format='%(asctime)s - %(levelname)s - %(message)s',
-                        filename=log_filepath,  # Direct logging to a file in local_storage_path
-                        filemode='a')  # Append mode
-
-    # If you also want to see the logs in the console, add a StreamHandler
-    #console_handler = logging.StreamHandler()
-    #console_handler.setLevel(logging.INFO)
-    #formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
-    #console_handler.setFormatter(formatter)
-    #logging.getLogger('').addHandler(console_handler)
-
 # 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.
@@ -62,7 +39,7 @@ def move_downloaded_files(local_storage_path):
         # 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)
-        logging.info("Moved '{}' to '{}'".format(file, local_response_directory))
+        MediLink_ConfigLoader.log("Moved '{}' to '{}'".format(file, local_response_directory))
 
 def find_era_files(era_file_path):
     """
@@ -92,7 +69,6 @@ def main(desired_endpoint='AVAILITY'):
     # Setup Logger, Load configuration and output directory
     config, _ = MediLink_ConfigLoader.load_configuration(args.config_path)
     local_storage_path = config['MediLink_Config']['local_storage_path']
-    setup_logger(local_storage_path)
     output_directory = os.path.join(local_storage_path, "translated_csvs")
      
     # Direct ERA file translation if a file path is provided
@@ -100,24 +76,25 @@ def main(desired_endpoint='AVAILITY'):
         era_files = find_era_files(args.era_file_path)
         if era_files:
             era_files_str = ', '.join(era_files)
-            logging.info("Translating ERA files: {}".format(era_files_str))
+            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)
-            logging.info("Translation and consolidation completed.")
+            MediLink_ConfigLoader.log("Translation and consolidation completed.")
             return consolidate_csv_path
         else:
-            logging.error("No ERA files found matching: {}".format(args.era_file_path))
+            MediLink_ConfigLoader.log("No ERA files found matching: {}".format(args.era_file_path))
             return
     
-    # TODO This probably needs to be built into a loop that cycles through all 3 endpoints. 
+    # 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")
+    # print("Please wait...\n")
     
     # Validate endpoint key
     endpoint_key = args.desired_endpoint
     if endpoint_key not in config['MediLink_Config']['endpoints']:
-        logging.error("Endpoint '{}' not found in configuration. Using default 'AVAILITY'.".format(endpoint_key))
+        MediLink_ConfigLoader.log("Endpoint '{}' not found in configuration. Using default 'AVAILITY'.".format(endpoint_key))
         endpoint_key = 'AVAILITY'
     
     # Retrieve endpoint configuration and local storage path
@@ -125,17 +102,17 @@ def main(desired_endpoint='AVAILITY'):
     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)
-    
+    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 This needs to add functionality for differentiating between ERA and 277 or 
+        # 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)
-        logging.info("Translated ERA to CSV: {}".format(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)

MediLink/MediLink_ERA_decoder.py

@@ -1,9 +1,10 @@
 import os
-import logging
 import sys
-from MediLink_ConfigLoader import setup_logger, load_configuration
+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.
@@ -170,7 +171,6 @@ if __name__ == "__main__":
     
     # Setup logger
     local_storage_path = config['MediLink_Config']['local_storage_path']
-    setup_logger(local_storage_path)
     
     # Define output directory
     output_directory = os.path.join(local_storage_path, "translated_csvs")
@@ -178,7 +178,7 @@ if __name__ == "__main__":
     # Retrieve ERA files from command line arguments
     files = sys.argv[1:]  # Exclude the script name
     if not files:
-        logging.error("No ERA files provided as arguments.")
+        log("No ERA files provided as arguments.")
         sys.exit(1)
 
     # Translate ERA files to CSV format

MediLink/MediLink_Gmail.py

@@ -1,4 +1,100 @@
 """
-Get new filtered GMail emails with Carol's CSV, make OTP request, login, download CSV.
-Also download the surgery schedule.
-"""
+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

@@ -62,6 +62,47 @@ Database Management:
 - 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.
+
 """
 
 

MediLink/MediLink_UI.py

@@ -1,20 +1,21 @@
-import datetime
-import sys
+from datetime import datetime
 
 """
 Development Tasks for User Interface (UI) Enhancement in MediSoft Claims Submittal (MediLink) Script:
 
-Streamline user interaction for endpoint selection and patient adjustments with automated endpoint validation.
-Strengthen error handling in file conversion, transmission, and user inputs with actionable user feedback.
-Expand logging levels and develop a user notification system for process milestones and errors.
-Focus workflow on patient details for endpoint adjustments, facilitating patient-centric file submissions.
-Implement internet connectivity checks with retry options for submissions and offer pause/resume capabilities.
-Include final review and confirmation steps before submission, allowing for endpoint adjustments per patient.
+- [ ] Streamline user interaction for endpoint selection and patient adjustments with automated endpoint validation.
+- [ ] Strengthen error handling in file conversion, transmission, and user inputs with actionable user feedback.
+- [ ] Expand logging levels and develop a user notification system for process milestones and errors.
+- [ ] Focus workflow on patient details for endpoint adjustments, facilitating patient-centric file submissions.
+- [ ] Implement internet connectivity checks with retry options for submissions and offer pause/resume capabilities.
+- [ ] Include final review and confirmation steps before submission, allowing for endpoint adjustments per patient.
+- [ ] TODO Need to resolve suggested endpoint issues/refresh/quasi-persist (this is partially implemented, careful)
+- [ ] TODO Augment the menu for displaying the insurance type information before submittal.
 """
 
 def display_welcome():
     print("\n" + "-" * 60)
-    print("\n          *~^~*:    Welcome to MediLink!    :*~^~*\n")
+    print("          *~^~*:    Welcome to MediLink!    :*~^~*")
     print("-" * 60 + "\n")
 
 def display_menu(options):
@@ -35,7 +36,7 @@ def display_patient_options(detailed_patient_data):
     """
     Displays a list of patients with their current suggested endpoints, prompting for selections to adjust.
     """
-    print("\nPlease select the patients you want to adjust by entering their numbers separated by commas (e.g., 1,3,5):")
+    print("\nPlease select the patients to adjust by entering their numbers separated by commas\n(e.g., 1,3,5):")
     # Can disable this extra print for now because the px list would already be on-screen.
     #for i, data in enumerate(detailed_patient_data, start=1):
     #    patient_info = "{0} ({1}) - {2}".format(data['patient_name'], data['patient_id'], data['surgery_date'])
@@ -62,26 +63,27 @@ def get_endpoint_decision():
     """
     return input("Change endpoint? (Y/N): ").strip().lower()
 
-def display_endpoint_options(endpoint_mapping):
+def display_endpoint_options(endpoints_config):
     """
     Displays the endpoint options to the user based on the provided mapping.
 
     Args:
-        endpoint_mapping (dict): A dictionary mapping option numbers to endpoint names.
-                                  Example: {'1': 'Availity', '2': 'OptumEDI', ...}
+        endpoints_config (dict): A dictionary mapping endpoint keys to their properties, 
+                                 where each property includes a 'name' key for the user-friendly name.
+                                 Example: {'Availity': {'name': 'Availity'}, 'OptumEDI': {'name': 'OptumEDI'}, ...}
 
     Returns:
         None
     """
     print("Select the new endpoint for the patient:")
-    for option, endpoint_name in endpoint_mapping.items():
-        print("{0}. {1}".format(option, endpoint_name))
+    for index, (key, details) in enumerate(endpoints_config.items(), 1):
+        print("{0}. {1}".format(index, details['name']))
 
 def get_new_endpoint_choice():
     """
     Gets the user's choice for a new endpoint.
     """
-    return input("Select new endpoint (1, 2, or 3): ").strip()
+    return input("Select desired endpoint (e.g. 1, 2): ").strip()
 
 def display_patient_summaries(detailed_patient_data):
     """
@@ -103,7 +105,7 @@ def ask_for_proceeding_with_endpoints():
 
 def display_file_summary(index, summary):
     # Ensure surgery_date is converted to a datetime object
-    surgery_date = datetime.datetime.strptime(summary['surgery_date'], "%m-%d-%y")
+    surgery_date = datetime.strptime(summary['surgery_date'], "%m-%d-%y")
 
     # Displays the summary of a file.
     print("{:02d}. {:5} (ID: {:<8}) {:20} {:15} Suggested Endpoint: {}".format(