Spaces:

sonuprasad23
/

quantum-bot

Sleeping

App Files Files Community

sonuprasad23 commited on Sep 14, 2025

Commit

5515ec2

1 Parent(s): 5078a4a

Almost Done

Browse files

Files changed (2) hide show

server.py +70 -35
worker.py +61 -68

server.py CHANGED Viewed

@@ -8,6 +8,7 @@ import os
 import base64
 import json
 import re
 from datetime import datetime
 from flask import Flask, Response, request, jsonify
 from flask_socketio import SocketIO, emit
@@ -21,6 +22,10 @@ from dotenv import load_dotenv
 load_dotenv()
 app = Flask(__name__)
 app.config['SECRET_KEY'] = 'secret-key-for-hillside-automation'
 FRONTEND_ORIGIN = os.getenv('FRONTEND_URL', 'https://quantbot.netlify.app')
@@ -30,27 +35,24 @@ socketio = SocketIO(app, cors_allowed_origins=[FRONTEND_ORIGIN, "http://localhos
 bot_instance = None
 session_data = {}
-def log(message):
-    print(f"[Server Log] {datetime.now().strftime('%H:%M:%S')} - {message}")
 class GmailApiService:
     def __init__(self):
         self.sender_email = os.getenv('EMAIL_SENDER'); self.service = None
         try:
             from google.oauth2 import service_account; from googleapiclient.discovery import build
             base64_creds = os.getenv('GDRIVE_SA_KEY_BASE64')
-            if not base64_creds: log("WARNING: GDRIVE_SA_KEY_BASE64 not found."); return
             creds_json = base64.b64decode(base64_creds).decode('utf-8'); creds_dict = json.loads(creds_json)
             credentials = service_account.Credentials.from_service_account_info(creds_dict, scopes=['https://www.googleapis.com/auth/gmail.send'])
             if self.sender_email: credentials = credentials.with_subject(self.sender_email)
             self.service = build('gmail', 'v1', credentials=credentials)
-            log("Gmail API Service initialized successfully")
-        except Exception as e: log(f"Gmail API Error: {e}")
     def create_professional_email_template(self, subject, status_text, stats, custom_name):
         status_color = "#28a745" if "completed" in status_text else "#ffc107" if "terminated" in status_text else "#dc3545"
         current_date = datetime.now().strftime("%B %d, %Y at %I:%M %p")
-        return f"""
         <!DOCTYPE html>
         <html><head><title>{subject}</title><style>
         body{{font-family: 'Segoe UI', sans-serif; background-color: #f8f8f8; color: #2c2c2c;}}
@@ -81,6 +83,7 @@ class GmailApiService:
         <li><b>{custom_name}_Skipped.csv:</b> A filtered list of patients that were skipped due to having no PRN.</li></ul></div></div>
         <div class="footer"><p>&copy; {datetime.now().year} Hillside Automation. This is an automated report.</p></div></div></body></html>
         """
     def send_report(self, recipients, subject, body, attachments=None):
         if not self.service or not recipients: return False
@@ -95,8 +98,9 @@ class GmailApiService:
                     message.attach(part)
             raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode('utf-8')
             sent_message = self.service.users().messages().send(userId='me', body={'raw': raw_message}).execute()
-            log(f"Email sent successfully! Message ID: {sent_message['id']}"); return True
-        except Exception as e: log(f"Failed to send email: {e}"); return False
 class GoogleDriveService:
     def __init__(self):
@@ -108,8 +112,8 @@ class GoogleDriveService:
             creds_json = base64.b64decode(base64_creds).decode('utf-8'); creds_dict = json.loads(creds_json)
             self.creds = service_account.Credentials.from_service_account_info(creds_dict, scopes=['https://www.googleapis.com/auth/drive'])
             self.service = build('drive', 'v3', credentials=self.creds)
-            log("Google Drive Service initialized.")
-        except Exception as e: log(f"G-Drive ERROR: {e}")
     def upload_file(self, filename, file_content):
         if not self.service: return False
@@ -118,8 +122,8 @@ class GoogleDriveService:
             file_metadata = {'name': filename, 'parents': [self.folder_id]}
             media = MediaIoBaseUpload(io.BytesIO(file_content.encode('utf-8')), mimetype='text/csv', resumable=True)
             self.service.files().create(body=file_metadata, media_body=media, fields='id').execute()
-            log(f"File '{filename}' uploaded to G-Drive."); return True
-        except Exception as e: log(f"G-Drive ERROR: {e}"); return False
 email_service = GmailApiService()
 drive_service = GoogleDriveService()
@@ -133,26 +137,30 @@ def run_automation_process(session_id):
     global bot_instance
     results = []; is_terminated = False; is_crash = False
     try:
         data = session_data.get(session_id, {}); patient_data = data.get('patient_data'); workflow = data.get('workflow')
         if not patient_data: raise ValueError("No patient data prepared.")
         socketio.emit('initial_stats', {'total': len(patient_data)})
-        results = bot_instance.process_patient_list(patient_data, workflow, data)
         is_terminated = bot_instance.termination_event.is_set()
     except Exception as e:
-        log(f"Fatal error in automation thread: {e}"); is_crash = True
         socketio.emit('error', {'message': f'A fatal error occurred: {e}'})
     finally:
-        socketio.emit('micro_status_update', {'message': 'Generating final reports...'})
         generate_and_send_reports(session_id, results, is_crash_report=is_crash, is_terminated=is_terminated)
         if bot_instance: bot_instance.shutdown(); bot_instance = None
         if session_id in session_data: del session_data[session_id]
 def generate_and_send_reports(session_id, results, is_crash_report=False, is_terminated=False):
-    log("Preparing final reports...")
     data = session_data.get(session_id, {})
-    if not data: log("Session data expired, cannot generate report."); return
     full_df = pd.DataFrame(data.get('patient_data_for_report'))
     if results:
@@ -179,14 +187,14 @@ def generate_and_send_reports(session_id, results, is_crash_report=False, is_ter
         bad_report_name: bad_df.to_csv(index=False),
         skipped_report_name: skipped_df.to_csv(index=False)
     }
-    status_text = "terminated by user" if is_terminated else "crashed" if is_crash_report else "completed successfully"
     stats = {
         'total': len(full_df), 'processed': len(results),
         'successful': len(full_df[full_df['Status'] == 'Done']),
         'bad': len(bad_df), 'skipped': len(skipped_df)
     }
     subject = f"Automation Report [{status_text.upper()}]: {custom_name}"
-    professional_body = email_service.create_professional_email_template(subject, status_text.capitalize(), stats, custom_name)
     email_service.send_report(data.get('emails'), subject, professional_body, attachments)
     socketio.emit('process_complete', {'message': f'Process {status_text}. Report sent.'})
@@ -200,9 +208,39 @@ def extract_patient_name(raw_name):
     name_only = raw_name.split('DOB')[0].strip()
     return re.sub(r'[:\d\-\s]+$', '', name_only).strip()
 @socketio.on('connect')
 def handle_connect():
-    log('Frontend connected.')
     emit('email_list', {'emails': get_email_list()})
 @socketio.on('get_email_list')
@@ -212,7 +250,6 @@ def handle_get_email_list():
 @socketio.on('initialize_session')
 def handle_init(data):
     session_id = 'user_session'
-    log("Received initialize_session event.")
     session_data.setdefault(session_id, {})
     session_data[session_id].update({
         'emails': data.get('emails', []), 'filename': data.get('filename'),
@@ -251,17 +288,16 @@ def handle_init(data):
         session_data[session_id]['patient_data'] = master_df.to_dict('records')
         socketio.emit('data_processed')
-        log(f"Data prepared. Total records: {len(master_df)}")
     except Exception as e:
-        log(f"ERROR during file processing: {e}")
         emit('error', {'message': f'Error preparing data: {e}'})
 @socketio.on('start_login')
 def handle_login(credentials):
-    log("Login process started.")
     global bot_instance
     if bot_instance: bot_instance.shutdown()
-    bot_instance = QuantumBot(socketio, app)
     is_success, error_message = bot_instance.initialize_driver()
     if is_success:
         is_login_success, login_error = bot_instance.login(credentials['username'], credentials['password'])
@@ -272,7 +308,6 @@ def handle_login(credentials):
 @socketio.on('submit_otp')
 def handle_otp(data):
-    log("OTP submission received.")
     if not bot_instance: return emit('error', {'message': 'Bot not initialized.'})
     is_success, error_message = bot_instance.submit_otp(data['otp'])
     if is_success:
@@ -283,12 +318,12 @@ def handle_otp(data):
 @socketio.on('terminate_process')
 def handle_terminate():
-    if bot_instance: log("Termination signal received."); bot_instance.stop()
 if __name__ == '__main__':
-    print("====================================================================")
-    print("  🤗 Hillside Automation - Definitive Dual-Workflow Version")
-    print(f"  Frontend URL: {FRONTEND_ORIGIN}")
-    print(f"  Port: {os.getenv('PORT', 7860)}")
-    print("====================================================================")
     socketio.run(app, host='0.0.0.0', port=int(os.getenv('PORT', 7860)))

 import base64
 import json
 import re
+import logging
 from datetime import datetime
 from flask import Flask, Response, request, jsonify
 from flask_socketio import SocketIO, emit
 load_dotenv()
+# --- Definitive Logging Setup ---
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 app = Flask(__name__)
 app.config['SECRET_KEY'] = 'secret-key-for-hillside-automation'
 FRONTEND_ORIGIN = os.getenv('FRONTEND_URL', 'https://quantbot.netlify.app')
 bot_instance = None
 session_data = {}
 class GmailApiService:
     def __init__(self):
         self.sender_email = os.getenv('EMAIL_SENDER'); self.service = None
         try:
             from google.oauth2 import service_account; from googleapiclient.discovery import build
             base64_creds = os.getenv('GDRIVE_SA_KEY_BASE64')
+            if not base64_creds: logger.warning("GDRIVE_SA_KEY_BASE64 not found in secrets."); return
             creds_json = base64.b64decode(base64_creds).decode('utf-8'); creds_dict = json.loads(creds_json)
             credentials = service_account.Credentials.from_service_account_info(creds_dict, scopes=['https://www.googleapis.com/auth/gmail.send'])
             if self.sender_email: credentials = credentials.with_subject(self.sender_email)
             self.service = build('gmail', 'v1', credentials=credentials)
+            logger.info("Gmail API Service initialized successfully")
+        except Exception: logger.exception("Gmail API Service initialization failed")
     def create_professional_email_template(self, subject, status_text, stats, custom_name):
         status_color = "#28a745" if "completed" in status_text else "#ffc107" if "terminated" in status_text else "#dc3545"
         current_date = datetime.now().strftime("%B %d, %Y at %I:%M %p")
+        html_template = f"""
         <!DOCTYPE html>
         <html><head><title>{subject}</title><style>
         body{{font-family: 'Segoe UI', sans-serif; background-color: #f8f8f8; color: #2c2c2c;}}
         <li><b>{custom_name}_Skipped.csv:</b> A filtered list of patients that were skipped due to having no PRN.</li></ul></div></div>
         <div class="footer"><p>&copy; {datetime.now().year} Hillside Automation. This is an automated report.</p></div></div></body></html>
         """
+        return html_template
     def send_report(self, recipients, subject, body, attachments=None):
         if not self.service or not recipients: return False
                     message.attach(part)
             raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode('utf-8')
             sent_message = self.service.users().messages().send(userId='me', body={'raw': raw_message}).execute()
+            logger.info(f"Email sent successfully! Message ID: {sent_message['id']}")
+            return True
+        except Exception: logger.exception("Failed to send email"); return False
 class GoogleDriveService:
     def __init__(self):
             creds_json = base64.b64decode(base64_creds).decode('utf-8'); creds_dict = json.loads(creds_json)
             self.creds = service_account.Credentials.from_service_account_info(creds_dict, scopes=['https://www.googleapis.com/auth/drive'])
             self.service = build('drive', 'v3', credentials=self.creds)
+            logger.info("Google Drive Service initialized successfully.")
+        except Exception: logger.exception("G-Drive ERROR: Could not initialize service")
     def upload_file(self, filename, file_content):
         if not self.service: return False
             file_metadata = {'name': filename, 'parents': [self.folder_id]}
             media = MediaIoBaseUpload(io.BytesIO(file_content.encode('utf-8')), mimetype='text/csv', resumable=True)
             self.service.files().create(body=file_metadata, media_body=media, fields='id').execute()
+            logger.info(f"File '{filename}' uploaded to Google Drive."); return True
+        except Exception: logger.exception("G-Drive ERROR: File upload failed"); return False
 email_service = GmailApiService()
 drive_service = GoogleDriveService()
     global bot_instance
     results = []; is_terminated = False; is_crash = False
     try:
+        logger.info(f"Starting automation thread for session: {session_id}")
         data = session_data.get(session_id, {}); patient_data = data.get('patient_data'); workflow = data.get('workflow')
         if not patient_data: raise ValueError("No patient data prepared.")
         socketio.emit('initial_stats', {'total': len(patient_data)})
+        if workflow == 'void':
+            results = bot_instance.process_patient_list(patient_data, 'void')
+        elif workflow == 'refund':
+            date_range = {'start_date': data.get('start_date'), 'end_date': data.get('end_date')}
+            results = bot_instance.process_patient_list(patient_data, 'refund', date_range)
         is_terminated = bot_instance.termination_event.is_set()
     except Exception as e:
+        logger.exception("Fatal error in automation thread")
+        is_crash = True
         socketio.emit('error', {'message': f'A fatal error occurred: {e}'})
     finally:
+        logger.info("Automation thread finished. Generating final reports...")
         generate_and_send_reports(session_id, results, is_crash_report=is_crash, is_terminated=is_terminated)
         if bot_instance: bot_instance.shutdown(); bot_instance = None
         if session_id in session_data: del session_data[session_id]
 def generate_and_send_reports(session_id, results, is_crash_report=False, is_terminated=False):
+    logger.info(f"Preparing final reports for session {session_id}. Terminated: {is_terminated}, Crashed: {is_crash}")
     data = session_data.get(session_id, {})
+    if not data: logger.error("Session data not found, cannot generate report."); return
     full_df = pd.DataFrame(data.get('patient_data_for_report'))
     if results:
         bad_report_name: bad_df.to_csv(index=False),
         skipped_report_name: skipped_df.to_csv(index=False)
     }
+    status_text = "terminated by user" if is_terminated else "crashed due to an error" if is_crash_report else "completed successfully"
     stats = {
         'total': len(full_df), 'processed': len(results),
         'successful': len(full_df[full_df['Status'] == 'Done']),
         'bad': len(bad_df), 'skipped': len(skipped_df)
     }
     subject = f"Automation Report [{status_text.upper()}]: {custom_name}"
+    professional_body = email_service.create_professional_email_template(subject, status_text, stats, custom_name)
     email_service.send_report(data.get('emails'), subject, professional_body, attachments)
     socketio.emit('process_complete', {'message': f'Process {status_text}. Report sent.'})
     name_only = raw_name.split('DOB')[0].strip()
     return re.sub(r'[:\d\-\s]+$', '', name_only).strip()
+@app.route('/process_files_for_automation', methods=['POST'])
+def handle_file_processing():
+    session_id = 'user_session'
+    try:
+        if 'app_data' not in request.files or 'quantum_data' not in request.files:
+            return jsonify({"error": "Both files are required."}), 400
+        df_app = pd.read_excel(request.files['app_data']) if request.files['app_data'].filename.endswith('.xlsx') else pd.read_csv(request.files['app_data'])
+        df_quantum = pd.read_excel(request.files['quantum_data']) if request.files['quantum_data'].filename.endswith('.xlsx') else pd.read_csv(request.files['quantum_data'])
+        if 'Patient Name' not in df_app.columns or 'PRN' not in df_app.columns: raise ValueError("App Data must contain 'Patient Name' and 'PRN' columns.")
+        if 'Name' not in df_quantum.columns: raise ValueError("Quantum Data must contain a 'Name' column.")
+        df_app_filtered = df_app.dropna(subset=['PRN']); df_app_filtered = df_app_filtered[df_app_filtered['PRN'].astype(str).str.strip() != '']
+        prn_lookup_dict = {extract_patient_name(row['Patient Name']): row['PRN'] for _, row in df_app_filtered.iterrows()}
+        master_df = df_quantum.copy()
+        master_df['PRN'] = master_df['Name'].apply(lambda name: prn_lookup_dict.get(name, ""))
+        master_df['Status'] = ''
+        session_data[session_id]['patient_data_for_report'] = master_df
+        session_data[session_id]['patient_data'] = master_df.to_dict('records')
+        socketio.emit('data_processed')
+        logger.info(f"Data prepared for session {session_id}. Total records: {len(master_df)}")
+        return jsonify({"message": "Data processed successfully."})
+    except Exception as e:
+        logger.exception("Error during file processing")
+        return jsonify({"error": str(e)}), 500
 @socketio.on('connect')
 def handle_connect():
+    logger.info('Frontend connected.')
     emit('email_list', {'emails': get_email_list()})
 @socketio.on('get_email_list')
 @socketio.on('initialize_session')
 def handle_init(data):
     session_id = 'user_session'
     session_data.setdefault(session_id, {})
     session_data[session_id].update({
         'emails': data.get('emails', []), 'filename': data.get('filename'),
         session_data[session_id]['patient_data'] = master_df.to_dict('records')
         socketio.emit('data_processed')
+        logger.info(f"Data prepared for session {session_id}. Total records: {len(master_df)}")
     except Exception as e:
+        logger.exception("Error preparing data")
         emit('error', {'message': f'Error preparing data: {e}'})
 @socketio.on('start_login')
 def handle_login(credentials):
     global bot_instance
     if bot_instance: bot_instance.shutdown()
+    bot_instance = QuantumBot(socketio, app, logger)
     is_success, error_message = bot_instance.initialize_driver()
     if is_success:
         is_login_success, login_error = bot_instance.login(credentials['username'], credentials['password'])
 @socketio.on('submit_otp')
 def handle_otp(data):
     if not bot_instance: return emit('error', {'message': 'Bot not initialized.'})
     is_success, error_message = bot_instance.submit_otp(data['otp'])
     if is_success:
 @socketio.on('terminate_process')
 def handle_terminate():
+    if bot_instance: logger.info("Termination signal received from frontend."); bot_instance.stop()
 if __name__ == '__main__':
+    logger.info("====================================================================")
+    logger.info("  🤗 Hillside Automation - Definitive Dual-Workflow Version")
+    logger.info(f"  Frontend URL: {FRONTEND_ORIGIN}")
+    logger.info(f"  Port: {os.getenv('PORT', 7860)}")
+    logger.info("====================================================================")
     socketio.run(app, host='0.0.0.0', port=int(os.getenv('PORT', 7860)))

worker.py CHANGED Viewed

@@ -14,26 +14,19 @@ from selenium.webdriver.support import expected_conditions as EC
 from selenium.common.exceptions import TimeoutException
 class QuantumBot:
-    def __init__(self, socketio, app):
         self.socketio = socketio; self.app = app; self.driver = None
         self.DEFAULT_TIMEOUT = 30; self.termination_event = threading.Event()
-    def _log(self, message):
-        print(f"[Bot Log] {datetime.now().strftime('%H:%M:%S')} - {message}")
-    def micro_status(self, message):
-        self._log(message)
-        with self.app.app_context():
-            self.socketio.emit('micro_status_update', {'message': message})
     def _kill_chrome_processes(self):
         try:
-            self._log("Attempting to kill stale chromium processes...")
             subprocess.run(['pkill', '-f', 'chromium'], check=True, timeout=5)
             time.sleep(1)
-            self._log("...Stale processes cleared.")
         except Exception as e:
-            self._log(f"Info: Could not kill chrome processes (this is normal if none were running): {e}")
     def initialize_driver(self):
         try:
@@ -47,11 +40,19 @@ class QuantumBot:
             options.add_argument(f"--user-agent={user_agent}")
             service = ChromeService(executable_path="/usr/bin/chromedriver")
             self.driver = webdriver.Chrome(service=service, options=options)
-            self.driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {'source': "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"})
             return True, None
-        except Exception as e:
-            error_message = f"Message: {str(e)}"; self._log(f"CRITICAL ERROR in WebDriver Initialization: {error_message}")
-            return False, error_message
     def stop(self):
         self.micro_status("Termination signal received..."); self.termination_event.set()
@@ -65,11 +66,11 @@ class QuantumBot:
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.ID, "login"))).click()
             self.micro_status("Waiting for OTP screen...")
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.presence_of_element_located((By.ID, "code1")))
-            self._log("...Login step successful, OTP screen detected.")
             return True, None
-        except Exception as e:
-            error_message = f"Error during login: {str(e)}"; self._log(f"ERROR during login: {error_message}")
-            return False, error_message
     def submit_otp(self, otp):
         try:
@@ -78,18 +79,19 @@ class QuantumBot:
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.ID, "login"))).click()
             self.micro_status("Verifying login success...")
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//span[text()='Payments']")))
-            self._log("...OTP submission and login verification successful.")
             return True, None
-        except Exception as e:
-            error_message = f"Error during OTP submission: {str(e)}"; self._log(f"ERROR during OTP submission: {error_message}")
-            return False, error_message
     def _get_calendar_months(self):
         try:
             titles = self.driver.find_elements(By.XPATH, "//div[contains(@class, 'vc-title')]")
             if not titles: return []
             return [datetime.strptime(title.text, "%B %Y") for title in titles]
-        except Exception: return []
     def _select_date_in_calendar(self, target_date):
         target_month_str = target_date.strftime("%B %Y")
@@ -98,8 +100,7 @@ class QuantumBot:
             visible_months = self._get_calendar_months()
             if not visible_months: raise Exception("Calendar months not visible.")
             if any(d.strftime("%B %Y") == target_month_str for d in visible_months):
-                self._log(f"...Found month. Selecting day {target_date.day}.")
-                day_format = "%-d"
                 day_xpath = f"//span[@aria-label='{target_date.strftime(f'%A, %B {day_format}, %Y')}']"
                 day_element = WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable((By.XPATH, day_xpath)))
                 self.driver.execute_script("arguments[0].click();", day_element); return
@@ -114,28 +115,21 @@ class QuantumBot:
         self._select_date_in_calendar(start_date); time.sleep(1)
         self._select_date_in_calendar(end_date); time.sleep(1)
         self.driver.find_element(By.TAG_NAME, "body").click(); time.sleep(3)
-        self._log("...Date range set successfully.")
     def process_patient_list(self, patient_data, workflow, date_range=None):
         results = []
-        records_to_process = list(patient_data)
         if workflow == 'refund':
-            try:
-                self._log(f"Setting up Refund workflow for date range {date_range['start_date']} to {date_range['end_date']}")
-                self.driver.get("https://gateway.quantumepay.com/credit-card/refund")
-                self._set_date_range(date_range['start_date'], date_range['end_date'])
-            except Exception as e:
-                self._log(f"FATAL ERROR during Refund setup: {e}. Aborting process.")
-                return results # Return empty results if setup fails
-        for index, record in enumerate(records_to_process):
-            if self.termination_event.is_set(): self._log("Termination detected."); break
             patient_name = record['Name']; patient_prn = record.get('PRN', '')
             if not patient_prn or not str(patient_prn).strip():
-                status = 'Skipped - No PRN'
-                self.micro_status(f"Skipping '{patient_name}' (No PRN)."); time.sleep(0.1)
             else:
-                self.micro_status(f"Processing '{patient_name}' ({index + 1}/{len(records_to_process)})...")
                 if workflow == 'void':
                     status = self._process_single_void(patient_name, patient_prn)
                 elif workflow == 'refund':
@@ -143,59 +137,58 @@ class QuantumBot:
             results.append({'Name': patient_name, 'PRN': patient_prn, 'Status': status})
             with self.app.app_context():
                 self.socketio.emit('log_update', {'name': patient_name, 'prn': patient_prn, 'status': status})
-                self.socketio.emit('stats_update', {'processed': len(results), 'remaining': len(records_to_process) - len(results), 'status': status})
         return results
     def _perform_core_patient_processing(self, patient_name, patient_prn):
         try:
-            self.micro_status(f"Searching for '{patient_name}'..."); search_box = WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//input[@placeholder='Search']")))
-            search_box.click(); time.sleep(0.5); search_box.clear(); time.sleep(0.5); search_box.send_keys(patient_name); time.sleep(3)
-            self._log("...Search complete.")
-            self.micro_status("Opening transaction details..."); WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, f"//tr[contains(., \"{patient_name}\")]//button[@data-v-b6b33fa0]"))).click()
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.LINK_TEXT, "Transaction Detail"))).click(); self._log("...Details opened.")
-            self.micro_status("Adding to Vault..."); WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button/span[normalize-space()='Add to Vault']"))).click()
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//div[@class='modal-footer']//button/span[normalize-space()='Confirm']"))).click(); self._log("...Vault confirmed.")
             try:
-                self.micro_status("Verifying success and entering data...")
                 company_input = WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable((By.NAME, "company_name")))
-                company_input.click(); company_input.send_keys(Keys.CONTROL + "a"); company_input.send_keys(Keys.BACK_SPACE); company_input.send_keys(patient_name)
-                self._log("...Company Name entered.")
                 contact_input = WebDriverWait(self.driver, 5).until(EC.element_to_be_clickable((By.NAME, "company_contact")))
                 contact_input.click(); contact_input.send_keys(Keys.CONTROL + "a"); contact_input.send_keys(Keys.BACK_SPACE)
                 contact_input.send_keys(str(patient_prn))
-                self._log("...Contact Name (PRN) entered.")
                 WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button/span[normalize-space()='Save Changes']"))).click()
                 WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Confirm']]"))).click()
-                time.sleep(5); self._log("...Save complete."); return 'Done'
             except TimeoutException:
                 self.micro_status(f"'{patient_name}' is in a bad state, cancelling.")
                 WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Cancel']]"))).click()
                 return 'Bad'
         except Exception as e:
-            self._log(f"ERROR: A step failed for patient '{patient_name}'. Reason: {e}"); return 'Error'
     def _process_single_void(self, patient_name, patient_prn):
         try:
-            self.micro_status(f"Navigating to Void page for '{patient_name}'")
-            self.driver.get("https://gateway.quantumepay.com/credit-card/void")
             return self._perform_core_patient_processing(patient_name, patient_prn)
         except Exception as e:
-            self._log(f"ERROR in Void workflow for {patient_name}: {e}"); return 'Error'
     def _process_single_refund(self, patient_name, patient_prn):
         try:
             return self._perform_core_patient_processing(patient_name, patient_prn)
         except Exception as e:
-            self._log(f"ERROR in Refund workflow for {patient_name}: {e}"); return 'Error'
     def shutdown(self):
         try:
             if self.driver: self.driver.quit()
             self._kill_chrome_processes()
-            self._log("Chrome session closed and cleaned up.")
-        except Exception as e: self._log(f"Error during shutdown: {e}")

 from selenium.common.exceptions import TimeoutException
 class QuantumBot:
+    def __init__(self, socketio, app, logger):
         self.socketio = socketio; self.app = app; self.driver = None
         self.DEFAULT_TIMEOUT = 30; self.termination_event = threading.Event()
+        self.logger = logger
     def _kill_chrome_processes(self):
         try:
+            self.logger.info("Attempting to kill any lingering chromium processes...")
             subprocess.run(['pkill', '-f', 'chromium'], check=True, timeout=5)
             time.sleep(1)
+            self.logger.info("Lingering processes terminated.")
         except Exception as e:
+            self.logger.warning(f"Could not kill chrome processes (this is often normal): {e}")
     def initialize_driver(self):
         try:
             options.add_argument(f"--user-agent={user_agent}")
             service = ChromeService(executable_path="/usr/bin/chromedriver")
             self.driver = webdriver.Chrome(service=service, options=options)
+            self.driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
+                'source': "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
+            })
+            self.logger.info("WebDriver initialized successfully.")
             return True, None
+        except Exception:
+            self.logger.exception("CRITICAL ERROR in WebDriver Initialization")
+            return False, "WebDriver initialization failed. See backend logs for details."
+    def micro_status(self, message):
+        self.logger.info(message)
+        with self.app.app_context():
+            self.socketio.emit('micro_status_update', {'message': message})
     def stop(self):
         self.micro_status("Termination signal received..."); self.termination_event.set()
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.ID, "login"))).click()
             self.micro_status("Waiting for OTP screen...")
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.presence_of_element_located((By.ID, "code1")))
+            self.logger.info("Login successful, OTP screen is visible.")
             return True, None
+        except Exception:
+            self.logger.exception("ERROR during login process")
+            return False, "An error occurred during login. See backend logs."
     def submit_otp(self, otp):
         try:
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.ID, "login"))).click()
             self.micro_status("Verifying login success...")
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//span[text()='Payments']")))
+            self.logger.info("OTP submission successful, dashboard is visible.")
             return True, None
+        except Exception:
+            self.logger.exception("ERROR during OTP submission")
+            return False, "OTP submission failed. See backend logs."
     def _get_calendar_months(self):
         try:
             titles = self.driver.find_elements(By.XPATH, "//div[contains(@class, 'vc-title')]")
             if not titles: return []
             return [datetime.strptime(title.text, "%B %Y") for title in titles]
+        except Exception as e:
+            self.logger.warning(f"Could not get calendar months: {e}"); return []
     def _select_date_in_calendar(self, target_date):
         target_month_str = target_date.strftime("%B %Y")
             visible_months = self._get_calendar_months()
             if not visible_months: raise Exception("Calendar months not visible.")
             if any(d.strftime("%B %Y") == target_month_str for d in visible_months):
+                day_format = "%#d" if os.name == 'nt' else "%-d"
                 day_xpath = f"//span[@aria-label='{target_date.strftime(f'%A, %B {day_format}, %Y')}']"
                 day_element = WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable((By.XPATH, day_xpath)))
                 self.driver.execute_script("arguments[0].click();", day_element); return
         self._select_date_in_calendar(start_date); time.sleep(1)
         self._select_date_in_calendar(end_date); time.sleep(1)
         self.driver.find_element(By.TAG_NAME, "body").click(); time.sleep(3)
     def process_patient_list(self, patient_data, workflow, date_range=None):
+        self.logger.info(f"Starting patient processing for '{workflow}' workflow. Total patients: {len(patient_data)}")
         results = []
         if workflow == 'refund':
+            self._navigate_and_verify("https://gateway.quantumepay.com/credit-card/refund", "//button[.//span[contains(text(), '-')]]")
+            self._set_date_range(date_range['start_date'], date_range['end_date'])
+        for index, record in enumerate(patient_data):
+            if self.termination_event.is_set(): self.logger.info("Termination detected. Ending patient processing loop."); break
             patient_name = record['Name']; patient_prn = record.get('PRN', '')
             if not patient_prn or not str(patient_prn).strip():
+                status = 'Skipped - No PRN'; self.micro_status(f"Skipping '{patient_name}' (No PRN)."); time.sleep(0.1)
             else:
+                self.micro_status(f"Processing '{patient_name}' ({index + 1}/{len(patient_data)})...")
                 if workflow == 'void':
                     status = self._process_single_void(patient_name, patient_prn)
                 elif workflow == 'refund':
             results.append({'Name': patient_name, 'PRN': patient_prn, 'Status': status})
             with self.app.app_context():
                 self.socketio.emit('log_update', {'name': patient_name, 'prn': patient_prn, 'status': status})
+                self.socketio.emit('stats_update', {'processed': len(results), 'remaining': len(patient_data) - len(results), 'status': status})
+        self.logger.info("Finished processing patient list.")
         return results
     def _perform_core_patient_processing(self, patient_name, patient_prn):
         try:
+            self.micro_status(f"Searching for '{patient_name}'...")
+            search_box = WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//input[@placeholder='Search']")))
+            search_box.click(); time.sleep(0.5); search_box.clear(); time.sleep(0.5)
+            search_box.send_keys(patient_name); time.sleep(3)
+            self.micro_status("Opening transaction details...")
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, f"//tr[contains(., \"{patient_name}\")]//button[@data-v-b6b33fa0]"))).click()
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.LINK_TEXT, "Transaction Detail"))).click()
+            self.micro_status("Adding to Vault...")
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button/span[normalize-space()='Add to Vault']"))).click()
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//div[@class='modal-footer']//button/span[normalize-space()='Confirm']"))).click()
             try:
+                self.micro_status("Verifying success and saving data...")
                 company_input = WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable((By.NAME, "company_name")))
+                company_input.clear(); company_input.send_keys(patient_name)
                 contact_input = WebDriverWait(self.driver, 5).until(EC.element_to_be_clickable((By.NAME, "company_contact")))
                 contact_input.click(); contact_input.send_keys(Keys.CONTROL + "a"); contact_input.send_keys(Keys.BACK_SPACE)
                 contact_input.send_keys(str(patient_prn))
                 WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button/span[normalize-space()='Save Changes']"))).click()
                 WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Confirm']]"))).click()
+                time.sleep(5); return 'Done'
             except TimeoutException:
                 self.micro_status(f"'{patient_name}' is in a bad state, cancelling.")
                 WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Cancel']]"))).click()
                 return 'Bad'
         except Exception as e:
+            self.logger.exception(f"An error occurred while processing {patient_name} (core)")
+            return 'Error'
     def _process_single_void(self, patient_name, patient_prn):
         try:
+            self._navigate_and_verify("https://gateway.quantumepay.com/credit-card/void", "//input[@placeholder='Search']")
             return self._perform_core_patient_processing(patient_name, patient_prn)
         except Exception as e:
+            self.logger.exception(f"Error in Void workflow for {patient_name}")
+            return 'Error'
     def _process_single_refund(self, patient_name, patient_prn):
         try:
             return self._perform_core_patient_processing(patient_name, patient_prn)
         except Exception as e:
+            self.logger.exception(f"Error in Refund workflow for {patient_name}")
+            return 'Error'
     def shutdown(self):
         try:
             if self.driver: self.driver.quit()
             self._kill_chrome_processes()
+            self.logger.info("Chrome session closed and cleaned up successfully.")
+        except Exception as e: self.logger.error(f"Error during shutdown: {e}")