medicafe 0.251017.1__py3-none-any.whl → 0.251026.0__py3-none-any.whl

MediBot/__init__.py

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

MediCafe/MediLink_ConfigLoader.py

@@ -38,7 +38,14 @@ def get_default_config():
                 'endpoint_url': '',
                 'auth_token': '',
                 'insecure_http': False,
-                'max_bundle_bytes': 2097152
+                'max_bundle_bytes': 2097152,
+                'email': {
+                    'enabled': False,
+                    'to': '',
+                    'subject_prefix': 'MediCafe Error Report',
+                    'max_bundle_bytes': 1572864,
+                    'transport': 'gmail_api'
+                }
             },
             # STRATEGIC NOTE (COB Configuration): COB library is fully implemented and ready
             # To enable COB functionality, add the following configuration:

MediCafe/__init__.py

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

MediCafe/api_core.py

@@ -1212,14 +1212,14 @@ def get_eligibility_super_connector(client, payer_id, provider_last_name, search
                                    corporate_tax_owner_id=None, corporate_tax_owner_name=None, organization_name=None, 
                                    organization_id=None, identify_service_level_deductible=True):
     """
-    GraphQL Super Connector version of eligibility check that maps to the same interface as get_eligibility_v3.
-    This function provides a drop-in replacement for the REST API with identical input/output behavior.
+    OPTUMAI eligibility (GraphQL) that maps to the same interface as get_eligibility_v3.
+    This function does not perform legacy fallback; callers should invoke legacy v3 separately if desired.
     """
     # 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")
 
-    # Prefer OPTUMAI endpoint if configured, otherwise fall back to legacy UHCAPI super connector
+    # Prefer OPTUMAI endpoint if configured, otherwise fall back to legacy UHCAPI v3 (REST)
     try:
         endpoints_cfg = client.config['MediLink_Config']['endpoints']
     except Exception:
@@ -1240,12 +1240,8 @@ def get_eligibility_super_connector(client, payer_id, provider_last_name, search
         pass
 
     if not endpoint_name:
-        # Fallback to legacy UHCAPI super connector path for backward compatibility
-        endpoint_name = 'UHCAPI'
-        try:
-            url_extension = endpoints_cfg.get(endpoint_name, {}).get('additional_endpoints', {}).get('eligibility_super_connector')
-        except Exception:
-            url_extension = None
+        # No fallback from this function; surface configuration error
+        raise ValueError("OPTUMAI eligibility endpoint not configured")
 
     # Validate payer_id against the selected endpoint's list
     # - If OPTUMAI is used, allow the augmented list (includes LIFE1, WELM2, etc.).
@@ -1258,17 +1254,17 @@ def get_eligibility_super_connector(client, payer_id, provider_last_name, search
     if not url_extension:
         raise ValueError("Eligibility endpoint not configured for {}".format(endpoint_name))
 
-    # Debug/trace: indicate which endpoint/path is being used for the Super Connector call
+    # Debug/trace: indicate that OPTUMAI eligibility path is active
     try:
         MediLink_ConfigLoader.log(
-            "Super Connector eligibility using endpoint '{}' with path '{}'".format(endpoint_name, url_extension),
+            "Eligibility using OPTUMAI endpoint with path '{}'".format(url_extension),
             level="INFO",
             console_output=CONSOLE_LOGGING
         )
     except Exception:
         pass
     try:
-        print("[Eligibility] Using endpoint: {} (path: {})".format(endpoint_name, url_extension))
+        print("[Eligibility] Using OPTUMAI (path: {})".format(url_extension))
     except Exception:
         pass
     
@@ -1405,36 +1401,8 @@ def get_eligibility_super_connector(client, payer_id, provider_last_name, search
         except Exception:
             pass
 
-        # Progressive hardening: allow disabling fallback to UHC via config
-        try:
-            disable_fallback = False
-            try:
-                disable_fallback = bool(medi.get('optumai_disable_fallback', False))
-            except Exception:
-                disable_fallback = False
-            if not disable_fallback and endpoint_name == 'OPTUMAI':
-                fallback_url = endpoints_cfg.get('UHCAPI', {}).get('additional_endpoints', {}).get('eligibility_super_connector')
-                if fallback_url:
-                    try:
-                        MediLink_ConfigLoader.log(
-                            "OPTUMAI call failed. Falling back to UHCAPI path '{}'".format(fallback_url),
-                            level="WARNING",
-                            console_output=CONSOLE_LOGGING
-                        )
-                    except Exception:
-                        pass
-                    try:
-                        print("[Eligibility] Fallback to UHCAPI (path: {})".format(fallback_url))
-                    except Exception:
-                        pass
-                    response = client.make_api_call('UHCAPI', 'POST', fallback_url, params=None, data=graphql_body, headers=headers)
-                else:
-                    raise
-            else:
-                raise
-        except Exception:
-            # Propagate original error if fallback not possible or also fails
-            raise
+        # No fallback from this function; re-raise so callers can handle or try legacy explicitly
+        raise
     
     # Transform GraphQL response to match REST API format
     # This ensures the calling code doesn't know the difference
@@ -1446,7 +1414,7 @@ def get_eligibility_super_connector(client, payer_id, provider_last_name, search
         if sc_status and sc_status != '200':
             msg = transformed_response.get('message')
             MediLink_ConfigLoader.log(
-                "Super Connector transformed response status: {} msg: {}".format(sc_status, msg),
+                "OPTUMAI eligibility transformed response status: {} msg: {}".format(sc_status, msg),
                 level="INFO",
                 console_output=CONSOLE_LOGGING
             )
@@ -1464,6 +1432,22 @@ def get_eligibility_super_connector(client, payer_id, provider_last_name, search
                     print("[Eligibility] GraphQL error code={} desc={}".format(code, desc))
                 except Exception:
                     pass
+
+            # Terminal self-help hints for auth/authorization cases
+            # Non-throwing hint emitter (kept outside core logic path)
+            def _emit_hint_for_status(status_str):
+                try:
+                    if status_str == '401':
+                        print("[Eligibility] Hint: Authentication failed. Verify client credentials/token and endpoint config.")
+                    elif status_str == '403':
+                        print("[Eligibility] Hint: Access denied. Verify providerTaxId/TIN and account permissions/roles for endpoint.")
+                except Exception:
+                    pass
+
+            try:
+                _emit_hint_for_status(str(sc_status))
+            except Exception:
+                pass
     except Exception:
         pass
     

MediCafe/error_reporter.py

@@ -1,12 +1,20 @@
-import os, sys, time, json, zipfile, hashlib, platform
+import base64
+import hashlib
+import json
+import os
+import platform
+import sys
+import time
+import zipfile
 
-try:
-	import requests
-except Exception:
-	requests = None
+import requests
 
-from MediCafe.MediLink_ConfigLoader import load_configuration, log as mc_log
+from email.mime.application import MIMEApplication
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
 
+from MediCafe.MediLink_ConfigLoader import load_configuration, log as mc_log
+from MediLink.MediLink_Gmail import get_access_token
 
 ASCII_SAFE_REPLACEMENTS = [
 	('"', '"'),
@@ -95,7 +103,7 @@ def _compute_report_id(zip_path):
 		return 'mc-{}-{}'.format(int(time.time()), '000000000000')
 
 
-def collect_support_bundle(include_traceback=True, max_log_lines=2000):
+def collect_support_bundle(include_traceback=True, max_log_lines=500):
 	config, _ = load_configuration()
 	medi = config.get('MediLink_Config', {})
 	local_storage_path = medi.get('local_storage_path', '.')
@@ -140,12 +148,29 @@ def collect_support_bundle(include_traceback=True, max_log_lines=2000):
 				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
+			# Get latest WinSCP log
+			upload_log = os.path.join(local_storage_path, 'winscp_upload.log')
+			download_log = os.path.join(local_storage_path, 'winscp_download.log')
+			winscp_logs = [(p, os.path.getmtime(p)) for p in [upload_log, download_log] if os.path.exists(p)]
+			if winscp_logs:
+				latest_winscp = max(winscp_logs, key=lambda x: x[1])[0]
+				winscp_tail = _tail_file(latest_winscp, max_log_lines) if latest_winscp else ''
+				winscp_tail = _redact(winscp_tail)
+			else:
+				winscp_tail = ''
+			if winscp_tail:
+				z.writestr('winscp_log_tail.txt', winscp_tail)
 	except Exception as e:
 		mc_log('Error creating support bundle: {}'.format(e), level='ERROR')
 		return None
 
+	bundle_size = os.path.getsize(zip_path)
+	if bundle_size > 1572864:
+		os.remove(zip_path)
+		mc_log('Bundle too large ({} bytes) - discarded'.format(bundle_size), level='WARNING')
+		return None
+	return zip_path
+
 
 def _first_line(text):
 	try:
@@ -158,14 +183,6 @@ def _first_line(text):
 		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__
@@ -174,102 +191,6 @@ def _get_version():
 		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()
@@ -285,3 +206,59 @@ def capture_unhandled_traceback(exc_type, exc_value, exc_traceback):
 	except Exception:
 		pass
 
+def submit_support_bundle_email(zip_path=None, include_traceback=True):
+    if not zip_path:
+        zip_path = collect_support_bundle(include_traceback)
+        if not zip_path:
+            mc_log("Failed to create bundle.", level="ERROR")
+            return False
+    bundle_size = os.path.getsize(zip_path)
+    if bundle_size > 1572864:
+        mc_log("Bundle too large ({} bytes) - discarding.".format(bundle_size), level="WARNING")
+        os.remove(zip_path)
+        return False
+    config, _ = load_configuration()
+    email_config = config.get('MediLink_Config', {}).get('error_reporting', {}).get('email', {})
+    if not email_config.get('enabled', False):
+        mc_log("Email reporting disabled.", level="INFO")
+        return False
+    to_emails = email_config.get('to', [])
+    subject_prefix = email_config.get('subject_prefix', 'MediCafe Error Report')
+    access_token = get_access_token()
+    if not access_token:
+        mc_log("No access token - authenticate first.", level="ERROR")
+        return False
+    mc_log("Building email...", level="INFO")
+    msg = MIMEMultipart()
+    msg['To'] = ', '.join(to_emails)
+    msg['Subject'] = '{} - {}'.format(subject_prefix, time.strftime('%Y%m%d_%H%M%S'))
+    with open(zip_path, 'rb') as f:
+        attach = MIMEApplication(f.read(), _subtype='zip')
+        attach.add_header('Content-Disposition', 'attachment', filename=os.path.basename(zip_path))
+        msg.attach(attach)
+    body = "Error report attached."
+    msg.attach(MIMEText(body, 'plain'))
+    raw = base64.urlsafe_b64encode(msg.as_bytes()).decode()
+    mc_log("Sending report...", level="INFO")
+    headers = {'Authorization': 'Bearer {}'.format(access_token), 'Content-Type': 'application/json'}
+    data = {'raw': raw}
+    resp = requests.post('https://gmail.googleapis.com/gmail/v1/users/me/messages/send', headers=headers, json=data)
+    if resp.status_code == 200:
+        mc_log("Report sent successfully!", level="INFO")
+        os.remove(zip_path)
+        return True
+    else:
+        mc_log("Failed to send: {} - {}".format(resp.status_code, resp.text), level="ERROR")
+        return False
+
+def email_error_report_flow():
+    try:
+        sent = submit_support_bundle_email(zip_path=None, include_traceback=True)
+        return 0 if sent else 1
+    except Exception as e:
+        mc_log("[ERROR] Exception during email report flow: {0}".format(e), level="ERROR")
+        return 1
+
+if __name__ == "__main__":
+    raise SystemExit(email_error_report_flow())
+

MediCafe/graphql_utils.py

@@ -268,6 +268,36 @@ class GraphQLQueryBuilder:
             }
         }
 
+def _map_graphql_error_to_status_message(error):
+    """Map provider GraphQL error to (statuscode, message) using simple heuristics.
+    Python 3.4-compatible; avoids dependencies and centralizes logic.
+    """
+    try:
+        if not isinstance(error, dict):
+            return '500', 'GraphQL error: unknown format'
+        code = ((error.get('extensions', {}) or {}).get('code') or
+                error.get('code') or 'GRAPHQL_ERROR')
+        msg = (error.get('message') or error.get('description') or 'GraphQL error')
+        code_upper = str(code).upper()
+        msg_lower = str(msg).lower()
+
+        # 401 auth failures
+        if (code == 'UNAUTHORIZED_AUTHENTICATION_FAILED' or
+                ('UNAUTH' in code_upper) or
+                ('AUTHENTICATION' in code_upper)):
+            return '401', 'Authentication failed: {}'.format(msg)
+
+        # 403 authorization/access issues
+        if ('FORBIDDEN' in code_upper) or ('AUTHORIZATION' in code_upper) or ('ACCESS_DENIED' in code_upper) or \
+           ('forbidden' in msg_lower) or ('permission' in msg_lower):
+            return '403', 'Authorization failed: {}'.format(msg)
+
+        # Default
+        return '500', '{}: {}'.format(code, msg)
+    except Exception:
+        return '500', 'GraphQL error: unknown'
+
+
 class GraphQLResponseTransformer:
     """Transforms GraphQL responses to match REST API format"""
     
@@ -284,24 +314,15 @@ class GraphQLResponseTransformer:
             Transformed response matching REST API format
         """
         try:
-            # Check for authentication errors first
+            # Check for authentication/authorization errors first
             if 'errors' in graphql_response:
                 error = graphql_response['errors'][0]
-                error_code = error.get('extensions', {}).get('code', 'UNKNOWN_ERROR')
-                error_message = error.get('message', 'Unknown error')
-                
-                if error_code == 'UNAUTHORIZED_AUTHENTICATION_FAILED':
-                    return {
-                        'statuscode': '401',
-                        'message': 'Authentication failed: {}'.format(error_message),
-                        'rawGraphQLResponse': graphql_response
-                    }
-                else:
-                    return {
-                        'statuscode': '500',
-                        'message': 'GraphQL error: {} - {}'.format(error_code, error_message),
-                        'rawGraphQLResponse': graphql_response
-                    }
+                statuscode, mapped_msg = _map_graphql_error_to_status_message(error)
+                return {
+                    'statuscode': statuscode,
+                    'message': mapped_msg,
+                    'rawGraphQLResponse': graphql_response
+                }
             
             # Check if GraphQL response has data
             if 'data' not in graphql_response:
@@ -544,12 +565,10 @@ class GraphQLResponseTransformer:
             # Handle GraphQL errors
             if isinstance(graphql_response, dict) and 'errors' in graphql_response:
                 first_err = graphql_response['errors'][0] if graphql_response['errors'] else {}
-                code = (first_err.get('extensions', {}) or {}).get('code') or first_err.get('code') or 'GRAPHQL_ERROR'
-                msg = first_err.get('message') or first_err.get('description') or 'GraphQL error'
-                status = '401' if 'AUTH' in str(code).upper() else '500'
+                statuscode, mapped_msg = _map_graphql_error_to_status_message(first_err)
                 return {
-                    'statuscode': status,
-                    'message': '{}: {}'.format(code, msg),
+                    'statuscode': statuscode,
+                    'message': mapped_msg,
                     'rawGraphQLResponse': graphql_response
                 }