medicafe 0.240415.1__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

@@ -0,0 +1,81 @@
+import os
+import json
+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
+"""
+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.
+    """
+    # 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:
+            config = json.load(config_file, object_pairs_hook=OrderedDict)
+            if 'MediLink_Config' not in config:
+                raise KeyError("MediLink_Config key is missing from the loaded configuration.")
+            # MediLink_config = config['MediLink_Config']
+
+        with open(crosswalk_path, 'r') as crosswalk_file:
+            crosswalk = json.load(crosswalk_file)
+
+        return config, crosswalk
+    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))
+        sys.exit(1)  # Exit the script due to a critical error in configuration loading
+    except KeyError as e:
+        print("Critical configuration is missing: {}".format(e))
+        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
+        
+# 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

@@ -0,0 +1,258 @@
+import csv
+import os
+from datetime import datetime, timedelta
+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):
+    # Convert slices list to a tuple for slicing operation
+    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=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']
+    service_slices = config['fixedWidthSlices']['service_slices']
+
+    # Parse each segment
+    parsed_data = {}
+    parsed_data.update(slice_data(personal_info, personal_slices))
+    parsed_data.update(slice_data(insurance_info, insurance_slices))
+    parsed_data.update(slice_data(service_info, service_slices))
+    
+    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):
+    # 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:
+            stripped_line = line.strip()
+            if stripped_line:  # Only process non-empty lines
+                lines_buffer.append(stripped_line)
+                # Once we have 3 lines of data, yield them as a patient record
+                if len(lines_buffer) == 3:
+                    personal_info, insurance_info, service_info = lines_buffer
+                    MediLink_ConfigLoader.log("Successfully read data from file: {}".format(file_path), level="INFO")
+                    yield personal_info, insurance_info, service_info
+                    lines_buffer.clear()  # Reset buffer for the next patient record
+            # If the line is blank but we have already started collecting a patient record,
+            # we continue without resetting the buffer, effectively skipping blank lines.
+
+# 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 
+    the user interaction option if we're running interactive. This has not been implemented, but the helper function exists.
+    """
+    today = datetime.now()
+    consolidated_filename = today.strftime("ERA_%m%d%y.csv")
+    consolidated_filepath = os.path.join(source_directory, consolidated_filename)
+
+    consolidated_data = []
+    header_saved = False
+
+    # Check if the file already exists and log the action
+    if os.path.exists(consolidated_filepath):
+        MediLink_ConfigLoader.log("The file {} already exists. It will be overwritten.".format(consolidated_filename))
+
+    for filename in os.listdir(source_directory):
+        filepath = os.path.join(source_directory, filename)
+        if not filepath.endswith('.csv') or os.path.isdir(filepath) or filepath == consolidated_filepath:
+            continue  # Skip non-CSV files, directories, and the target consolidated file itself
+
+        # Check if the file was created within the last day
+        modification_time = datetime.fromtimestamp(os.path.getmtime(filepath))
+        if modification_time < today - timedelta(days=1):
+            continue  # Skip files not modified in the last day
+
+        # Read and append data from each CSV
+        with open(filepath, 'r', newline='') as csvfile:
+            reader = csv.reader(csvfile)
+            header = next(reader)  # Assumes all CSV files have the same header
+            if not header_saved:  # Save header from the first file
+                consolidated_data.append(header)
+                header_saved = True
+            consolidated_data.extend(row for row in reader)
+
+        # Delete the source file after its contents have been added to the consolidation list
+        os.remove(filepath)
+
+    # Write consolidated data to a new or existing CSV file, overwriting it if it exists
+    with open(consolidated_filepath, 'w', newline='') as csvfile:
+        writer = csv.writer(csvfile)
+        writer.writerows(consolidated_data)
+
+    MediLink_ConfigLoader.log("Consolidated CSVs into {}".format(consolidated_filepath))
+    
+    return consolidated_filepath
+
+def operate_winscp(operation_type, files, endpoint_config, local_storage_path, config):
+    """
+    General function to operate WinSCP for uploading or downloading files.
+
+    :param operation_type: 'upload' or 'download'
+    :param files: List of files to upload or pattern for files to download.
+    :param endpoint_config: Dictionary containing endpoint configuration.
+    :param local_storage_path: Base local storage path for logs and files.
+
+    # Example of how to call this function for uploads
+    upload_files = ['path/to/local/file1.txt', 'path/to/local/file2.txt']
+    upload_config = {
+        'session_name': 'MySession',
+        'remote_directory_up': '/remote/upload/path'
+    }
+
+    operate_winscp('upload', upload_files, upload_config, 'path/to/local/storage', config)
+
+    # Example of how to call this function for downloads
+    download_config = {
+        'session_name': 'MySession',
+        'remote_directory_down': '/remote/download/path'
+    }
+
+    operate_winscp('download', None, download_config, 'path/to/local/storage', config)
+    """
+    # Setup paths
+    try:
+        # 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 while running WinSCP:", e)
+        winscp_path = None
+        
+    if not os.path.isfile(winscp_path):
+        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"
+    winscp_log_path = os.path.join(local_storage_path, log_filename)
+
+    # Session and directory setup
+    session_name = endpoint_config.get('session_name', '')
+    remote_directory = endpoint_config['remote_directory_up'] if operation_type == "upload" else endpoint_config['remote_directory_down']
+
+    # Command building
+    command = [
+        winscp_path,
+        '/log=' + winscp_log_path,
+        '/loglevel=1',
+        '/command',
+        'open {}'.format(session_name),
+        'cd /',
+        'cd {}'.format(remote_directory)
+    ]
+
+    # Add commands to WinSCP script
+    # 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. 
+    #  command.append("put {}".format("C:\\Z_optumedi_04161742.txt"))
+    if operation_type == "upload":
+        for file_path in files:
+            normalized_path = os.path.normpath(file_path)
+            command.append("put {}".format(normalized_path))
+    else:
+        command.append('get *')  # Adjust pattern as needed
+
+    command += ['close', 'exit']
+
+    # 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 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:
+        MediLink_ConfigLoader.log("Failed to {} files. Details: {}".format(operation_type, stderr.decode('utf-8')))
+        return []  # Return empty list to indicate failure. BUG check to make sure this doesn't break something else.
+
+# UNUSED CSV Functions
+"""
+def remove_blank_rows_from_csv(csv_file_path):
+    with open(csv_file_path, 'r') as csv_file:
+        # Read the CSV file and filter out any empty rows
+        rows = [row for row in csv.reader(csv_file) if any(field.strip() for field in row)]
+    
+    # Write the filtered rows back to the CSV file
+    with open(csv_file_path, 'w', newline='') as csv_file:
+        writer = csv.writer(csv_file)
+        writer.writerows(rows)
+
+def list_chart_numbers_in_existing_file(filepath):
+    # Lists the Chart Numbers contained in an existing CSV file.
+    chart_numbers = []
+    with open(filepath, 'r', newline='') as csvfile:
+        reader = csv.reader(csvfile)
+        next(reader)  # Skip header
+        for row in reader:
+            if len(row) > 2:  # Assuming Chart Number is in the 3rd column
+                chart_numbers.append(row[2])
+    return chart_numbers
+"""