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

MediLink/MediLink_API_v2.py

@@ -0,0 +1,174 @@
+import time
+import requests
+
+# Importing configuration loader
+try:
+    from MediLink import MediLink_ConfigLoader
+except ImportError:
+    import MediLink_ConfigLoader
+
+# Class for handling API calls
+class APIClient:
+    def __init__(self):
+        # Load configuration
+        self.config, _ = MediLink_ConfigLoader.load_configuration()
+        # Initialize token cache
+        self.token_cache = {}
+
+    # Method to get access token
+    def get_access_token(self, endpoint_name):
+        # Retrieve endpoint configuration
+        endpoint_config = self.config['MediLink_Config']['endpoints'][endpoint_name]
+        current_time = time.time()
+
+        # Check if token is cached and still valid
+        if endpoint_name in self.token_cache:
+            cached_token = self.token_cache[endpoint_name]
+            if cached_token['expires_at'] > current_time:
+                return cached_token['access_token']
+
+        # Prepare data for token request
+        data = {
+            'grant_type': 'client_credentials',
+            'client_id': endpoint_config['client_id'],
+            'client_secret': endpoint_config['client_secret'],
+            'scope': 'hipaa'
+        }
+        headers = {'Content-Type': 'application/x-www-form-urlencoded'}
+
+        # Request token
+        response = requests.post(endpoint_config['token_url'], headers=headers, data=data)
+        response.raise_for_status()
+        token_data = response.json()
+        access_token = token_data['access_token']
+        expires_in = token_data.get('expires_in', 3600)
+
+        # Cache token with expiration time adjusted
+        self.token_cache[endpoint_name] = {
+            'access_token': access_token,
+            'expires_at': current_time + expires_in - 120
+        }
+        return access_token
+
+    # Method for making API calls
+    def make_api_call(self, endpoint_name, call_type, url_extension="", params=None, data=None):
+        # Retrieve endpoint configuration
+        endpoint_config = self.config['MediLink_Config']['endpoints'][endpoint_name]
+        # Get access token
+        token = self.get_access_token(endpoint_name)
+        headers = {'Authorization': 'Bearer {}'.format(token), 'Accept': 'application/json'}
+
+        # Construct full URL
+        url = endpoint_config['api_url'] + url_extension
+
+        # Make appropriate type of call
+        if call_type == 'GET':
+            response = requests.get(url, headers=headers, params=params)
+        elif call_type == 'POST':
+            headers['Content-Type'] = 'application/json'
+            response = requests.post(url, headers=headers, json=data)
+        elif call_type == 'DELETE':
+            response = requests.delete(url, headers=headers)
+        else:
+            raise ValueError("Unsupported call type")
+
+        if response.status_code >= 400:
+            print("Error {}: {}".format(response.status_code, response.text))
+            response.raise_for_status()
+
+        return response.json()
+
+    # Method for creating coverage
+    def create_coverage(self, endpoint_name, patient_info):
+        return self.make_api_call(endpoint_name, 'POST', url_extension="/coverages", data=patient_info)
+
+    # Method for getting all coverages
+    def get_coverages(self, endpoint_name, params=None):
+        return self.make_api_call(endpoint_name, 'GET', url_extension="/coverages", params=params)
+
+    # Method for getting coverage by ID
+    def get_coverage_by_id(self, endpoint_name, coverage_id):
+        return self.make_api_call(endpoint_name, 'GET', url_extension="/coverages/{}".format(coverage_id))
+
+    # Method for deleting coverage by ID
+    def delete_coverage_by_id(self, endpoint_name, coverage_id):
+        return self.make_api_call(endpoint_name, 'DELETE', url_extension="/coverages/{}".format(coverage_id))
+
+    # Method for getting payer list
+    def get_payer_list(self, endpoint_name, params=None):
+        return self.make_api_call(endpoint_name, 'GET', url_extension="/availity-payer-list", params=params)
+
+# Function to fetch payer name from API
+def fetch_payer_name_from_api(payer_id, config, primary_endpoint='AVAILITY'):
+    client = APIClient()
+
+    # Step 1: Reload configuration for safety (This should be able to be replaced by APIClient())
+    config, _ = MediLink_ConfigLoader.load_configuration()
+
+    # Step 2: Check if the primary endpoint is specified and is valid 
+    # (these validity checks will need to be incorporated into the main functionality)
+    endpoints = config['MediLink_Config']['endpoints']
+    if primary_endpoint and primary_endpoint in endpoints:
+        endpoint_order = [primary_endpoint] + [endpoint for endpoint in endpoints if endpoint != primary_endpoint]
+    else:
+        endpoint_order = list(endpoints.keys())
+
+    # Step 3: Iterate through available endpoints in specified order
+    for endpoint_name in endpoint_order:
+        endpoint_config = endpoints[endpoint_name]
+        if not all(key in endpoint_config for key in ['token_url', 'client_id', 'client_secret']):
+            MediLink_ConfigLoader.log("Skipping {} due to missing API keys.".format(endpoint_name), config, level="WARNING")
+            continue
+
+        try:
+            response = client.get_payer_list(endpoint_name, params={'payerId': payer_id})
+            if 'payers' in response and response['payers']:
+                payer = response['payers'][0]
+                payer_name = payer.get('displayName') or payer.get('name')
+                
+                MediLink_ConfigLoader.log("Successfully found payer at {} for ID {}: {}".format(endpoint_name, payer_id, payer_name), config, level="INFO")
+                return payer_name
+            else:
+                MediLink_ConfigLoader.log("No payer found at {} for ID: {}. Trying next available endpoint.".format(endpoint_name, payer_id), config, level="INFO")
+        except requests.RequestException as e:
+            MediLink_ConfigLoader.log("API call failed at {} for Payer ID '{}': {}".format(endpoint_name, payer_id, str(e)), config, level="ERROR")
+
+    error_message = "All endpoints exhausted for Payer ID {}.".format(payer_id)
+    MediLink_ConfigLoader.log(error_message, config, level="CRITICAL")
+    raise ValueError(error_message)
+
+# Example usage
+if __name__ == "__main__":
+    client = APIClient()
+    try:
+        # Fetch and print payer name
+        payer_name = fetch_payer_name_from_api("11347", 'config.yaml')
+        print("Payer Name: {}".format(payer_name))
+        
+        # Example patient info
+        patient_info = {
+            "policyNumber": "12345", 
+            "name": "John Doe", 
+            "dob": "1980-01-01"
+        }
+        # Create coverage and print response
+        response = client.create_coverage('AVAILITY', patient_info)
+        print("Create Coverage Response: {}".format(response))
+        
+        # Get all coverages and print response
+        response = client.get_coverages('AVAILITY')
+        print("All Coverages: {}".format(response))
+        
+        # Example coverage ID
+        coverage_id = "some-coverage-id"
+        # Get coverage by ID and print response
+        response = client.get_coverage_by_id('AVAILITY', coverage_id)
+        print("Coverage by ID: {}".format(response))
+        
+        # Delete coverage by ID and print response
+        response = client.delete_coverage_by_id('AVAILITY', coverage_id)
+        print("Delete Coverage Response: {}".format(response))
+        
+    except Exception as e:
+        # Print error if any
+        print("Error: {}".format(e))

MediLink/MediLink_APIs.py

@@ -0,0 +1,137 @@
+import time
+import requests
+try:
+    from MediLink import MediLink_ConfigLoader
+except ImportError:
+    import MediLink_ConfigLoader
+
+# Fetches the payer name from API based on the payer ID.
+def fetch_payer_name_from_api(payer_id, config, primary_endpoint='AVAILITY'):
+    """
+    Fetches the payer name from the API using the provided payer ID.
+
+    Args:
+        payer_id (str): The ID of the payer.
+        config (dict): Configuration settings.
+        primary_endpoint (str): The primary endpoint for resolving payer information.
+
+    Raises:
+        ValueError: If all endpoints are exhausted without finding the payer.
+
+    Returns:
+        str: The fetched payer name.
+    """
+    # Reload for safety
+    config, _ = MediLink_ConfigLoader.load_configuration()
+    
+    # Step 1: Retrieve endpoint configurations
+    endpoints = config['MediLink_Config']['endpoints']
+    tried_endpoints = []
+
+    # Step 2: Check if the primary endpoint is specified and is valid
+    if primary_endpoint and primary_endpoint in endpoints:
+        endpoint_order = [primary_endpoint] + [endpoint for endpoint in endpoints if endpoint != primary_endpoint]
+    else:
+        endpoint_order = list(endpoints.keys())
+
+    # Step 3: Iterate through available endpoints in specified order
+    for endpoint_name in endpoint_order:
+        endpoint_config = endpoints[endpoint_name]
+        if not all(key in endpoint_config for key in ['token_url', 'client_id', 'client_secret']):
+            MediLink_ConfigLoader.log("Skipping {} due to missing API keys.".format(endpoint_name), config, level="WARNING")
+            continue
+
+        # Step 4: Get access token for the endpoint
+        token = get_access_token(endpoint_config)
+        api_url = endpoint_config.get("api_url", "")
+        headers = {'Authorization': 'Bearer {}'.format(token), 'Accept': 'application/json'}
+        params = {'payerId': payer_id}
+
+        try:
+            # Step 5: Make API call to fetch payer name
+            response = requests.get(api_url, headers=headers, params=params)
+            response.raise_for_status()
+            data = response.json()
+            if 'payers' in data and data['payers']:
+                payer = data['payers'][0]
+                payer_name = payer.get('displayName') or payer.get('name')
+                
+                # Log successful match
+                MediLink_ConfigLoader.log("Successfully found payer at {} for ID {}: {}".format(endpoint_name, payer_id, payer_name), config, level="INFO")
+                
+                return payer_name
+            else:
+                MediLink_ConfigLoader.log("No payer found at {} for ID: {}. Trying next available endpoint.".format(endpoint_name, payer_id), config, level="INFO")
+        except requests.RequestException as e:
+            # Step 6: Log API call failure
+            MediLink_ConfigLoader.log("API call failed at {} for Payer ID '{}': {}".format(endpoint_name, payer_id, str(e)), config, level="ERROR")
+            tried_endpoints.append(endpoint_name)
+    
+    # Step 7: Log all endpoints exhaustion and raise error
+    error_message = "All endpoints exhausted for Payer ID {}. Endpoints tried: {}".format(payer_id, ', '.join(tried_endpoints))
+    MediLink_ConfigLoader.log(error_message, config, level="CRITICAL")
+    raise ValueError(error_message)
+
+# Test Case for API fetch
+#payer_id = "11347"
+#config = load_configuration() 
+#payer_name = fetch_payer_name_from_api(payer_id, config, endpoint='AVAILITY')
+#print(payer_id, payer_name)
+
+# Initialize a global dictionary to store the access token and its expiry time
+# TODO (Low API) This will need to get setup for each endpoint separately. 
+token_cache = {
+    'access_token': None,
+    'expires_at': 0  # Timestamp of when the token expires
+}
+
+def get_access_token(endpoint_config):
+    current_time = time.time()
+    
+    # Check if the cached token is still valid
+    if token_cache['access_token'] and token_cache['expires_at'] > current_time:
+        return token_cache['access_token']
+
+    # Validate endpoint configuration
+    if not endpoint_config or not all(k in endpoint_config for k in ['client_id', 'client_secret', 'token_url']):
+        raise ValueError("Endpoint configuration is incomplete or missing necessary fields.")
+
+    # Extract credentials and URL from the config
+    CLIENT_ID = endpoint_config.get("client_id")
+    CLIENT_SECRET = endpoint_config.get("client_secret")
+    url = endpoint_config.get("token_url")
+
+    # Setup the data payload and headers for the HTTP request
+    data = {
+        'grant_type': 'client_credentials',
+        'client_id': CLIENT_ID,
+        'client_secret': CLIENT_SECRET,
+        'scope': 'hipaa'
+    }
+    headers = {
+        'Content-Type': 'application/x-www-form-urlencoded'
+    }
+
+    try:
+        # Perform the HTTP request to get the access token
+        response = requests.post(url, headers=headers, data=data)
+        response.raise_for_status()  # This will raise an exception for HTTP error statuses
+        json_response = response.json()
+        access_token = json_response.get('access_token')
+        expires_in = json_response.get('expires_in', 3600)  # Default to 3600 seconds if not provided
+
+        if not access_token:
+            raise ValueError("No access token returned by the server.")
+        
+        # Store the access token and calculate the expiry time
+        token_cache['access_token'] = access_token
+        token_cache['expires_at'] = current_time + expires_in - 120  # Subtracting 120 seconds to provide buffer
+
+        return access_token
+    except requests.RequestException as e:
+        # Handle HTTP errors (e.g., network problems, invalid response)
+        error_msg = "Failed to retrieve access token: {0}. Response status: {1}".format(str(e), response.status_code if response else 'No response')
+        raise Exception(error_msg)
+    except ValueError as e:
+        # Handle specific errors like missing access token
+        raise Exception("Configuration or server response error: {0}".format(str(e)))

MediLink/MediLink_ConfigLoader.py

@@ -4,45 +4,28 @@ import logging
 from datetime import datetime
 from collections import OrderedDict
 import sys
+import platform
 
 """
 This function should be generalizable to have a initialization script over all the Medi* functions
 """
-
-# Setup basic logging. 
-# BUG Consolidate this with MediLink_837p_encoder_library.log
-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)
-
 def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..', 'json', 'config.json'), crosswalk_path=os.path.join(os.path.dirname(__file__), '..', 'json', 'crosswalk.json')):
     """
     Loads endpoint configuration, credentials, and other settings from JSON files.
         
     Returns: A tuple containing dictionaries with configuration settings for the main config and crosswalk.
     """
-    # BUG HARDCODE FOR NOW
-    config_path="G:\\My Drive\\Codes\\MediCafe\\json\\config.json"
-    # "F:\\Medibot\\json\\config.json"
-    crosswalk_path="G:\\My Drive\\Codes\\MediCafe\\json\\crosswalk.json"
-    # "F:\\Medibot\\json\\crosswalk.json"
+    # TODO (Low Config Upgrade) The Medicare / Private differentiator flag probably needs to be pulled or passed to this.
+    # BUG (HARDCODE) FOR NOW:
+    # Detect the operating system
+    if platform.system() == 'Windows' and platform.release() == 'XP':
+        # Use F: paths for Windows XP
+        config_path = "F:\\Medibot\\json\\config.json"
+        crosswalk_path = "F:\\Medibot\\json\\crosswalk.json"
+    else:
+        # Use G: paths for other versions of Windows
+        config_path = "G:\\My Drive\\Codes\\MediCafe\\json\\config.json"
+        crosswalk_path = "G:\\My Drive\\Codes\\MediCafe\\json\\crosswalk.json"
     
     try:
         with open(config_path, 'r') as config_file:
@@ -55,8 +38,11 @@ def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..',
             crosswalk = json.load(crosswalk_file)
 
         return config, crosswalk
-    except json.JSONDecodeError as e:
-        print("Error parsing JSON file: {}".format(e))
+    except ValueError as e:
+        if isinstance(e, UnicodeDecodeError):
+            print("Error decoding JSON file: {}".format(e))
+        else:
+            print("Error parsing JSON file: {}".format(e))
         sys.exit(1)  # Exit the script due to a critical error in configuration loading
     except FileNotFoundError:
         print("One or both JSON files not found. Config: {}, Crosswalk: {}".format(config_path, crosswalk_path))
@@ -66,4 +52,30 @@ def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..',
         sys.exit(1)  # Exit the script due to a critical error in configuration loading
     except Exception as e:
         print("An unexpected error occurred while loading the configuration: {}".format(e))
-        sys.exit(1)  # Exit the script due to a critical error in configuration loading
+        sys.exit(1)  # Exit the script due to a critical error in configuration loading
+        
+# Logs messages with optional error type and claim data.
+def log(message, config=None, level="INFO", error_type=None, claim=None):
+    
+    # If config is not provided, load it
+    if config is None:
+        config, _ = load_configuration()
+    
+    # Setup logger if not already configured
+    if not logging.root.handlers:
+        local_storage_path = config['MediLink_Config'].get('local_storage_path', '.') if isinstance(config, dict) else '.'
+        log_filename = datetime.now().strftime("Log_%m%d%Y.log")
+        log_filepath = os.path.join(local_storage_path, log_filename)
+        logging.basicConfig(level=logging.INFO,
+                            format='%(asctime)s - %(levelname)s - %(message)s',
+                            filename=log_filepath,
+                            filemode='a')
+    
+    # Prepare log message
+    claim_data = " - Claim Data: {}".format(claim) if claim else ""
+    error_info = " - Error Type: {}".format(error_type) if error_type else ""
+    full_message = "{} {}{}".format(message, claim_data, error_info)
+
+    # Log the message
+    logger = logging.getLogger()
+    getattr(logger, level.lower())(full_message)

MediLink/MediLink_DataMgmt.py

@@ -1,10 +1,13 @@
 import csv
 import os
 from datetime import datetime, timedelta
-import logging
-import MediLink_837p_encoder_library
-import subprocess # BUG Currently disabled for testing.
-import logging
+import subprocess 
+
+# Need this for running Medibot and MediLink
+try:
+    import MediLink_ConfigLoader
+except ImportError:
+    from . import MediLink_ConfigLoader
 
 # Helper function to slice and strip values
 def slice_data(data, slices):
@@ -12,7 +15,15 @@ def slice_data(data, slices):
     return {key: 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):
+def parse_fixed_width_data(personal_info, insurance_info, service_info, config=None):
+    
+    # Make sure we have the right config
+    if not config:  # Checks if config is None or an empty dictionary
+        MediLink_ConfigLoader.log("No config passed to parse_fixed_width_data. Re-loading config...", level="WARNING")
+        config, _ = MediLink_ConfigLoader.load_configuration()
+    
+    config = config.get('MediLink_Config', config) # Safest config call.
+    
     # Load slice definitions from config within the MediLink_Config section
     personal_slices = config['fixedWidthSlices']['personal_slices']
     insurance_slices = config['fixedWidthSlices']['insurance_slices']
@@ -24,14 +35,15 @@ def parse_fixed_width_data(personal_info, insurance_info, service_info, config):
     parsed_data.update(slice_data(insurance_info, insurance_slices))
     parsed_data.update(slice_data(service_info, service_slices))
     
-    MediLink_837p_encoder_library.log("Successfully parsed data from segments", config, level="INFO")
+    MediLink_ConfigLoader.log("Successfully parsed data from segments", config, level="INFO")
     
     return parsed_data
 
 # Function to read fixed-width Medisoft output and extract claim data
-def read_fixed_width_data(file_path, config):
+def read_fixed_width_data(file_path):
     # Reads the fixed width data from the file and yields each patient's
     # personal, insurance, and service information.
+    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
         for line in file:
@@ -41,12 +53,21 @@ def read_fixed_width_data(file_path, config):
                 # 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_837p_encoder_library.log("Successfully read data from file: {}".format(file_path), config, level="INFO")
+                    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.
 
+# TODO (Refactor) Consider consolidating with the other read_fixed_with_data 
+def read_general_fixed_width_data(file_path, slices):
+    # handle any fixed-width data based on provided slice definitions
+    with open(file_path, 'r', encoding='utf-8') as file:
+        next(file)  # Skip the header
+        for line_number, line in enumerate(file, start=1):
+            insurance_name = {key: line[start:end].strip() for key, (start, end) in slices.items()}
+            yield insurance_name, line_number
+
 def consolidate_csvs(source_directory):
     """
     This default overwrites any existing CSV for the same day. We want this for the automated runs but want to switch through 
@@ -61,7 +82,7 @@ def consolidate_csvs(source_directory):
 
     # Check if the file already exists and log the action
     if os.path.exists(consolidated_filepath):
-        MediLink_837p_encoder_library.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))
 
     for filename in os.listdir(source_directory):
         filepath = os.path.join(source_directory, filename)
@@ -90,11 +111,11 @@ def consolidate_csvs(source_directory):
         writer = csv.writer(csvfile)
         writer.writerows(consolidated_data)
 
-    MediLink_837p_encoder_library.log("Consolidated CSVs into {}".format(consolidated_filepath))
+    MediLink_ConfigLoader.log("Consolidated CSVs into {}".format(consolidated_filepath))
     
     return consolidated_filepath
 
-def operate_winscp(operation_type, files, endpoint_config, local_storage_path):
+def operate_winscp(operation_type, files, endpoint_config, local_storage_path, config):
     """
     General function to operate WinSCP for uploading or downloading files.
 
@@ -110,7 +131,7 @@ def operate_winscp(operation_type, files, endpoint_config, local_storage_path):
         'remote_directory_up': '/remote/upload/path'
     }
 
-    operate_winscp('upload', upload_files, upload_config, 'path/to/local/storage')
+    operate_winscp('upload', upload_files, upload_config, 'path/to/local/storage', config)
 
     # Example of how to call this function for downloads
     download_config = {
@@ -118,21 +139,22 @@ def operate_winscp(operation_type, files, endpoint_config, local_storage_path):
         'remote_directory_down': '/remote/download/path'
     }
 
-    operate_winscp('download', None, download_config, 'path/to/local/storage')
+    operate_winscp('download', None, download_config, 'path/to/local/storage', config)
     """
     # Setup paths
     try:
-        winscp_path = endpoint_config['winscp_path']
+        # TODO (Easy / Config) Get this updated. ??
+        winscp_path = config['winscp_path']
     except KeyError:
         winscp_path = os.path.join(os.getcwd(), "Installers", "WinSCP-Portable", "WinSCP.com")
     except Exception as e:
         # Handle any other exceptions here
-        print("An error occurred:", e)
+        print("An error occurred while running WinSCP:", e)
         winscp_path = None
         
     if not os.path.isfile(winscp_path):
-        logging.error("WinSCP.com not found at {}".format(winscp_path))
-        return False
+        MediLink_ConfigLoader.log("WinSCP.com not found at {}".format(winscp_path))
+        return []
 
     # Setup logging
     log_filename = "winscp_upload.log" if operation_type == "upload" else "winscp_download.log"
@@ -154,7 +176,7 @@ def operate_winscp(operation_type, files, endpoint_config, local_storage_path):
     ]
 
     # Add commands to WinSCP script
-    # BUG We really need to fix this path situation.
+    # BUG (Low SFTP) We really need to fix this path situation.
     #  Unfortunately, this just needs to be a non-spaced path because WinSCP can't
     #  handle the spaces. Also, Windows won't let me use shutil to move the files out of G:\ into C:\ and it it wants an administrator security 
     #  check or verification thing for me to even move the file by hand so that doesn't work either. 
@@ -162,28 +184,57 @@ def operate_winscp(operation_type, files, endpoint_config, local_storage_path):
     if operation_type == "upload":
         for file_path in files:
             normalized_path = os.path.normpath(file_path)
-            command.append("put \"{}\"".format(normalized_path))
+            command.append("put {}".format(normalized_path))
     else:
         command.append('get *')  # Adjust pattern as needed
 
     command += ['close', 'exit']
 
-    # Execute command
-    # process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False)
-    # stdout, stderr = process.communicate()
+    # Check if TestMode is enabled in the configuration
+    if config.get("MediLink_Config", {}).get("TestMode", True):
+        # 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.")
+        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
+    else:
+        # TestMode is not enabled, execute the command
+        process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False)
+        stdout, stderr = process.communicate()
     
-    if True: #process.returncode == 0:
-        print("WINSCP IS CURRENTLY DISABLED FOR TESTING.") # BUG
-        logging.info("Files {}ed successfully.".format(operation_type))
-        # BUG This return code is a little trigger happy.
-        # BUG If the WinSCP command specifies the correct download path, this might not be necessary
-        # move_downloaded_files(local_storage_path)
-        return True
+    if process.returncode == 0: # BUG Does this work as intended?
+        MediLink_ConfigLoader.log("WinSCP {} attempted.".format(operation_type))
+        # Construct a list of downloaded files if operation_type is 'download'
+        if operation_type == 'download':
+            downloaded_files = []
+            for root, dirs, files in os.walk(local_storage_path):
+                for file in files:
+                    downloaded_files.append(os.path.join(root, file))
+            return downloaded_files
+        
+        if operation_type == 'upload':
+            # Return a list of uploaded files
+            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("Failed to upload file: {} does not exist.".format(normalized_path))
+            return uploaded_files
     else:
-        logging.error("Failed to {} files. Details: {}".format(operation_type, stderr.decode('utf-8')))
-        return False
+        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
@@ -195,7 +246,7 @@ def remove_blank_rows_from_csv(csv_file_path):
         writer.writerows(rows)
 
 def list_chart_numbers_in_existing_file(filepath):
-    """Lists the Chart Numbers contained in an existing CSV file."""
+    # Lists the Chart Numbers contained in an existing CSV file.
     chart_numbers = []
     with open(filepath, 'r', newline='') as csvfile:
         reader = csv.reader(csvfile)
@@ -203,4 +254,5 @@ def list_chart_numbers_in_existing_file(filepath):
         for row in reader:
             if len(row) > 2:  # Assuming Chart Number is in the 3rd column
                 chart_numbers.append(row[2])
-    return chart_numbers
+    return chart_numbers
+"""