medicafe 0.240613.0__py3-none-any.whl → 0.240809.0__py3-none-any.whl

MediLink/MediLink_API_v3.py

@@ -0,0 +1,429 @@
+import time
+import requests
+import yaml
+import json
+import os
+
+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'), 
+                           crosswalk_path=os.path.join(os.path.dirname(__file__), '..', 'json', 'crosswalk.json')):
+        return MediLink_ConfigLoader.load_configuration(config_path, crosswalk_path)
+
+    @staticmethod
+    def load_swagger_file(swagger_path):
+        try:
+            print("Attempting to load Swagger file: {}".format(swagger_path))
+            with open(swagger_path, 'r') as swagger_file:
+                if swagger_path.endswith('.yaml') or swagger_path.endswith('.yml'):
+                    print("Parsing YAML file: {}".format(swagger_path))
+                    swagger_data = yaml.safe_load(swagger_file)
+                elif swagger_path.endswith('.json'):
+                    print("Parsing JSON file: {}".format(swagger_path))
+                    swagger_data = json.load(swagger_file)
+                else:
+                    raise ValueError("Unsupported Swagger file format.")
+            print("Successfully loaded Swagger file: {}".format(swagger_path))
+            return swagger_data
+        except ValueError as e:
+            print("Error parsing Swagger file {}: {}".format(swagger_path, e))
+            MediLink_ConfigLoader.log("Error parsing Swagger file {}: {}".format(swagger_path, e), level="ERROR")
+        except FileNotFoundError:
+            print("Swagger file not found: {}".format(swagger_path))
+            MediLink_ConfigLoader.log("Swagger file not found: {}".format(swagger_path), level="ERROR")
+        except Exception as e:
+            print("Unexpected error loading Swagger file {}: {}".format(swagger_path, e))
+            MediLink_ConfigLoader.log("Unexpected error loading Swagger file {}: {}".format(swagger_path, e), level="ERROR")
+        return None
+
+# Function to ensure numeric type
+def ensure_numeric(value):
+    if isinstance(value, str):
+        try:
+            value = float(value)
+        except ValueError:
+            raise ValueError("Cannot convert {} to a numeric type".format(value))
+    return value
+
+class TokenCache:
+    def __init__(self):
+        self.tokens = {}
+
+    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']
+        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)
+        
+        self.tokens[endpoint_name] = {
+            'access_token': access_token,
+            'expires_at': current_time + expires_in - 120
+        }
+
+class BaseAPIClient:
+    def __init__(self, config):
+        self.config = config
+        self.token_cache = TokenCache()
+
+    def get_access_token(self, endpoint_name):
+        raise NotImplementedError("Subclasses should implement this!")
+
+    def make_api_call(self, endpoint_name, call_type, url_extension="", params=None, data=None, headers=None):
+        raise NotImplementedError("Subclasses should implement this!")
+
+class APIClient(BaseAPIClient):
+    def __init__(self):
+        config, _ = MediLink_ConfigLoader.load_configuration()
+        super().__init__(config)
+
+    def get_access_token(self, endpoint_name):
+        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")
+            return cached_token
+
+        endpoint_config = self.config['MediLink_Config']['endpoints'][endpoint_name]
+        token_url = endpoint_config['token_url']
+        data = {
+            'grant_type': 'client_credentials',
+            'client_id': endpoint_config['client_id'],
+            'client_secret': endpoint_config['client_secret']
+        }
+
+        # Add scope if specified in the configuration
+        if 'scope' in endpoint_config:
+            data['scope'] = endpoint_config['scope']
+
+        headers = {'Content-Type': 'application/x-www-form-urlencoded'}
+
+        response = requests.post(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)
+
+        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")
+        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 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")
+
+        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()
+
+        return response.json()
+
+def fetch_payer_name_from_api(payer_id, config, primary_endpoint='AVAILITY'):
+    client = APIClient()
+    config, _ = MediLink_ConfigLoader.load_configuration()
+    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())
+
+    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})
+            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")
+        except Exception as e:
+            MediLink_ConfigLoader.log("API call to {} failed: {}".format(endpoint_name, e), level="ERROR")
+
+    error_message = "All endpoints exhausted for Payer ID {}.".format(payer_id)
+    MediLink_ConfigLoader.log(error_message, level="CRITICAL")
+    raise ValueError(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'
+    url_extension = client.config['MediLink_Config']['endpoints'][endpoint_name]['additional_endpoints']['claim_summary_by_provider']
+    headers = {
+        'tin': tin,
+        'firstServiceDt': first_service_date,
+        'lastServiceDt': last_service_date,
+        'payerId': payer_id,
+        'getStandardError': get_standard_error,
+        'Accept': 'application/json'
+    }
+    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'
+    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)
+    return client.make_api_call(endpoint_name, 'GET', url_extension)
+
+def get_eligibility_v3(client, payer_id, provider_last_name, search_option, date_of_birth, member_id, npi, 
+                       first_name=None, last_name=None, payer_label=None, payer_name=None, service_start=None, service_end=None, 
+                       middle_name=None, gender=None, ssn=None, city=None, state=None, zip=None, group_number=None, 
+                       service_type_code=None, provider_first_name=None, tax_id_number=None, provider_name_id=None, 
+                       corporate_tax_owner_id=None, corporate_tax_owner_name=None, organization_name=None, 
+                       organization_id=None, identify_service_level_deductible=True):
+
+    # Ensure all required parameters have values
+    if not all([client, payer_id, provider_last_name, search_option, date_of_birth, member_id, npi]):
+        raise ValueError("All required parameters must have values: client, payer_id, provider_last_name, search_option, date_of_birth, member_id, npi")
+
+    # Validate payer_id
+    valid_payer_ids = ["87726", "06111", "25463", "37602", "39026", "74227", "65088", "81400", "03432", "86050", "86047", "95378", "95467"]
+    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'
+    url_extension = client.config['MediLink_Config']['endpoints'][endpoint_name]['additional_endpoints']['eligibility_v3']
+    
+    # Construct request body
+    body = {
+        "memberId": member_id,
+        "lastName": last_name,
+        "firstName": first_name,
+        "dateOfBirth": date_of_birth,
+        "payerID": payer_id,
+        "payerLabel": payer_label,
+        "payerName": payer_name,
+        "serviceStart": service_start,
+        "serviceEnd": service_end,
+        "middleName": middle_name,
+        "gender": gender,
+        "ssn": ssn,
+        "city": city,
+        "state": state,
+        "zip": zip,
+        "groupNumber": group_number,
+        "serviceTypeCode": service_type_code,
+        "providerLastName": provider_last_name,
+        "providerFirstName": provider_first_name,
+        "taxIdNumber": tax_id_number,
+        "providerNameID": provider_name_id,
+        "npi": npi,
+        "corporateTaxOwnerID": corporate_tax_owner_id,
+        "corporateTaxOwnerName": corporate_tax_owner_name,
+        "organizationName": organization_name,
+        "organizationID": organization_id,
+        "searchOption": search_option,
+        "identifyServiceLevelDeductible": identify_service_level_deductible
+    }
+    
+    # Remove None values from the body
+    body = {k: v for k, v in body.items() if v is not None}
+
+    # Log the request body
+    MediLink_ConfigLoader.log("Request body: {}".format(json.dumps(body, indent=4)), level="DEBUG")
+
+    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 API response for {}.".format(endpoint_type), level="INFO")
+        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_claim_summary': False,
+        'test_eligibility': False,
+        'test_eligibility_v3': False,
+        'test_claim_submission': True,
+    }
+    
+    try:
+        api_test_cases = client.config['MediLink_Config']['API Test Case']
+        
+        # Test 1: Fetch Payer Name
+        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))
+            except Exception as 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):
+            try:
+                for case in api_test_cases:
+                    claim_summary = get_claim_summary_by_provider(client, case['provider_tin'], '05/01/2024', '06/23/2024', case['payer_id'])
+                    print("TEST API: Claim Summary: {}".format(claim_summary))
+            except Exception as e:
+                print("TEST API: Error in Claim Summary Test: {}".format(e))
+        
+        # Test 3: Get Eligibility
+        if test_config.get('test_eligibility', False):
+            try:
+                for case in api_test_cases:
+                    eligibility = get_eligibility(client, case['payer_id'], case['provider_last_name'], case['search_option'], 
+                                                  case['date_of_birth'], case['member_id'], case['npi'])
+                    print("TEST API: Eligibility: {}".format(eligibility))
+            except Exception as e:
+                print("TEST API: Error in Eligibility Test: {}".format(e))
+
+        # Test 4: Get Eligibility v3
+        if test_config.get('test_eligibility_v3', False):
+            try:
+                for case in api_test_cases:
+                    eligibility_v3 = get_eligibility_v3(client, payer_id=case['payer_id'], provider_last_name=case['provider_last_name'], 
+                                                        search_option=case['search_option'], date_of_birth=case['date_of_birth'], 
+                                                        member_id=case['member_id'], npi=case['npi'])
+                    print("TEST API: Eligibility v3: {}".format(eligibility_v3))
+            except Exception as e:
+                print("TEST API: Error in Eligibility v3 Test: {}".format(e))
+
+        """
+        # Example of iterating over multiple patients (if needed)
+        patients = [
+            {'payer_id': '87726', 'provider_last_name': 'VIDA', 'search_option': 'MemberIDDateOfBirth', 'date_of_birth': '1980-01-01', 'member_id': '123456789', 'npi': '9876543210'},
+            {'payer_id': '87726', 'provider_last_name': 'SMITH', 'search_option': 'MemberIDDateOfBirth', 'date_of_birth': '1970-02-02', 'member_id': '987654321', 'npi': '1234567890'},
+            # Add more patients as needed
+        ]
+
+        for patient in patients:
+            try:
+                eligibility = get_eligibility(client, patient['payer_id'], patient['provider_last_name'], patient['search_option'], patient['date_of_birth'], patient['member_id'], patient['npi'])
+                print("Eligibility for {}: {}".format(patient['provider_last_name'], eligibility))
+            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))

MediLink/MediLink_ClaimStatus.py

@@ -0,0 +1,144 @@
+from datetime import datetime, timedelta
+import MediLink_API_v3
+
+try:
+    from MediLink import MediLink_ConfigLoader
+except ImportError:
+    import MediLink_ConfigLoader
+
+# Load configuration
+config, _ = MediLink_ConfigLoader.load_configuration()
+
+# Calculate start_date as 60 days before today's date and end_date as today's date
+end_date = datetime.today()
+start_date = end_date - timedelta(days=60)
+end_date_str = end_date.strftime('%m/%d/%Y')
+start_date_str = start_date.strftime('%m/%d/%Y')
+
+# Get billing provider TIN from configuration
+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
+# Allowed payer id's for UHC
+# payer_ids = ['87726', '03432', '96385', '95467', '86050', '86047', '95378', '06111', '37602']
+
+# Initialize the API client
+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):
+    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)
+    print("=" * len(header))
+
+    # 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)
+    print("-" * len(table_header))
+
+    # Process each claim and display it in a compact format
+    claims_dict = {}
+    for claim in claims:
+        claim_number = claim['claimNumber']  # String: e.g., "29285698"
+        claim_status = claim['claimStatus']  # String: e.g., "Finalized"
+        patient_first_name = claim['memberInfo']['ptntFn']  # String: e.g., "FRANK"
+        patient_last_name = claim['memberInfo']['ptntLn']  # String: e.g., "LOHR"
+        processed_date = claim['claimSummary']['processedDt']  # String (Date in "MM/DD/YYYY" format): e.g., "06/10/2024"
+        first_service_date = claim['claimSummary']['firstSrvcDt']  # String (Date in "MM/DD/YYYY" format): e.g., "05/13/2024"
+        total_charged_amount = claim['claimSummary']['totalChargedAmt']  # String (Decimal as String): e.g., "450.00"
+        total_allowed_amount = claim['claimSummary']['totalAllowdAmt']  # String (Decimal as String): e.g., "108.95"
+        total_paid_amount = claim['claimSummary']['totalPaidAmt']  # String (Decimal as String): e.g., "106.78"
+        total_patient_responsibility_amount = claim['claimSummary']['totalPtntRespAmt']  # String (Decimal as String): e.g., "0.00"
+        
+        patient_name = "{} {}".format(patient_first_name, patient_last_name)
+
+        # Store claims in a dictionary to handle duplicate claim numbers
+        if claim_number not in claims_dict:
+            claims_dict[claim_number] = []
+        claims_dict[claim_number].append({
+            'claim_status': claim_status,
+            'patient_name': patient_name,
+            'processed_date': processed_date,
+            'first_service_date': first_service_date,
+            'total_charged_amount': total_charged_amount,
+            'total_allowed_amount': total_allowed_amount,
+            'total_paid_amount': total_paid_amount,
+            'total_patient_responsibility_amount': total_patient_responsibility_amount,
+            'claim_xwalk_data': claim['claimSummary']['clmXWalkData']
+        })
+
+    # Sort claims by first_service_date
+    sorted_claims = sorted(claims_dict.items(), key=lambda x: x[1][0]['first_service_date'])
+
+    for claim_number, claim_data_list in sorted_claims:
+        # Check for repeated claim numbers and validate data
+        if len(claim_data_list) > 1:
+            # Validate data
+            unique_claims = {tuple(claim_data.items()) for claim_data in claim_data_list}
+            if len(unique_claims) == 1:
+                # Data is the same, only print once
+                claim_data = claim_data_list[0]
+                table_row = "{:<10} | {:<10} | {:<20} | {:<6} | {:<6} | {:<7} | {:<7} | {:<7} | {:<7}".format(
+                    claim_number, claim_data['claim_status'], claim_data['patient_name'][:20], 
+                    claim_data['processed_date'][:5], claim_data['first_service_date'][:5],
+                    claim_data['total_allowed_amount'], claim_data['total_paid_amount'], 
+                    claim_data['total_patient_responsibility_amount'], claim_data['total_charged_amount']
+                )
+                print(table_row)
+
+                if claim_data['total_paid_amount'] == '0.00':
+                    for xwalk in claim_data['claim_xwalk_data']:
+                        clm507Cd = xwalk['clm507Cd']  # String: e.g., "F1"
+                        clm507CdDesc = xwalk['clm507CdDesc']  # String: e.g., "Finalized/Payment-The claim/line has been paid."
+                        clm508Cd = xwalk['clm508Cd']  # String: e.g., "104"
+                        clm508CdDesc = xwalk['clm508CdDesc']  # String: e.g., "Processed according to plan provisions..."
+                        clmIcnSufxCd = xwalk['clmIcnSufxCd']  # String: e.g., "01"
+                        print("  507: {} ({}) | 508: {} ({}) | ICN Suffix: {}".format(clm507Cd, clm507CdDesc, clm508Cd, clm508CdDesc, clmIcnSufxCd))
+            else:
+                # Data is different, print all
+                for claim_data in claim_data_list:
+                    table_row = "{:<10} | {:<10} | {:<20} | {:<6} | {:<6} | {:<7} | {:<7} | {:<7} | {:<7}".format(
+                        claim_number, claim_data['claim_status'], claim_data['patient_name'][:20], 
+                        claim_data['processed_date'][:5], claim_data['first_service_date'][:5],
+                        claim_data['total_allowed_amount'], claim_data['total_paid_amount'], 
+                        claim_data['total_patient_responsibility_amount'], claim_data['total_charged_amount']
+                    )
+                    print(table_row + " (Duplicate with different data)")
+
+                    if claim_data['total_paid_amount'] == '0.00':
+                        for xwalk in claim_data['claim_xwalk_data']:
+                            clm507Cd = xwalk['clm507Cd']  # String: e.g., "F1"
+                            clm507CdDesc = xwalk['clm507CdDesc']  # String: e.g., "Finalized/Payment-The claim/line has been paid."
+                            clm508Cd = xwalk['clm508Cd']  # String: e.g., "104"
+                            clm508CdDesc = xwalk['clm508CdDesc']  # String: e.g., "Processed according to plan provisions..."
+                            clmIcnSufxCd = xwalk['clmIcnSufxCd']  # String: e.g., "01"
+                            print("  507: {} ({}) | 508: {} ({}) | ICN Suffix: {}".format(clm507Cd, clm507CdDesc, clm508Cd, clm508CdDesc, clmIcnSufxCd))
+        else:
+            # Only one claim, print normally
+            claim_data = claim_data_list[0]
+            table_row = "{:<10} | {:<10} | {:<20} | {:<6} | {:<6} | {:<7} | {:<7} | {:<7} | {:<7}".format(
+                claim_number, claim_data['claim_status'], claim_data['patient_name'][:20], 
+                claim_data['processed_date'][:5], claim_data['first_service_date'][:5],
+                claim_data['total_allowed_amount'], claim_data['total_paid_amount'], 
+                claim_data['total_patient_responsibility_amount'], claim_data['total_charged_amount']
+            )
+            print(table_row)
+
+            if claim_data['total_paid_amount'] == '0.00':
+                for xwalk in claim_data['claim_xwalk_data']:
+                    clm507Cd = xwalk['clm507Cd']  # String: e.g., "F1"
+                    clm507CdDesc = xwalk['clm507CdDesc']  # String: e.g., "Finalized/Payment-The claim/line has been paid."
+                    clm508Cd = xwalk['clm508Cd']  # String: e.g., "104"
+                    clm508CdDesc = xwalk['clm508CdDesc']  # String: e.g., "Processed according to plan provisions..."
+                    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)

MediLink/MediLink_ConfigLoader.py

@@ -5,18 +5,19 @@ 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
 """
 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.
+    Loads endpoint configuration, credentials, and other settings from JSON or YAML 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:
+    # 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
@@ -29,10 +30,15 @@ def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..',
     
     try:
         with open(config_path, 'r') as config_file:
-            config = json.load(config_file, object_pairs_hook=OrderedDict)
+            if config_path.endswith('.yaml') or config_path.endswith('.yml'):
+                config = yaml.safe_load(config_file)
+            elif config_path.endswith('.json'):
+                config = json.load(config_file, object_pairs_hook=OrderedDict)
+            else:
+                raise ValueError("Unsupported configuration format.")
+            
             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)
@@ -40,12 +46,12 @@ def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..',
         return config, crosswalk
     except ValueError as e:
         if isinstance(e, UnicodeDecodeError):
-            print("Error decoding JSON file: {}".format(e))
+            print("Error decoding file: {}".format(e))
         else:
-            print("Error parsing JSON file: {}".format(e))
+            print("Error parsing 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))
+        print("One or both configuration 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))

MediLink/MediLink_DataMgmt.py

@@ -219,11 +219,11 @@ def operate_winscp(operation_type, files, endpoint_config, local_storage_path, c
     except KeyError as e:
         # Log the missing key information
         missing_key = str(e)
-        message = "KeyError: Endpoint config is missing key: {}".format(missing_key)
+        message = "Critical Error: Endpoint config is missing key: {}".format(missing_key)
         MediLink_ConfigLoader.log(message)
-        # Set default values or handle the situation accordingly
-        session_name = ''
-        remote_directory = ''
+        # Raise an exception to halt execution
+        raise RuntimeError("Configuration error: The endpoint configuration is missing definitions for the required remote directories. Please check the configuration and try again.")
+
     # Command building
     command = [
         winscp_path,