medicafe 0.240419.2__py3-none-any.whl → 0.240613.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,139 @@
+# Unused archive backup. This has been superceded by API_v2
+
+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)