medicafe 0.250912.0__tar.gz → 0.250930.0__tar.gz

{medicafe-0.250912.0 → medicafe-0.250930.0}/MediBot/__init__.py

@@ -19,7 +19,7 @@ Smart Import Integration:
         medibot_main = get_components('medibot_main')
 """
 
-__version__ = "0.250912.0"
+__version__ = "0.250930.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

{medicafe-0.250912.0 → medicafe-0.250930.0}/MediCafe/MediLink_ConfigLoader.py

@@ -33,6 +33,13 @@ def get_default_config():
                 'level': 'INFO',
                 'console_output': True
             },
+            'error_reporting': {
+                'enabled': False,
+                'endpoint_url': '',
+                'auth_token': '',
+                'insecure_http': False,
+                'max_bundle_bytes': 2097152
+            },
             # STRATEGIC NOTE (COB Configuration): COB library is fully implemented and ready
             # To enable COB functionality, add the following configuration:
             # 'cob_settings': {

{medicafe-0.250912.0 → medicafe-0.250930.0}/MediCafe/__init__.py

@@ -27,7 +27,7 @@ Smart Import System:
         api_suite = get_api_access()
 """
 
-__version__ = "0.250912.0"
+__version__ = "0.250930.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

{medicafe-0.250912.0 → medicafe-0.250930.0}/MediCafe/api_core.py

@@ -6,7 +6,7 @@ Moved from MediLink to centralize shared API operations.
 COMPATIBILITY: Python 3.4.4 and Windows XP compatible
 """
 
-import time, json, os, traceback, sys, requests
+import time, json, os, traceback, sys
 
 # Import centralized logging configuration
 try:
@@ -689,21 +689,61 @@ class APIClient(BaseAPIClient):
             MediLink_ConfigLoader.log(log_message, level="ERROR")
             raise
 
-def fetch_payer_name_from_api(client, payer_id, config, primary_endpoint='AVAILITY'):
+def fetch_payer_name_from_api(*args, **kwargs):
     """
-    Fetches the payer name using the provided APIClient instance.
+    Fetch payer name by Payer ID with backward-compatible calling styles.
 
-    :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
+    Supported call signatures:
+    - fetch_payer_name_from_api(client, payer_id, config, primary_endpoint='AVAILITY')
+    - fetch_payer_name_from_api(payer_id, config, primary_endpoint='AVAILITY')  # client inferred via factory
+    - fetch_payer_name_from_api(payer_id=payer_id, config=config, client=client, primary_endpoint='AVAILITY')
     """
-    # Ensure client is an instance of APIClient
+    # Normalize arguments
+    client = None
+    payer_id = None
+    config = None
+    primary_endpoint = kwargs.get('primary_endpoint', 'AVAILITY')
+
+    if 'client' in kwargs:
+        client = kwargs.get('client')
+    if 'payer_id' in kwargs:
+        payer_id = kwargs.get('payer_id')
+    if 'config' in kwargs:
+        config = kwargs.get('config')
+
+    if len(args) >= 3 and isinstance(args[0], APIClient):
+        client = args[0]
+        payer_id = args[1]
+        config = args[2]
+        if len(args) >= 4 and 'primary_endpoint' not in kwargs:
+            primary_endpoint = args[3]
+    elif len(args) >= 2 and isinstance(args[0], str) and client is None:
+        # Called as (payer_id, config, [primary_endpoint])
+        payer_id = args[0]
+        config = args[1]
+        if len(args) >= 3 and 'primary_endpoint' not in kwargs:
+            primary_endpoint = args[2]
+    elif len(args) == 1 and isinstance(args[0], APIClient) and (payer_id is None or config is None):
+        # Partial positional with client first, other params via kwargs
+        client = args[0]
+
+    # Acquire client via factory if not provided
+    if client is None:
+        try:
+            from MediCafe.core_utils import get_api_client
+            client = get_api_client()
+            if client is None:
+                client = APIClient()
+        except Exception:
+            client = APIClient()
+
+    # Basic validation
     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
+        raise ValueError(error_message)
+    if payer_id is None or config is None:
+        raise ValueError("Missing required arguments: payer_id and config are required")
     
     # TODO: FUTURE IMPLEMENTATION - Remove AVAILITY default when other endpoints have payer-list APIs
     # Currently defaulting to AVAILITY as it's the only endpoint with confirmed payer-list functionality
@@ -750,6 +790,66 @@ def fetch_payer_name_from_api(client, payer_id, config, primary_endpoint='AVAILI
     # 3. Fall back to endpoints with basic payer lookup if available
     # 4. Use AVAILITY as final fallback
     
+    # If HTTP client is unavailable or endpoints missing, use offline fallback only when allowed (TestMode or env flag)
+    try:
+        http_unavailable = (requests is None)  # type: ignore[name-defined]
+    except Exception:
+        http_unavailable = True
+    # Determine whether offline fallback is permitted
+    # Align with main flow: default True when TestMode key is absent
+    offline_allowed = True
+    try:
+        from MediCafe.core_utils import extract_medilink_config
+        medi_local = extract_medilink_config(config)
+        offline_allowed = bool(medi_local.get('TestMode', True))
+    except Exception:
+        offline_allowed = True
+    try:
+        if os.environ.get('MEDICAFE_OFFLINE_PERMISSIVE', '').strip().lower() in ('1', 'true', 'yes', 'y'):
+            offline_allowed = True
+    except Exception:
+        pass
+
+    if offline_allowed and (http_unavailable or not isinstance(endpoints, dict) or not endpoints):
+        try:
+            # Prefer crosswalk mapping when available
+            try:
+                _, cw = MediLink_ConfigLoader.load_configuration()
+            except Exception:
+                cw = {}
+            payer_mappings = {}
+            try:
+                if isinstance(cw, dict):
+                    payer_mappings = cw.get('payer_mappings', {}) or {}
+            except Exception:
+                payer_mappings = {}
+
+            if payer_id in payer_mappings:
+                resolved = payer_mappings.get(payer_id)
+                MediLink_ConfigLoader.log(
+                    "Using crosswalk mapping for payer {} -> {} (offline)".format(payer_id, resolved),
+                    level="WARNING",
+                    console_output=CONSOLE_LOGGING
+                )
+                return resolved
+            # Safe minimal hardcoded map as last resort (test/offline only)
+            fallback_map = {
+                '87726': 'UnitedHealthcare',
+                '06111': 'Aetna',
+                '03432': 'Cigna',
+                '95378': 'Anthem Blue Cross',
+                '95467': 'Blue Shield',
+            }
+            if payer_id in fallback_map:
+                MediLink_ConfigLoader.log(
+                    "Using offline fallback for payer {} -> {}".format(payer_id, fallback_map[payer_id]),
+                    level="WARNING",
+                    console_output=CONSOLE_LOGGING
+                )
+                return fallback_map[payer_id]
+        except Exception:
+            pass
+
     # Define endpoint rotation logic with payer-list capability detection
     available_endpoints = []
     
@@ -820,6 +920,47 @@ def fetch_payer_name_from_api(client, payer_id, config, primary_endpoint='AVAILI
             error_message = "Error calling {0} for Payer ID {1}. Exception: {2}".format(endpoint_name, payer_id, e)
             MediLink_ConfigLoader.log(error_message, level="INFO")
 
+    # Offline/local fallback mapping for common payer IDs when API endpoints are unavailable
+    # Only when offline fallback is permitted
+    if offline_allowed:
+        try:
+            # Prefer crosswalk mapping first
+            try:
+                _, cw = MediLink_ConfigLoader.load_configuration()
+            except Exception:
+                cw = {}
+            payer_mappings = {}
+            try:
+                if isinstance(cw, dict):
+                    payer_mappings = cw.get('payer_mappings', {}) or {}
+            except Exception:
+                payer_mappings = {}
+            if payer_id in payer_mappings:
+                resolved = payer_mappings.get(payer_id)
+                MediLink_ConfigLoader.log(
+                    "Using crosswalk mapping for payer {} -> {} (offline)".format(payer_id, resolved),
+                    level="WARNING",
+                    console_output=CONSOLE_LOGGING
+                )
+                return resolved
+            # Minimal fallback map if crosswalk has no mapping (still offline-only)
+            fallback_map = {
+                '87726': 'UnitedHealthcare',
+                '06111': 'Aetna',
+                '03432': 'Cigna',
+                '95378': 'Anthem Blue Cross',
+                '95467': 'Blue Shield',
+            }
+            if payer_id in fallback_map:
+                MediLink_ConfigLoader.log(
+                    "Using offline fallback for payer {} -> {}".format(payer_id, fallback_map[payer_id]),
+                    level="WARNING",
+                    console_output=CONSOLE_LOGGING
+                )
+                return fallback_map[payer_id]
+        except Exception:
+            pass
+
     # If all endpoints fail
     final_error_message = "All endpoints exhausted for Payer ID {0}.".format(payer_id)
     print(final_error_message)

medicafe-0.250930.0/MediCafe/error_reporter.py

@@ -0,0 +1,287 @@
+import os, sys, time, json, zipfile, hashlib, platform
+
+try:
+	import requests
+except Exception:
+	requests = None
+
+from MediCafe.MediLink_ConfigLoader import load_configuration, log as mc_log
+
+
+ASCII_SAFE_REPLACEMENTS = [
+	('"', '"'),
+	("'", "'"),
+]
+
+
+def _safe_ascii(text):
+	try:
+		if text is None:
+			return ''
+		if isinstance(text, bytes):
+			try:
+				text = text.decode('ascii', 'ignore')
+			except Exception:
+				text = text.decode('utf-8', 'ignore')
+		else:
+			text = str(text)
+		return text.encode('ascii', 'ignore').decode('ascii', 'ignore')
+	except Exception:
+		return ''
+
+
+def _tail_file(path, max_lines):
+	lines = []
+	try:
+		with open(path, 'r') as f:
+			for line in f:
+				lines.append(line)
+				if len(lines) > max_lines:
+					lines.pop(0)
+		return ''.join(lines)
+	except Exception:
+		return ''
+
+
+def _get_latest_log_path(local_storage_path):
+	try:
+		files = []
+		for name in os.listdir(local_storage_path or '.'):
+			if name.startswith('Log_') and name.endswith('.log'):
+				files.append(os.path.join(local_storage_path, name))
+		if not files:
+			return None
+		files.sort(key=lambda p: os.path.getmtime(p))
+		return files[-1]
+	except Exception:
+		return None
+
+
+def _redact(text):
+	# Best-effort ASCII redaction: mask obvious numeric IDs and bearer tokens
+	try:
+		text = _safe_ascii(text)
+		import re
+		patterns = [
+			(r'\b(\d{3}-?\d{2}-?\d{4})\b', '***-**-****'),
+			(r'\b(\d{9,11})\b', '*********'),
+			(r'Bearer\s+[A-Za-z0-9\-._~+/]+=*', 'Bearer ***'),
+			(r'Authorization:\s*[^\n\r]+', 'Authorization: ***'),
+		]
+		for pat, rep in patterns:
+			text = re.sub(pat, rep, text)
+		return text
+	except Exception:
+		return text
+
+
+def _ensure_dir(path):
+	try:
+		if not os.path.exists(path):
+			os.makedirs(path)
+		return True
+	except Exception:
+		return False
+
+
+def _compute_report_id(zip_path):
+	try:
+		h = hashlib.sha256()
+		with open(zip_path, 'rb') as f:
+			chunk = f.read(256 * 1024)
+			h.update(chunk)
+		return 'mc-{}-{}'.format(int(time.time()), h.hexdigest()[:12])
+	except Exception:
+		return 'mc-{}-{}'.format(int(time.time()), '000000000000')
+
+
+def collect_support_bundle(include_traceback=True, max_log_lines=2000):
+	config, _ = load_configuration()
+	medi = config.get('MediLink_Config', {})
+	local_storage_path = medi.get('local_storage_path', '.')
+	queue_dir = os.path.join(local_storage_path, 'reports_queue')
+	_ensure_dir(queue_dir)
+
+	stamp = time.strftime('%Y%m%d_%H%M%S')
+	bundle_name = 'support_report_{}.zip'.format(stamp)
+	zip_path = os.path.join(queue_dir, bundle_name)
+
+	latest_log = _get_latest_log_path(local_storage_path)
+	log_tail = _tail_file(latest_log, max_log_lines) if latest_log else ''
+	log_tail = _redact(log_tail)
+
+	traceback_txt = ''
+	if include_traceback:
+		try:
+			trace_path = os.path.join(local_storage_path, 'traceback.txt')
+			if os.path.exists(trace_path):
+				with open(trace_path, 'r') as tf:
+					traceback_txt = _redact(tf.read())
+		except Exception:
+			traceback_txt = ''
+
+	meta = {
+		'app_version': _safe_ascii(_get_version()),
+		'python_version': _safe_ascii(sys.version.split(' ')[0]),
+		'platform': _safe_ascii(platform.platform()),
+		'timestamp': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
+		'error_summary': _safe_ascii(_first_line(traceback_txt)),
+		'traceback_present': bool(traceback_txt),
+		'config_flags': {
+			'console_logging': bool(medi.get('logging', {}).get('console_output', False)),
+			'test_mode': bool(medi.get('TestMode', False))
+		}
+	}
+
+	try:
+		with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as z:
+			z.writestr('meta.json', json.dumps(meta, ensure_ascii=True, indent=2))
+			if latest_log and log_tail:
+				z.writestr('log_tail.txt', log_tail)
+			if traceback_txt:
+				z.writestr('traceback.txt', traceback_txt)
+			z.writestr('README.txt', _readme_text())
+		return zip_path
+	except Exception as e:
+		mc_log('Error creating support bundle: {}'.format(e), level='ERROR')
+		return None
+
+
+def _first_line(text):
+	try:
+		for line in (text or '').splitlines():
+			line = line.strip()
+			if line:
+				return line[:200]
+		return ''
+	except Exception:
+		return ''
+
+
+def _readme_text():
+	return (
+		"MediCafe Support Bundle\n\n"
+		"This archive contains a redacted log tail, optional traceback, and metadata.\n"
+		"You may submit this bundle automatically from the app or send it manually to support.\n"
+	)
+
+
+def _get_version():
+	try:
+		from MediCafe import __version__
+		return __version__
+	except Exception:
+		return 'unknown'
+
+
+def submit_support_bundle(zip_path):
+	config, _ = load_configuration()
+	medi = config.get('MediLink_Config', {})
+	rep = medi.get('error_reporting', {}) if isinstance(medi, dict) else {}
+	endpoint_url = _safe_ascii(rep.get('endpoint_url', ''))
+	auth_token = _safe_ascii(rep.get('auth_token', ''))
+	insecure = bool(rep.get('insecure_http', False))
+	max_bytes = int(rep.get('max_bundle_bytes', 2097152))
+
+	if not requests:
+		print("[ERROR] requests module not available; cannot submit report.")
+		return False
+	if not endpoint_url:
+		print("[ERROR] error_reporting.endpoint_url not configured.")
+		return False
+	if not os.path.exists(zip_path):
+		print("[ERROR] Bundle not found: {}".format(zip_path))
+		return False
+	try:
+		size = os.path.getsize(zip_path)
+		if size > max_bytes:
+			print("[INFO] Bundle size {} exceeds cap {}; rebuilding smaller not implemented here.".format(size, max_bytes))
+	except Exception:
+		pass
+
+	report_id = _compute_report_id(zip_path)
+	headers = {
+		'X-Auth-Token': auth_token or '',
+		'X-Report-Id': report_id,
+		'User-Agent': 'MediCafe-Reporter/1.0'
+	}
+
+	# Prepare meta.json stream derived from inside the zip for server convenience
+	meta_json = '{}'
+	try:
+		with zipfile.ZipFile(zip_path, 'r') as z:
+			if 'meta.json' in z.namelist():
+				meta_json = z.read('meta.json')
+	except Exception:
+		meta_json = '{}'
+
+	try:
+		bundle_fh = open(zip_path, 'rb')
+		files = {
+			'meta': ('meta.json', meta_json, 'application/json'),
+			'bundle': (os.path.basename(zip_path), bundle_fh, 'application/zip')
+		}
+		r = requests.post(endpoint_url, headers=headers, files=files, timeout=(10, 20), verify=(not insecure))
+		code = getattr(r, 'status_code', None)
+		if code == 200:
+			print("[SUCCESS] Report submitted. ID: {}".format(report_id))
+			return True
+		elif code == 401:
+			print("[ERROR] Unauthorized (401). Check error_reporting.auth_token.")
+			return False
+		elif code == 413:
+			print("[ERROR] Too large (413). Consider reducing max log lines.")
+			return False
+		else:
+			print("[ERROR] Submission failed with status {}".format(code))
+			return False
+	except Exception as e:
+		print("[ERROR] Submission exception: {}".format(e))
+		return False
+	finally:
+		try:
+			bundle_fh.close()
+		except Exception:
+			pass
+
+
+def flush_queued_reports():
+	config, _ = load_configuration()
+	medi = config.get('MediLink_Config', {})
+	local_storage_path = medi.get('local_storage_path', '.')
+	queue_dir = os.path.join(local_storage_path, 'reports_queue')
+	if not os.path.isdir(queue_dir):
+		return 0, 0
+	count_ok = 0
+	count_total = 0
+	for name in sorted(os.listdir(queue_dir)):
+		if not name.endswith('.zip'):
+			continue
+		zip_path = os.path.join(queue_dir, name)
+		count_total += 1
+		print("Attempting upload of queued report: {}".format(name))
+		ok = submit_support_bundle(zip_path)
+		if ok:
+			try:
+				os.remove(zip_path)
+			except Exception:
+				pass
+			count_ok += 1
+	return count_ok, count_total
+
+
+def capture_unhandled_traceback(exc_type, exc_value, exc_traceback):
+	try:
+		config, _ = load_configuration()
+		medi = config.get('MediLink_Config', {})
+		local_storage_path = medi.get('local_storage_path', '.')
+		trace_path = os.path.join(local_storage_path, 'traceback.txt')
+		import traceback
+		text = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+		text = _redact(text)
+		with open(trace_path, 'w') as f:
+			f.write(text)
+		print("An error occurred. A traceback was saved to {}".format(trace_path))
+	except Exception:
+		pass
+

{medicafe-0.250912.0 → medicafe-0.250930.0}/MediLink/MediLink_837p_encoder_library.py

@@ -87,21 +87,24 @@ except (ImportError, SystemError):
     except ImportError:
         MediLink_UI = None
 
-# Import MediBot crosswalk utilities with fallback - using dynamic imports to avoid circular dependencies
-try:
-    import MediBot_Crosswalk_Utils
-    update_crosswalk_with_corrected_payer_id = MediBot_Crosswalk_Utils.update_crosswalk_with_corrected_payer_id
-    update_crosswalk_with_new_payer_id = MediBot_Crosswalk_Utils.update_crosswalk_with_new_payer_id
-except ImportError:
-    # Fallback to main library if utility import fails
-    try:
-        import MediBot_Crosswalk_Library
-        update_crosswalk_with_corrected_payer_id = MediBot_Crosswalk_Library.update_crosswalk_with_corrected_payer_id
-        update_crosswalk_with_new_payer_id = MediBot_Crosswalk_Library.update_crosswalk_with_new_payer_id
-    except (ImportError, AttributeError):
-        # If functions are not available, set to None for graceful handling
-        update_crosswalk_with_corrected_payer_id = None
-        update_crosswalk_with_new_payer_id = None
+# Import MediBot crosswalk utilities via centralized import helpers
+from MediCafe.core_utils import import_medibot_module
+
+# Resolve required functions directly at import-time using centralized helper (Py 3.4.4 friendly)
+update_crosswalk_with_new_payer_id = (
+    import_medibot_module('MediBot_Crosswalk_Utils', 'update_crosswalk_with_new_payer_id') or
+    import_medibot_module('MediBot_Crosswalk_Library', 'update_crosswalk_with_new_payer_id')
+)
+
+update_crosswalk_with_corrected_payer_id = (
+    import_medibot_module('MediBot_Crosswalk_Utils', 'update_crosswalk_with_corrected_payer_id') or
+    import_medibot_module('MediBot_Crosswalk_Library', 'update_crosswalk_with_corrected_payer_id')
+)
+
+if not callable(update_crosswalk_with_new_payer_id):
+    raise RuntimeError("Crosswalk update function not available (new payer id). Ensure MediBot_Crosswalk_Utils or MediBot_Crosswalk_Library is importable.")
+if not callable(update_crosswalk_with_corrected_payer_id):
+    raise RuntimeError("Crosswalk update function not available (corrected payer id). Ensure MediBot_Crosswalk_Utils or MediBot_Crosswalk_Library is importable.")
 
 # Import enhanced insurance selection with fallback
 # XP/Python34 Compatibility: Enhanced error handling with verbose output

{medicafe-0.250912.0 → medicafe-0.250930.0}/MediLink/MediLink_Deductible.py

@@ -390,17 +390,50 @@ def manual_deductible_lookup():
                     # Already processed data from merge_responses
                     enhanced_result = eligibility_data
                 elif convert_eligibility_to_enhanced_format is not None:
+                    # Attempt CSV backfill context for manual route
+                    csv_row = patient_row_index.get((formatted_dob, member_id))
+                    derived_patient_id = ""
+                    derived_service_date = ""
+                    if csv_row:
+                        try:
+                            derived_patient_id = str(csv_row.get('Patient ID #2', csv_row.get('Patient ID', '')))
+                            derived_service_date = str(csv_row.get('Service Date', ''))
+                        except Exception:
+                            derived_patient_id = ""
+                            derived_service_date = ""
                     # Raw API data needs conversion with patient info
-                    enhanced_result = convert_eligibility_to_enhanced_format(eligibility_data, formatted_dob, member_id, "", "")
+                    enhanced_result = convert_eligibility_to_enhanced_format(
+                        eligibility_data, formatted_dob, member_id, derived_patient_id, derived_service_date
+                    )
                 else:
                     # Fallback if utility function not available
                     enhanced_result = None
                 if enhanced_result:
                     try:
                         # Backfill with CSV row data when available
-                        enhanced_result = backfill_enhanced_result(enhanced_result, None)
+                        csv_row = patient_row_index.get((formatted_dob, member_id))
+                        enhanced_result = backfill_enhanced_result(enhanced_result, csv_row)
+                    except Exception:
+                        pass
+                    # Ensure patient_id present; warn/log and set surrogate if missing
+                    try:
+                        pid = str(enhanced_result.get('patient_id', '')).strip()
+                        if not pid:
+                            surrogate = "{}:{}".format(formatted_dob, member_id)
+                            enhanced_result['patient_id'] = surrogate
+                            print("Warning: Missing Patient ID; using surrogate key {}".format(surrogate))
+                            MediLink_ConfigLoader.log(
+                                "Manual lookup: Missing Patient ID; using surrogate key {}".format(surrogate),
+                                level="WARNING"
+                            )
                     except Exception:
                         pass
+                    # Ensure patient_name not blank
+                    try:
+                        if not str(enhanced_result.get('patient_name', '')).strip():
+                            enhanced_result['patient_name'] = 'Unknown Patient'
+                    except Exception:
+                        enhanced_result['patient_name'] = 'Unknown Patient'
                     print("\n" + "=" * 60)
                     display_enhanced_deductible_table([enhanced_result], context="post_api", 
                                                     title="Manual Lookup Result")
@@ -441,7 +474,18 @@ def manual_deductible_lookup():
                         "Patient Name", "DOB", "Insurance Type", "PayID", "Policy Status", "Remaining Amt")
                     output_file.write(table_header + "\n")
                     output_file.write("-" * len(table_header) + "\n")
-                    display_eligibility_info(eligibility_data, formatted_dob, member_id, output_file)
+                    # Write directly from enhanced_result to ensure CSV backfill/defaults are preserved
+                    if enhanced_result:
+                        table_row = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
+                            enhanced_result['patient_name'][:20],
+                            enhanced_result['dob'],
+                            enhanced_result['insurance_type'][:40],
+                            enhanced_result['payer_id'][:5],
+                            enhanced_result['policy_status'][:14],
+                            enhanced_result['remaining_amount'][:14])
+                        output_file.write(table_row + "\n")
+                    else:
+                        display_eligibility_info(eligibility_data, formatted_dob, member_id, output_file)
                 
                 # Ask if user wants to open the report
                 open_report = input("\nEligibility data found! Open the report? (Y/N): ").strip().lower()

{medicafe-0.250912.0 → medicafe-0.250930.0}/MediLink/MediLink_Display_Utils.py

@@ -177,6 +177,20 @@ def _normalize_pre_api_data(row):
         member_id = row.get('Primary Policy Number', row.get('Ins1 Member ID', '')).strip()
         payer_id = row.get('Ins1 Payer ID', '')
         patient_id = row.get('Patient ID #2', row.get('Patient ID', ''))
+
+        # Surrogate key and warnings if patient_id missing/blank
+        if not str(patient_id).strip():
+            surrogate = "{}:{}".format(dob, member_id)
+            patient_id = surrogate
+            try:
+                # Print visible warning and log as WARNING event
+                print("Warning: Missing Patient ID in CSV row; using surrogate key {}".format(surrogate))
+                MediLink_ConfigLoader.log(
+                    "Missing Patient ID in CSV; using surrogate key {}".format(surrogate),
+                    level="WARNING"
+                )
+            except Exception:
+                pass
         
         return {
             'patient_id': str(patient_id),
@@ -200,7 +214,7 @@ def _normalize_post_api_data(eligibility_result):
     try:
         # Handle the enhanced format that comes from convert_eligibility_to_enhanced_format
         if isinstance(eligibility_result, dict):
-            return {
+            normalized = {
                 'patient_id': str(eligibility_result.get('patient_id', '')),
                 'patient_name': str(eligibility_result.get('patient_name', '')),
                 'dob': str(eligibility_result.get('dob', '')),
@@ -214,6 +228,28 @@ def _normalize_post_api_data(eligibility_result):
                 'remaining_amount': str(eligibility_result.get('remaining_amount', '')),
                 'data_source': str(eligibility_result.get('data_source', ''))
             }
+
+            # Default unknown patient name when blank
+            try:
+                if not normalized['patient_name'].strip():
+                    normalized['patient_name'] = 'Unknown Patient'
+            except Exception:
+                normalized['patient_name'] = 'Unknown Patient'
+
+            # Surrogate key and warnings if patient_id missing/blank
+            try:
+                if not normalized['patient_id'].strip():
+                    surrogate = "{}:{}".format(normalized.get('dob', ''), normalized.get('member_id', ''))
+                    normalized['patient_id'] = surrogate
+                    print("Warning: Missing Patient ID in eligibility result; using surrogate key {}".format(surrogate))
+                    MediLink_ConfigLoader.log(
+                        "Missing Patient ID in eligibility result; using surrogate key {}".format(surrogate),
+                        level="WARNING"
+                    )
+            except Exception:
+                pass
+
+            return normalized
         else:
             MediLink_ConfigLoader.log("Unexpected eligibility result format: {}".format(type(eligibility_result)), level="WARNING")
             return None

{medicafe-0.250912.0 → medicafe-0.250930.0}/MediLink/MediLink_main.py

@@ -22,6 +22,7 @@ if PERFORMANCE_LOGGING:
 
 # Now import core utilities after path setup
 from MediCafe.core_utils import get_shared_config_loader, setup_module_paths, extract_medilink_config
+from MediCafe.error_reporter import flush_queued_reports, collect_support_bundle, submit_support_bundle, capture_unhandled_traceback
 setup_module_paths(__file__)
 
 # Import modules after path setup
@@ -57,6 +58,8 @@ def _tools_menu(config, medi):
         print("\nMaintenance Tools:")
         options = [
             "Rebuild submission index now",
+            "Submit Error Report (online)",
+            "Create Support Bundle (offline)",
             "Back"
         ]
         MediLink_UI.display_menu(options)
@@ -75,6 +78,27 @@ def _tools_menu(config, medi):
             except Exception as e:
                 print("Index rebuild error: {}".format(e))
         elif choice == '2':
+            try:
+                print("\nSubmitting Error Report (online)...")
+                zip_path = collect_support_bundle(include_traceback=True)
+                if not zip_path:
+                    print("Failed to create support bundle.")
+                else:
+                    ok = submit_support_bundle(zip_path)
+                    if not ok:
+                        print("Submission failed. Bundle saved at {} for later retry.".format(zip_path))
+            except Exception as e:
+                print("Error during report submission: {}".format(e))
+        elif choice == '3':
+            try:
+                zip_path = collect_support_bundle(include_traceback=True)
+                if zip_path:
+                    print("Support bundle created: {}".format(zip_path))
+                else:
+                    print("Failed to create support bundle.")
+            except Exception as e:
+                print("Error creating support bundle: {}".format(e))
+        elif choice == '4':
             break
         else:
             MediLink_UI.display_invalid_choice()
@@ -167,6 +191,15 @@ def main_menu():
     if PERFORMANCE_LOGGING:
         print("Welcome display completed in {:.2f} seconds".format(welcome_end - welcome_start))
 
+    # Startup: flush any queued error reports (non-blocking style)
+    try:
+        print("\nChecking for queued error reports...")
+        uploaded, total = flush_queued_reports()
+        if total:
+            print("Queued reports: {} | Uploaded now: {}".format(total, uploaded))
+    except Exception:
+        pass
+
     # Show message if new records were found during boot-time scan. TODO we need this to use the 'Last acknowledgements update:' timestamp to decide if it has already run in the last day so 
     # that we're not running it multiple times in rapid succession automatically. (user-initiated checks are fine like via selection of (1. Check for new remittances))
     if ack_result:
@@ -428,6 +461,11 @@ if __name__ == "__main__":
     total_start_time = time.time()
     exit_code = 0
     try:
+        # Install unhandled exception hook to capture tracebacks
+        try:
+            sys.excepthook = capture_unhandled_traceback
+        except Exception:
+            pass
         main_menu()
     except ValueError as e:
         # Graceful domain error: show concise message without traceback, then exit
@@ -448,6 +486,25 @@ if __name__ == "__main__":
         # Unexpected error: still avoid full traceback, present succinct notice
         sys.stderr.write("An unexpected error occurred; process halted.\n")
         sys.stderr.write(str(e) + "\n")
+        # Offer to create and submit an error report
+        try:
+            ans = input("Create and submit an error report now? (y/N): ").strip().lower()
+        except Exception:
+            ans = 'n'
+        if ans in ['y', 'yes']:
+            try:
+                from MediCafe.error_reporter import collect_support_bundle, submit_support_bundle
+                zip_path = collect_support_bundle(include_traceback=True)
+                if not zip_path:
+                    print("Failed to create support bundle.")
+                else:
+                    ok = submit_support_bundle(zip_path)
+                    if ok:
+                        print("Report submitted successfully.")
+                    else:
+                        print("Submission failed. Bundle saved at {} for later retry.".format(zip_path))
+            except Exception as _erre:
+                print("Error while creating/submitting report: {}".format(_erre))
         sys.stderr.write("\nPress Enter to exit...\n")
         try:
             input()

{medicafe-0.250912.0 → medicafe-0.250930.0}/MediLink/__init__.py

@@ -22,7 +22,7 @@ Smart Import Integration:
         datamgmt = get_components('medilink_datamgmt')
 """
 
-__version__ = "0.250912.0"
+__version__ = "0.250930.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

{medicafe-0.250912.0/medicafe.egg-info → medicafe-0.250930.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: medicafe
-Version: 0.250912.0
+Version: 0.250930.0
 Summary: MediCafe
 Home-page: https://github.com/katanada2/MediCafe
 Author: Daniel Vidaud

{medicafe-0.250912.0 → medicafe-0.250930.0/medicafe.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: medicafe
-Version: 0.250912.0
+Version: 0.250930.0
 Summary: MediCafe
 Home-page: https://github.com/katanada2/MediCafe
 Author: Daniel Vidaud

{medicafe-0.250912.0 → medicafe-0.250930.0}/medicafe.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ MediCafe/api_factory.py
 MediCafe/api_utils.py
 MediCafe/core_utils.py
 MediCafe/deductible_utils.py
+MediCafe/error_reporter.py
 MediCafe/graphql_utils.py
 MediCafe/logging_config.py
 MediCafe/logging_demo.py

{medicafe-0.250912.0 → medicafe-0.250930.0}/setup.py

@@ -54,7 +54,7 @@ if long_description_text is None:
 
 setup(
     name='medicafe',
-    version="0.250912.0",
+    version="0.250930.0",
     description='MediCafe',
     long_description=long_description_text,
     long_description_content_type='text/markdown',