medicafe 0.240716.2__py3-none-any.whl → 0.240925.9__py3-none-any.whl

MediLink/MediLink_API_v3.py

@@ -1,14 +1,19 @@
-import time
-import requests
-import yaml
-import json
-import os
+# MediLink_API_v3.py
+import time, requests, yaml, json, os, traceback
 
 try:
     from MediLink import MediLink_ConfigLoader
 except ImportError:
     import MediLink_ConfigLoader
 
+"""
+TODO At some point it might make sense to test their acknoledgment endpoint. body is transactionId.
+This API is used to extract the claim acknowledgement details for the given transactionid which was 
+generated for 837 requests in claim submission process. Claims Acknowledgement (277CA) will provide 
+a status of claim-level acknowledgement of all claims received in the front-end processing system and 
+adjudication system.
+"""
+
 class ConfigLoader:
     @staticmethod
     def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..', 'json', 'config.json'), 
@@ -56,18 +61,37 @@ class TokenCache:
 
     def get(self, endpoint_name, current_time):
         token_info = self.tokens.get(endpoint_name, {})
-        if token_info and token_info['expires_at'] > current_time:
-            return token_info['access_token']
+        if token_info:
+            expires_at = token_info['expires_at']
+            # Log cache hit and expiration time
+            log_message = "Token for {} expires at {}. Current time: {}".format(endpoint_name, expires_at, current_time)
+            MediLink_ConfigLoader.log(log_message, level="DEBUG")
+
+            if expires_at > current_time:
+                return token_info['access_token']
+
+        # Log cache miss
+        log_message = "No valid token found for {}".format(endpoint_name)
+        MediLink_ConfigLoader.log(log_message, level="INFO")
+
         return None
 
     def set(self, endpoint_name, access_token, expires_in, current_time):
-        # Ensure types are correct
         current_time = ensure_numeric(current_time)
         expires_in = ensure_numeric(expires_in)
-        
+
+        # Log the expires_in value to debug
+        log_message = "Token expires in: {} seconds for {}".format(expires_in, endpoint_name)
+        MediLink_ConfigLoader.log(log_message, level="INFO")
+
+        # Adjust expiration time by subtracting a buffer of 120 seconds
+        expires_at = current_time + expires_in - 120
+        log_message = "Setting token for {}. Expires at: {}".format(endpoint_name, expires_at)
+        MediLink_ConfigLoader.log(log_message, level="INFO")
+
         self.tokens[endpoint_name] = {
             'access_token': access_token,
-            'expires_at': current_time + expires_in - 120
+            'expires_at': expires_at
         }
 
 class BaseAPIClient:
@@ -87,12 +111,16 @@ class APIClient(BaseAPIClient):
         super().__init__(config)
 
     def get_access_token(self, endpoint_name):
+        MediLink_ConfigLoader.log("[Get Access Token] Called for {}".format(endpoint_name), level="DEBUG")
         current_time = time.time()
         cached_token = self.token_cache.get(endpoint_name, current_time)
+        
         if cached_token:
-            MediLink_ConfigLoader.log("Using cached token for endpoint: {}".format(endpoint_name), level="INFO")
+            expires_at = self.token_cache.tokens[endpoint_name]['expires_at']
+            MediLink_ConfigLoader.log("Cached token expires at {}".format(expires_at), level="DEBUG")
             return cached_token
-
+        
+        # If no valid token, fetch a new one
         endpoint_config = self.config['MediLink_Config']['endpoints'][endpoint_name]
         token_url = endpoint_config['token_url']
         data = {
@@ -114,68 +142,228 @@ class APIClient(BaseAPIClient):
         expires_in = token_data.get('expires_in', 3600)
 
         self.token_cache.set(endpoint_name, access_token, expires_in, current_time)
-        MediLink_ConfigLoader.log("Obtained new token for endpoint: {}".format(endpoint_name), level="INFO")
+        MediLink_ConfigLoader.log("Obtained NEW token for endpoint: {}".format(endpoint_name), level="INFO")
         return access_token
 
     def make_api_call(self, endpoint_name, call_type, url_extension="", params=None, data=None, headers=None):
         token = self.get_access_token(endpoint_name)
+        if token:
+            MediLink_ConfigLoader.log("[Make API Call] Token found for {}".format(endpoint_name), level="DEBUG")
+        else:
+            MediLink_ConfigLoader.log("[Make API Call] No token obtained for {}".format(endpoint_name), level="ERROR")
+            raise ValueError("No access token available for endpoint: {}".format(endpoint_name))
+
         if headers is None:
             headers = {}
         headers.update({'Authorization': 'Bearer {}'.format(token), 'Accept': 'application/json'})
-        url = self.config['MediLink_Config']['endpoints'][endpoint_name]['api_url'] + url_extension
-        
-        # Debug: Print request details
-        # print("Request URL: {}".format(url))
-        # print("Request Headers: {}".format(headers))
-        # print("Request Params: {}".format(params))
-        # print("Request Data: {}".format(data))
-        
-        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")
+        base_url = self.config['MediLink_Config']['endpoints'][endpoint_name]['api_url']
+        url = base_url + url_extension
 
-        if response.status_code >= 400:
-            error_message = "Error {}: {}".format(response.status_code, response.text)
-            MediLink_ConfigLoader.log(error_message, level="ERROR")
-            response.raise_for_status()
+        try:
+            # Make the API call based on call_type
+            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: {}".format(call_type))
 
-        return response.json()
+            masked_headers = headers.copy()
+            if 'Authorization' in masked_headers:
+                masked_headers['Authorization'] = 'Bearer ***'
 
-def fetch_payer_name_from_api(payer_id, config, primary_endpoint='AVAILITY'):
-    client = APIClient()
-    config, _ = MediLink_ConfigLoader.load_configuration()
-    endpoints = config['MediLink_Config']['endpoints']
+            # Raise an HTTPError if the response was unsuccessful
+            response.raise_for_status()
 
-    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())
+            return response.json()
+
+        except requests.exceptions.HTTPError as http_err:
+            # If http_err.response is None, handle it separately
+            if http_err.response is None:
+                log_message = (
+                    "HTTPError with no response. "
+                    "URL: {url}, "
+                    "Method: {method}, "
+                    "Params: {params}, "
+                    "Data: {data}, "
+                    "Headers: {masked_headers}, "
+                    "Error: {error}"
+                ).format(
+                    url=url,
+                    method=call_type,
+                    params=params,
+                    data=data,
+                    masked_headers=masked_headers,
+                    error=str(http_err)
+                )
+                MediLink_ConfigLoader.log(log_message, level="ERROR")
+            else:
+                # Extract status code and full response content
+                status_code = http_err.response.status_code
+                try:
+                    # Try to log the JSON content if available
+                    response_content = http_err.response.json()
+                except ValueError:
+                    # Fallback to raw text if JSON decoding fails
+                    response_content = http_err.response.text
+
+                log_message = (
+                    "HTTPError: Status Code: {status}, "
+                    "URL: {url}, "
+                    "Method: {method}, "
+                    "Params: {params}, "
+                    "Data: {data}, "
+                    "Headers: {masked_headers}, "
+                    "Response Content: {content}"
+                ).format(
+                    status=status_code,
+                    url=url,
+                    method=call_type,
+                    params=params,
+                    data=data,
+                    masked_headers=masked_headers,
+                    content=response_content
+                )
+                MediLink_ConfigLoader.log(log_message, level="ERROR")
+            raise
+
+        except requests.exceptions.RequestException as req_err:
+            # Log connection-related issues or other request exceptions
+            log_message = (
+                "RequestException: No response received. "
+                "URL: {url}, "
+                "Method: {method}, "
+                "Params: {params}, "
+                "Data: {data}, "
+                "Headers: {masked_headers}, "
+                "Error: {error}"
+            ).format(
+                url=url,
+                method=call_type,
+                params=params,
+                data=data,
+                masked_headers=masked_headers,
+                error=str(req_err)
+            )
+            MediLink_ConfigLoader.log(log_message, level="ERROR")
+            raise
+
+        except Exception as e:
+            # Capture traceback for unexpected exceptions
+            tb = traceback.format_exc()
+            log_message = (
+                "Unexpected error: {error}. "
+                "URL: {url}, "
+                "Method: {method}, "
+                "Params: {params}, "
+                "Data: {data}, "
+                "Headers: {masked_headers}. "
+                "Traceback: {traceback}"
+            ).format(
+                error=str(e),
+                url=url,
+                method=call_type,
+                params=params,
+                data=data,
+                masked_headers=masked_headers,
+                traceback=tb
+            )
+            MediLink_ConfigLoader.log(log_message, level="ERROR")
+            raise
+
+def fetch_payer_name_from_api(client, payer_id, config, primary_endpoint='AVAILITY'):
+    """
+    Fetches the payer name using the provided APIClient instance.
+
+    :param client: An instance of APIClient
+    :param payer_id: The payer ID to fetch
+    :param primary_endpoint: The primary endpoint to use
+    :return: The payer name if found
+    """
+    # Ensure client is an instance of APIClient
+    if not isinstance(client, APIClient):
+        error_message = "Invalid client provided. Expected an instance of APIClient."
+        print(error_message)
+        MediLink_ConfigLoader.log(error_message, level="ERROR")
+        exit(1)  # Exit the script
+    
+    # BUG Force AVAILITY until I can get a payer-list api from any of the other endpoints. 
+    MediLink_ConfigLoader.log("[Fetch payer name from API] Overriding {} with AVAILITY.".format(primary_endpoint), level="DEBUG")
+    primary_endpoint = 'AVAILITY'
+    
+    try:
+        endpoints = config['MediLink_Config']['endpoints']
+    except KeyError as e:
+        error_message = "Configuration loading error: Missing key {0}".format(e)
+        print(error_message)
+        MediLink_ConfigLoader.log(error_message, level="CRITICAL")
+        # Attempt to reload configuration if key is missing
+        config, _ = MediLink_ConfigLoader.load_configuration()
+        endpoints = config['MediLink_Config']['endpoints']  # Re-attempt to access endpoints
+    
+    # Define endpoint rotation logic
+    endpoint_order = ([primary_endpoint] + 
+                      [endpoint for endpoint in endpoints if endpoint != primary_endpoint]
+                      if primary_endpoint in endpoints else list(endpoints.keys()))
 
     for endpoint_name in endpoint_order:
         try:
-            response = client.make_api_call(endpoint_name, 'GET', config['MediLink_Config']['endpoints'][endpoint_name].get('payer_list_endpoint', '/availity-payer-list'), {'payerId': payer_id})
+            endpoint_url = endpoints[endpoint_name].get('payer_list_endpoint', '/availity-payer-list')
+            response = client.make_api_call(endpoint_name, 'GET', endpoint_url, {'payerId': payer_id})
+            
+            # Check if response exists
+            if not response:
+                log_message = "No response from {0} for Payer ID {1}".format(endpoint_name, payer_id)
+                print(log_message)
+                MediLink_ConfigLoader.log(log_message, level="ERROR")
+                continue
+            
+            # Check if the status code is not 200
+            status_code = response.get('statuscode', 200)
+            if status_code != 200:
+                log_message = "Invalid response status code {0} from {1} for Payer ID {2}. Message: {3}".format(
+                    status_code, endpoint_name, payer_id, response.get('message', 'No message'))
+                print(log_message)
+                MediLink_ConfigLoader.log(log_message, level="ERROR")
+                continue
+            
+            # Extract payers and validate the response structure
             payers = response.get('payers', [])
-            if payers:
-                payer_name = payers[0].get('displayName', payers[0].get('name'))
-                MediLink_ConfigLoader.log("Successfully found payer at {} for ID {}: {}".format(endpoint_name, payer_id, payer_name), level="INFO")
-                return payer_name
-            else:
-                MediLink_ConfigLoader.log("No payer found at {} for ID: {}. Trying next available endpoint.".format(endpoint_name, payer_id), level="INFO")
+            if not payers:
+                log_message = "No payer found at {0} for ID {1}. Response: {2}".format(endpoint_name, payer_id, response)
+                print(log_message)
+                MediLink_ConfigLoader.log(log_message, level="INFO")
+                continue
+            
+            # Extract the payer name from the first payer in the list
+            payer_name = payers[0].get('displayName') or payers[0].get('name')
+            if not payer_name:
+                log_message = "Payer name not found in the response from {0} for ID {1}. Response: {2}".format(
+                    endpoint_name, payer_id, response)
+                print(log_message)
+                MediLink_ConfigLoader.log(log_message, level="ERROR")
+                continue
+            
+            # Log successful payer retrieval
+            log_message = "Found payer at {0} for ID {1}: {2}".format(endpoint_name, payer_id, payer_name)
+            MediLink_ConfigLoader.log(log_message, level="INFO")
+            return payer_name
+        
         except Exception as e:
-            MediLink_ConfigLoader.log("API call to {} failed: {}".format(endpoint_name, e), level="ERROR")
+            error_message = "Error calling {0} for Payer ID {1}. Exception: {2}".format(endpoint_name, payer_id, e)
+            MediLink_ConfigLoader.log(error_message, level="INFO")
 
-    error_message = "All endpoints exhausted for Payer ID {}.".format(payer_id)
-    MediLink_ConfigLoader.log(error_message, level="CRITICAL")
-    raise ValueError(error_message)
+    # If all endpoints fail
+    final_error_message = "All endpoints exhausted for Payer ID {0}.".format(payer_id)
+    print(final_error_message)
+    MediLink_ConfigLoader.log(final_error_message, level="CRITICAL")
+    raise ValueError(final_error_message)
 
 def get_claim_summary_by_provider(client, tin, first_service_date, last_service_date, payer_id, get_standard_error='false'):
-    endpoint_name = 'UHCApi'
+    endpoint_name = 'UHCAPI'
     url_extension = client.config['MediLink_Config']['endpoints'][endpoint_name]['additional_endpoints']['claim_summary_by_provider']
     headers = {
         'tin': tin,
@@ -188,7 +376,7 @@ def get_claim_summary_by_provider(client, tin, first_service_date, last_service_
     return client.make_api_call(endpoint_name, 'GET', url_extension, params=None, data=None, headers=headers)
 
 def get_eligibility(client, payer_id, provider_last_name, search_option, date_of_birth, member_id, npi):
-    endpoint_name = 'UHCApi'
+    endpoint_name = 'UHCAPI'
     url_extension = client.config['MediLink_Config']['endpoints'][endpoint_name]['additional_endpoints']['eligibility']
     url_extension = url_extension + '?payerID={}&providerLastName={}&searchOption={}&dateOfBirth={}&memberId={}&npi={}'.format(
         payer_id, provider_last_name, search_option, date_of_birth, member_id, npi)
@@ -210,7 +398,7 @@ def get_eligibility_v3(client, payer_id, provider_last_name, search_option, date
     if payer_id not in valid_payer_ids:
         raise ValueError("Invalid payer_id: {}. Must be one of: {}".format(payer_id, ", ".join(valid_payer_ids)))
     
-    endpoint_name = 'UHCApi'
+    endpoint_name = 'UHCAPI'
     url_extension = client.config['MediLink_Config']['endpoints'][endpoint_name]['additional_endpoints']['eligibility_v3']
     
     # Construct request body
@@ -253,15 +441,101 @@ def get_eligibility_v3(client, payer_id, provider_last_name, search_option, date
 
     return client.make_api_call(endpoint_name, 'POST', url_extension, params=None, data=body)
 
+def is_test_mode(client, body, endpoint_type):
+    """
+    Checks if Test Mode is enabled in the client's configuration and simulates the response if it is.
+
+    :param client: An instance of APIClient
+    :param body: The intended request body
+    :param endpoint_type: The type of endpoint being accessed ('claim_submission' or 'claim_details')
+    :return: A dummy response simulating the real API call if Test Mode is enabled, otherwise None
+    """
+    if client.config.get("MediLink_Config", {}).get("TestMode", True):
+        print("Test Mode is enabled! API Call not executed.")
+        print("\nIntended request body:", body)
+        MediLink_ConfigLoader.log("Test Mode is enabled! Simulating 1 second delay for API response for {}.".format(endpoint_type), level="INFO")
+        time.sleep(1)
+        MediLink_ConfigLoader.log("Intended request body: {}".format(body), level="INFO")
+
+        if endpoint_type == 'claim_submission':
+            dummy_response = {
+                "transactionId": "CS07180420240328013411240",  # This is the tID for the sandbox Claim Acknowledgement endpoint.
+                "x12ResponseData": "ISA*00* *00* *ZZ*TEST1234567890 *33*TEST *210101*0101*^*00501*000000001*0*P*:~GS*HC*TEST1234567890*TEST*20210101*0101*1*X*005010X222A1~ST*837*000000001*005010X222A1~BHT*0019*00*00001*20210101*0101*CH~NM1*41*2*TEST SUBMITTER*****46*TEST~PER*IC*TEST CONTACT*TE*1234567890~NM1*40*2*TEST RECEIVER*****46*TEST~HL*1**20*1~NM1*85*2*TEST PROVIDER*****XX*1234567890~N3*TEST ADDRESS~N4*TEST CITY*TEST STATE*12345~REF*EI*123456789~PER*IC*TEST PROVIDER*TE*1234567890~NM1*87*2~N3*TEST ADDRESS~N4*TEST CITY*TEST STATE*12345~HL*2*1*22*0~SBR*P*18*TEST GROUP******CI~NM1*IL*1*TEST PATIENT****MI*123456789~N3*TEST ADDRESS~N4*TEST CITY*TEST STATE*12345~DMG*D8*19800101*M~NM1*PR*2*TEST INSURANCE*****PI*12345~CLM*TESTCLAIM*100***12:B:1*Y*A*Y*Y*P~REF*D9*TESTREFERENCE~HI*ABK:TEST~NM1*DN*1*TEST DOCTOR****XX*1234567890~LX*1~SV1*HC:TEST*100*UN*1***1~DTP*472*RD8*20210101-20210101~REF*6R*TESTREFERENCE~SE*30*000000001~GE*1*1~IEA*1*000000001~",
+                "responseType": "dummy_response_837999",
+                "message": "Test Mode: Claim validated and sent for further processing"
+            }
+        elif endpoint_type == 'claim_details':
+            dummy_response = {
+                "responseType": "dummy_response_277CA-CH",
+                "x12ResponseData": "ISA*00* *00*  *ZZ*841162764 *ZZ*UB920086 *240318*0921*^*00501*000165687*0*T*:~GS*HN*841162764*UB920086*20240318*0921*0165687*X*005010X214~ST*277*000000006*005010X214~…………….. SE*116*000000006~GE*1*0165687~IEA*1*000165687~",
+                "statuscode": "000",
+                "message:": ""
+            }
+        return dummy_response
+    return None
+
+def submit_uhc_claim(client, x12_request_data):
+    """
+    Submits a UHC claim and retrieves the claim acknowledgement details.
+
+    This function first submits the claim using the provided x12 837p data. If the client is in Test Mode, 
+    it returns a simulated response. If Test Mode is not enabled, it submits the claim and then retrieves 
+    the claim acknowledgement details using the transaction ID from the initial response.
+
+    :param client: An instance of APIClient
+    :param x12_request_data: The x12 837p data as a string
+    :return: The final response containing the claim acknowledgement details or a dummy response if in Test Mode
+    """
+    endpoint_name = 'UHCAPI'
+    claim_submission_url = client.config['MediLink_Config']['endpoints'][endpoint_name]['additional_endpoints']['claim_submission']
+    claim_details_url = client.config['MediLink_Config']['endpoints'][endpoint_name]['additional_endpoints']['claim_details']
+
+    # Headers for the request
+    headers = {'Content-Type': 'application/json'} 
+
+    # Request body for claim submission
+    claim_body = {'x12RequestData': x12_request_data}
+
+    # Check if Test Mode is enabled and return simulated response if so
+    test_mode_response = is_test_mode(client, claim_body, 'claim_submission')
+    if test_mode_response:
+        return test_mode_response
+    
+    # Make the API call to submit the claim
+    try:
+        submission_response = client.make_api_call(endpoint_name, 'POST', claim_submission_url, data=claim_body, headers=headers)
+        
+        # Extract the transaction ID from the submission response
+        transaction_id = submission_response.get('transactionId')
+        if not transaction_id:
+            raise ValueError("transactionId not found in the submission response")
+        
+        # Prepare the request body for the claim acknowledgement retrieval
+        acknowledgement_body = {'transactionId': transaction_id}
+
+        # Check if Test Mode is enabled and return simulated response if so
+        test_mode_response = is_test_mode(client, acknowledgement_body, 'claim_details')
+        if test_mode_response:
+            return test_mode_response
+
+        # Make the API call to retrieve the claim acknowledgement details
+        acknowledgement_response = client.make_api_call(endpoint_name, 'POST', claim_details_url, data=acknowledgement_body, headers=headers)
+        return acknowledgement_response
+
+    except Exception as e:
+        print("Error during claim processing: {}".format(e))
+        raise
+
 if __name__ == "__main__":
     client = APIClient()
     
     # Define a configuration to enable or disable tests
     test_config = {
-        'test_fetch_payer_name': False,
+        'test_fetch_payer_name': True,
         'test_claim_summary': False,
         'test_eligibility': False,
-        'test_eligibility_v3': True,
+        'test_eligibility_v3': False,
+        'test_claim_submission': False,
     }
     
     try:
@@ -271,10 +545,10 @@ if __name__ == "__main__":
         if test_config.get('test_fetch_payer_name', False):
             try:
                 for case in api_test_cases:
-                    payer_name = fetch_payer_name_from_api(case['payer_id'], client.config)
-                    print("TEST API: Payer Name: {}".format(payer_name))
+                    payer_name = fetch_payer_name_from_api(client, case['payer_id'], client.config)
+                    print("*** TEST API: Payer Name: {}".format(payer_name))
             except Exception as e:
-                print("TEST API: Error in Fetch Payer Name Test: {}".format(e))
+                print("*** TEST API: Error in Fetch Payer Name Test: {}".format(e))
         
         # Test 2: Get Claim Summary
         if test_config.get('test_claim_summary', False):
@@ -321,5 +595,16 @@ if __name__ == "__main__":
             except Exception as e:
                 print("Error in getting eligibility for {}: {}".format(patient['provider_last_name'], e))
         """
+        # Test 5: UHC Claim Submission
+        if test_config.get('test_claim_submission', False):
+            try:
+                x12_request_data = (
+                    "ISA*00* *00* *ZZ*BRT219991205 *33*87726 *170417*1344*^*00501*019160001*0*P*:~GS*HC*BRT219991205*B2BRTA*20170417*134455*19160001*X*005010X222A1~ST*837*000000001*005010X222A1~BHT*0019*00*00001*20170417*134455*CH~NM1*41*2*B00099999819*****46*BB2B~PER*IC*NO NAME*TE*1234567890~NM1*40*2*TIGER*****46*87726~HL*1**20*1~NM1*85*2*XYZ ADDRESS*****XX*1073511762~N3*123 CITY#680~N4*STATE*TG*98765~REF*EI*943319804~PER*IC*XYZ ADDRESS*TE*8008738385*TE*9142862043*FX*1234567890~NM1*87*2~N3*PO BOX 277500~N4*STATE*TS*303847000~HL*2*1*22*0~SBR*P*18*701648******CI~NM1*IL*1*FNAME*LNAME****MI*00123456789~N3*2020 CITY~N4*STATE*TG*80001~DMG*D8*19820220*M~NM1*PR*2*PROVIDER XYZ*****PI*87726~\nCLM*TOSRTA-SPL1*471***12:B:1*Y*A*Y*Y*P~REF*D9*H4HZMH0R4P0104~HI*ABK:Z12~NM1*DN*1*DN*SKO****XX*1255589300~LX*1~SV1*HC:73525*471*UN*1***1~DTP*472*RD8*0190701-20190701~REF*6R*2190476543Z1~SE*30*000000001~GE*1*19160001~IEA*1*019160001~"
+                )
+                response = submit_uhc_claim(client, x12_request_data)
+                print("\nTEST API: Claim Submission Response:\n", response)
+            except Exception as e:
+                print("\nTEST API: Error in Claim Submission Test:\n", e)
+    
     except Exception as e:
-        print("TEST API: Unexpected Error: {}".format(e))
+        print("TEST API: Unexpected Error: {}".format(e))

MediLink/MediLink_APIs.py

@@ -1,7 +1,6 @@
 # Unused archive backup. This has been superceded by API_v2
 
-import time
-import requests
+import time, requests
 try:
     from MediLink import MediLink_ConfigLoader
 except ImportError:

MediLink/MediLink_ClaimStatus.py

@@ -1,4 +1,6 @@
+# MediLink_ClaimStatus.py
 from datetime import datetime, timedelta
+import os
 import MediLink_API_v3
 
 try:
@@ -19,7 +21,7 @@ start_date_str = start_date.strftime('%m/%d/%Y')
 billing_provider_tin = config['MediLink_Config'].get('billing_provider_tin')
 
 # Define the list of payer_id's to iterate over
-payer_ids = ['87726']  # Default value
+payer_ids = ['87726']  # Default value, getting a bad request error when trying to get all payer_ids.
 # Allowed payer id's for UHC
 # payer_ids = ['87726', '03432', '96385', '95467', '86050', '86047', '95378', '06111', '37602']
 
@@ -27,19 +29,23 @@ payer_ids = ['87726']  # Default value
 client = MediLink_API_v3.APIClient()
 
 # Function to process and display the data in a compact, tabular format
-def display_claim_summary(claim_summary, payer_id):
+def display_claim_summary(claim_summary, payer_id, output_file):
     claims = claim_summary.get('claims', [])
     
     # Display header
     header = "Payer ID: {} | Start Date: {} | End Date: {}".format(payer_id, start_date_str, end_date_str)
     print(header)
+    output_file.write(header + "\n")  # Write header to the output file
     print("=" * len(header))
+    output_file.write("=" * len(header) + "\n")  # Write separator to the output file
 
     # Table header
     table_header = "{:<10} | {:<10} | {:<20} | {:<6} | {:<6} | {:<7} | {:<7} | {:<7} | {:<7}".format(
         "Claim #", "Status", "Patient", "Proc.", "Serv.", "Allowed", "Paid", "Pt Resp", "Charged")
     print(table_header)
+    output_file.write(table_header + "\n")  # Write table header to the output file
     print("-" * len(table_header))
+    output_file.write("-" * len(table_header) + "\n")  # Write separator to the output file
 
     # Process each claim and display it in a compact format
     claims_dict = {}
@@ -90,6 +96,7 @@ def display_claim_summary(claim_summary, payer_id):
                     claim_data['total_patient_responsibility_amount'], claim_data['total_charged_amount']
                 )
                 print(table_row)
+                output_file.write(table_row + "\n")  # Write each row to the output file
 
                 if claim_data['total_paid_amount'] == '0.00':
                     for xwalk in claim_data['claim_xwalk_data']:
@@ -109,6 +116,7 @@ def display_claim_summary(claim_summary, payer_id):
                         claim_data['total_patient_responsibility_amount'], claim_data['total_charged_amount']
                     )
                     print(table_row + " (Duplicate with different data)")
+                    output_file.write(table_row + " (Duplicate with different data)\n")  # Write each row to the output file
 
                     if claim_data['total_paid_amount'] == '0.00':
                         for xwalk in claim_data['claim_xwalk_data']:
@@ -128,6 +136,7 @@ def display_claim_summary(claim_summary, payer_id):
                 claim_data['total_patient_responsibility_amount'], claim_data['total_charged_amount']
             )
             print(table_row)
+            output_file.write(table_row + "\n")  # Write each row to the output file
 
             if claim_data['total_paid_amount'] == '0.00':
                 for xwalk in claim_data['claim_xwalk_data']:
@@ -138,7 +147,13 @@ def display_claim_summary(claim_summary, payer_id):
                     clmIcnSufxCd = xwalk['clmIcnSufxCd']  # String: e.g., "01"
                     print("  507: {} ({}) | 508: {} ({}) | ICN Suffix: {}".format(clm507Cd, clm507CdDesc, clm508Cd, clm508CdDesc, clmIcnSufxCd))
 
-# Loop through each payer_id and call the API, then display the claim summary
-for payer_id in payer_ids:
-    claim_summary = MediLink_API_v3.get_claim_summary_by_provider(client, billing_provider_tin, start_date_str, end_date_str, payer_id=payer_id)
-    display_claim_summary(claim_summary, payer_id)
+# Create a temporary file to store the claim summary
+output_file_path = os.path.join(os.getenv('TEMP'), 'claim_summary_report.txt')
+with open(output_file_path, 'w') as output_file:
+    # Loop through each payer_id and call the API, then display the claim summary
+    for payer_id in payer_ids:
+        claim_summary = MediLink_API_v3.get_claim_summary_by_provider(client, billing_provider_tin, start_date_str, end_date_str, payer_id=payer_id)
+        display_claim_summary(claim_summary, payer_id, output_file)  # Pass output_file to the display function
+
+# Open the generated file in Notepad
+os.startfile(output_file_path)  # Use os.startfile for better handling

MediLink/MediLink_ConfigLoader.py

@@ -1,11 +1,7 @@
-import os
-import json
-import logging
+# MediLink_ConfigLoader.py
+import os, json, logging, sys, platform, yaml
 from datetime import datetime
 from collections import OrderedDict
-import sys
-import platform
-import yaml
 
 """
 This function should be generalizable to have a initialization script over all the Medi* functions
@@ -17,7 +13,7 @@ def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..',
     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 sucks.
+    # BUG Hardcode sucks. This should probably be some local env variable. 
     # Detect the operating system
     if platform.system() == 'Windows' and platform.release() == 'XP':
         # Use F: paths for Windows XP
@@ -61,7 +57,7 @@ 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
         
 # Logs messages with optional error type and claim data.
-def log(message, config=None, level="INFO", error_type=None, claim=None):
+def log(message, config=None, level="INFO", error_type=None, claim=None, verbose=False):
     
     # If config is not provided, load it
     if config is None:
@@ -72,7 +68,11 @@ def log(message, config=None, level="INFO", error_type=None, claim=None):
         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,
+        
+        # Set logging level based on verbosity
+        logging_level = logging.DEBUG if verbose else logging.INFO
+        
+        logging.basicConfig(level=logging_level,
                             format='%(asctime)s - %(levelname)s - %(message)s',
                             filename=log_filepath,
                             filemode='a')