Spaces:

sonuprasad23
/

quantum-bot

Sleeping

App Files Files Community

sonuprasad23 commited on Sep 13, 2025

Commit

30ba375

1 Parent(s): c1e4b14

Fixing this

Browse files

Files changed (2) hide show

server.py +37 -48
worker.py +113 -125

server.py CHANGED Viewed

@@ -124,9 +124,7 @@ def generate_and_send_reports(session_id, results, is_crash_report=False, is_ter
     if results:
         result_df = pd.DataFrame(results).set_index('Name')
         full_df.set_index('Name', inplace=True)
-        full_df['Status'] = full_df['Status'].astype('object')
         full_df.update(result_df); full_df.reset_index(inplace=True)
     full_df['Status'].fillna('Not Processed', inplace=True)
     final_report_df = full_df[['Name', 'PRN', 'Status']]
@@ -163,43 +161,22 @@ def status_page():
     APP_STATUS_HTML = """<!DOCTYPE html><html lang="en"><head><title>API Status</title><style>body{font-family:sans-serif;display:flex;justify-content:center;align-items:center;height:100vh;margin:0;background:#f0f2f5;}.status-box{text-align:center;padding:40px 60px;background:white;border-radius:12px;box-shadow:0 8px 30px rgba(0,0,0,0.1);}h1{font-size:24px;color:#333;margin-bottom:10px;} .indicator{font-size:18px;font-weight:600;padding:8px 16px;border-radius:20px;}.active{color:#28a745;background-color:#e9f7ea;}</style></head><body><div class="status-box"><h1>Hillside Automation API</h1><div class="indicator active">● Active</div></div></body></html>"""
     return Response(APP_STATUS_HTML)
-def read_file_content(b64_content, filename):
-    raw_bytes = base64.b64decode(b64_content)
-    try:
-        return raw_bytes.decode('utf-8')
-    except UnicodeDecodeError:
-        print(f"[Server Log] UTF-8 decoding failed for {filename}, falling back to Latin-1.")
-        return raw_bytes.decode('latin-1')
 def extract_patient_name(raw_name):
     if not isinstance(raw_name, str): return ""
     name_only = raw_name.split('DOB')[0].strip()
     return re.sub(r'[:\d\-\s]+$', '', name_only).strip()
-@socketio.on('connect')
-def handle_connect():
-    print(f'Frontend connected.')
-    emit('email_list', {'emails': get_email_list()})
-@socketio.on('process_and_initialize')
-def handle_init_and_process(data):
     session_id = 'user_session'
     try:
-        print("[Server Log] Received initialization and file processing request.")
-        session_data[session_id] = {
-            'emails': data['emails'], 'filename': data['filename'], 'mode': data.get('mode'),
-            'start_date': data.get('start_date'), 'end_date': data.get('end_date')
-        }
-        app_data_file = data.get('app_data_file')
-        quantum_data_file = data.get('quantum_data_file')
-        app_data_content = read_file_content(app_data_file['content'], app_data_file['name'])
-        quantum_data_content = read_file_content(quantum_data_file['content'], quantum_data_file['name'])
-        df_app = pd.read_csv(io.StringIO(app_data_content))
-        df_quantum = pd.read_csv(io.StringIO(quantum_data_content))
         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.")
@@ -211,28 +188,40 @@ def handle_init_and_process(data):
         master_df = df_quantum.copy()
         master_df['Status'] = ''
-        session_data[session_id]['patient_data_for_report'] = master_df
-        session_data[session_id]['patient_data'] = master_df.to_dict('records')
-        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:
-            emit('data_processed')
-        else:
-            emit('error', {'message': f'Failed to initialize bot: {error_message}'})
-    except Exception as e:
-        print(f"[Server Log] ERROR during initialization: {e}")
-        emit('error', {'message': str(e)})
 @socketio.on('start_login')
 def handle_login(credentials):
-    if not bot_instance: return emit('error', {'message': 'Bot not initialized.'})
-    is_success, error_message = bot_instance.login(credentials['username'], credentials['password'])
-    if is_success: emit('otp_required')
-    else: emit('error', {'message': f'Login failed: {error_message}'})
 @socketio.on('submit_otp')
 def handle_otp(data):
@@ -250,7 +239,7 @@ def handle_terminate():
 if __name__ == '__main__':
     print("====================================================================")
-    print("  🤗 Hillside Automation - Definitive Final Version")
     print(f"  Frontend URL: {FRONTEND_ORIGIN}")
     print(f"  Port: {os.getenv('PORT', 7860)}")
     print("====================================================================")

     if results:
         result_df = pd.DataFrame(results).set_index('Name')
         full_df.set_index('Name', inplace=True)
         full_df.update(result_df); full_df.reset_index(inplace=True)
     full_df['Status'].fillna('Not Processed', inplace=True)
     final_report_df = full_df[['Name', 'PRN', 'Status']]
     APP_STATUS_HTML = """<!DOCTYPE html><html lang="en"><head><title>API Status</title><style>body{font-family:sans-serif;display:flex;justify-content:center;align-items:center;height:100vh;margin:0;background:#f0f2f5;}.status-box{text-align:center;padding:40px 60px;background:white;border-radius:12px;box-shadow:0 8px 30px rgba(0,0,0,0.1);}h1{font-size:24px;color:#333;margin-bottom:10px;} .indicator{font-size:18px;font-weight:600;padding:8px 16px;border-radius:20px;}.active{color:#28a745;background-color:#e9f7ea;}</style></head><body><div class="status-box"><h1>Hillside Automation API</h1><div class="indicator active">● Active</div></div></body></html>"""
     return Response(APP_STATUS_HTML)
 def extract_patient_name(raw_name):
     if not isinstance(raw_name, str): return ""
     name_only = raw_name.split('DOB')[0].strip()
     return re.sub(r'[:\d\-\s]+$', '', name_only).strip()
+@app.route('/process_and_initialize', methods=['POST'])
+def handle_file_processing_and_init():
     session_id = 'user_session'
     try:
+        data = session_data.get(session_id, {})
+        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.")
         master_df = df_quantum.copy()
         master_df['Status'] = ''
+        data['patient_data_for_report'] = master_df
+        data['patient_data'] = master_df.to_dict('records')
+        socketio.emit('data_processed')
+        return jsonify({"message": "Data processed successfully."})
+    except Exception as e:
+        print(f"[Server Log] ERROR during file processing: {e}")
+        return jsonify({"error": str(e)}), 500
+@socketio.on('connect')
+def handle_connect():
+    print(f'Frontend connected.')
+    emit('email_list', {'emails': get_email_list()})
+@socketio.on('initialize_session')
+def handle_init(data):
+    session_id = 'user_session'
+    session_data[session_id] = {
+        'emails': data['emails'], 'filename': data['filename'], 'mode': data.get('mode'),
+        'start_date': data.get('start_date'), 'end_date': data.get('end_date')
+    }
 @socketio.on('start_login')
 def handle_login(credentials):
+    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'])
+        if is_login_success: emit('otp_required')
+        else: emit('error', {'message': f'Login failed: {login_error}'})
+    else:
+        emit('error', {'message': f'Failed to initialize bot: {error_message}'})
 @socketio.on('submit_otp')
 def handle_otp(data):
 if __name__ == '__main__':
     print("====================================================================")
+    print("  🤗 Hillside Automation - Definitive Multi-Workflow Platform")
     print(f"  Frontend URL: {FRONTEND_ORIGIN}")
     print(f"  Port: {os.getenv('PORT', 7860)}")
     print("====================================================================")

worker.py CHANGED Viewed

@@ -2,6 +2,8 @@ import time
 import threading
 import subprocess
 import pandas as pd
 from selenium import webdriver
 from selenium.webdriver.chrome.service import Service as ChromeService
 from selenium.webdriver.chrome.options import Options as ChromeOptions
@@ -10,8 +12,6 @@ from selenium.webdriver.common.keys import Keys
 from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.common.exceptions import TimeoutException
-from datetime import datetime
-import os
 class QuantumBot:
     def __init__(self, socketio, app):
@@ -28,13 +28,21 @@ class QuantumBot:
         try:
             self.micro_status("Initializing headless browser...")
             self._kill_chrome_processes()
-            options = ChromeOptions(); options.binary_location = "/usr/bin/chromium"
             options.add_argument("--headless=new"); options.add_argument("--no-sandbox")
             options.add_argument("--disable-dev-shm-usage"); options.add_argument("--disable-gpu")
             options.add_argument("--window-size=1920,1080")
             user_agent = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
             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})"
@@ -55,8 +63,7 @@ class QuantumBot:
     def login(self, username, password):
         try:
             self.micro_status("Navigating to login page..."); self.driver.get("https://gateway.quantumepay.com/")
-            self._wait_for_page_load()
-            self.micro_status("Entering credentials...")
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.presence_of_element_located((By.ID, "Username"))).send_keys(username)
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.presence_of_element_located((By.ID, "Password"))).send_keys(password)
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.ID, "login"))).click()
@@ -72,47 +79,12 @@ class QuantumBot:
             self.micro_status(f"Submitting OTP..."); otp_digits = list(otp)
             for i in range(6): self.driver.find_element(By.ID, f"code{i+1}").send_keys(otp_digits[i])
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.ID, "login"))).click()
-            self._wait_for_page_load()
             self.micro_status("Verifying login success...")
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//span[text()='Payments']")))
             return True, None
         except Exception as e:
             error_message = f"Error during OTP submission: {str(e)}"; print(f"[Bot Log] ERROR during OTP submission: {error_message}")
             return False, error_message
-    def _wait_for_page_load(self, timeout=None):
-        if timeout is None: timeout = self.DEFAULT_TIMEOUT
-        self.micro_status("Waiting for page activity to cease...")
-        loading_overlay_xpath = "//div[contains(@class, 'vld-background')]"
-        try:
-            WebDriverWait(self.driver, timeout).until(EC.invisibility_of_element_located((By.XPATH, loading_overlay_xpath)))
-            self.micro_status("...Page is ready.")
-        except TimeoutException:
-            self.micro_status("Warning: Loading overlay did not disappear in time.")
-    def _get_calendar_months(self):
-        try:
-            titles = self.driver.find_elements(By.XPATH, "//div[contains(@class, 'vc-title')]")
-            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")
-        self.micro_status(f"Navigating calendar to {target_month_str}...")
-        for _ in range(24):
-            visible_months = self._get_calendar_months()
-            if any(d.strftime("%B %Y") == target_month_str for d in visible_months):
-                self.micro_status(f"Found month. Selecting day {target_date.day}.")
-                day_format = "%#d" if os.name == 'nt' else "%-d"
-                expected_aria_label = target_date.strftime(f"%A, %B {day_format}, %Y")
-                day_xpath = f"//span[@aria-label='{expected_aria_label}']"
-                day_element = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.XPATH, day_xpath)))
-                self.driver.execute_script("arguments[0].click();", day_element)
-                return
-            arrow_direction = 'is-left' if target_date < visible_months[0] else 'is-right'
-            self.driver.find_element(By.XPATH, f"//div[contains(@class, 'vc-arrow') and contains(@class, '{arrow_direction}')]").click()
-            self._wait_for_page_load(timeout=5)
-        raise Exception(f"Could not navigate to date {target_date.strftime('%Y-%m-%d')}")
     def start_processing(self, process_type, patient_data, **kwargs):
         if process_type == 'void':
@@ -122,122 +94,138 @@ class QuantumBot:
         return []
     def process_void_list(self, patient_data):
-        results = []; current_patient_index = 0
-        while current_patient_index < len(patient_data):
             if self.termination_event.is_set(): print("[Bot Log] Termination detected."); break
-            record = patient_data[current_patient_index]; patient_name = record['Name']; patient_prn = record.get('PRN', '')
             status = 'Skipped - No PRN'
             if patient_prn and str(patient_prn).strip():
-                self.micro_status(f"Processing VOID for '{patient_name}' ({current_patient_index + 1}/{len(patient_data)})...")
                 status = self._process_single_void(patient_name, patient_prn)
             else:
-                self.micro_status(f"Skipping '{patient_name}' (No PRN)."); time.sleep(0.2)
-            if status != "RETRY":
-                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})
-                current_patient_index += 1
         return results
     def process_refund_list(self, patient_data, start_date_str, end_date_str):
-        results = []; current_patient_index = 0
-        try:
-            self._navigate_and_verify("https://gateway.quantumepay.com/credit-card/refund", "//button[.//span[contains(text(), '-')]]")
-            self._set_date_range_on_page(start_date_str, end_date_str)
-        except Exception as e:
-            self.micro_status(f"FATAL: Could not set date range. Error: {e}")
-            return [{'Name': r['Name'], 'PRN': r.get('PRN', ''), 'Status': 'Error - Date Setup Failed'} for r in patient_data]
-        while current_patient_index < len(patient_data):
             if self.termination_event.is_set(): print("[Bot Log] Termination detected."); break
-            record = patient_data[current_patient_index]; patient_name = record['Name']; patient_prn = record.get('PRN', '')
-            status = 'Skipped - No PRN'
-            if patient_prn and str(patient_prn).strip():
-                self.micro_status(f"Processing REFUND for '{patient_name}' ({current_patient_index + 1}/{len(patient_data)})...")
-                status = self._process_single_refund(patient_name, patient_prn)
-            else:
-                self.micro_status(f"Skipping '{patient_name}' (No PRN)."); time.sleep(0.2)
-            if status != "RETRY":
-                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})
-                current_patient_index += 1
         return results
     def _process_single_void(self, patient_name, patient_prn):
         try:
-            self._navigate_and_verify("https://gateway.quantumepay.com/credit-card/void", "//input[@placeholder='Search']")
-            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']")))
-            time.sleep(1); search_box.click(); search_box.clear(); time.sleep(0.5); search_box.send_keys(patient_name)
-            self._wait_for_page_load()
             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(); self._wait_for_page_load(5)
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.LINK_TEXT, "Transaction Detail"))).click(); self._wait_for_page_load()
             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(); self._wait_for_page_load()
-            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._wait_for_page_load()
             try:
                 self.micro_status("Verifying success and saving...")
                 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)
-                self.micro_status(f"Entering PRN: {patient_prn}..."); 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(); self._wait_for_page_load()
-                WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Confirm']]"))).click(); time.sleep(2); self._wait_for_page_load()
-                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(); self._wait_for_page_load()
                 return 'Bad'
         except Exception as e:
-            print(f"An error occurred during VOID for {patient_name}: {e}"); return 'RETRY'
-    def _process_single_refund(self, patient_name, patient_prn):
         try:
-            self.micro_status(f"Searching for '{patient_name}' in date range...")
-            search_box = WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//input[@placeholder='Search']")))
-            time.sleep(1); search_box.click(); search_box.clear(); time.sleep(0.5); search_box.send_keys(patient_name)
-            self._wait_for_page_load()
-            self.micro_status("Opening transaction details for Refund...")
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, f"//tr[contains(., \"{patient_name}\")]//button"))).click(); self._wait_for_page_load(5)
-            self.micro_status("Initiating Refund...")
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button/span[normalize-space()='Refund']"))).click(); self._wait_for_page_load()
-            try:
-                self.micro_status("Confirming Refund...")
-                WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Confirm']]"))).click(); time.sleep(2); self._wait_for_page_load()
-                return "Done"
-            except TimeoutException:
-                self.micro_status(f"'{patient_name}' is in a bad state for refund, cancelling.")
-                WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Cancel']]"))).click(); self._wait_for_page_load()
-                return 'Bad'
-        except Exception as e:
-            print(f"An error occurred during REFUND for {patient_name}: {e}"); return 'RETRY'
     def _set_date_range_on_page(self, start_date_str, end_date_str):
         try:
-            self.micro_status("Opening calendar...")
-            date_button = WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[contains(text(), '-')]]")))
-            time.sleep(2)
-            date_button.click()
-            self._wait_for_page_load(timeout=10)
-            start_date = datetime.strptime(start_date_str, "%Y-%m-%d"); end_date = datetime.strptime(end_date_str, "%Y-%m-%d")
-            self._select_date_in_calendar(start_date)
-            self._wait_for_page_load(timeout=10)
-            self._select_date_in_calendar(end_date)
             time.sleep(2)
-            self.driver.find_element(By.TAG_NAME, "body").click()
-            self.micro_status("Date range set. Waiting for data to filter...")
-            self._wait_for_page_load()
-            return True
         except Exception as e:
-            self.micro_status(f"Error setting date range: {e}")
-            return False
     def shutdown(self):
         try:

 import threading
 import subprocess
 import pandas as pd
+import os
+from datetime import datetime
 from selenium import webdriver
 from selenium.webdriver.chrome.service import Service as ChromeService
 from selenium.webdriver.chrome.options import Options as ChromeOptions
 from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.common.exceptions import TimeoutException
 class QuantumBot:
     def __init__(self, socketio, app):
         try:
             self.micro_status("Initializing headless browser...")
             self._kill_chrome_processes()
+            options = ChromeOptions()
             options.add_argument("--headless=new"); options.add_argument("--no-sandbox")
             options.add_argument("--disable-dev-shm-usage"); options.add_argument("--disable-gpu")
             options.add_argument("--window-size=1920,1080")
             user_agent = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
             options.add_argument(f"--user-agent={user_agent}")
+            # Smartly choose between production and local driver
+            if os.path.exists("/usr/bin/chromedriver"):
+                options.binary_location = "/usr/bin/chromium"
+                service = ChromeService(executable_path="/usr/bin/chromedriver")
+            else:
+                from webdriver_manager.chrome import ChromeDriverManager
+                service = ChromeService(ChromeDriverManager().install())
             self.driver = webdriver.Chrome(service=service, options=options)
             self.driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
                 'source': "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
     def login(self, username, password):
         try:
             self.micro_status("Navigating to login page..."); self.driver.get("https://gateway.quantumepay.com/")
+            time.sleep(2); self.micro_status("Entering credentials...")
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.presence_of_element_located((By.ID, "Username"))).send_keys(username)
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.presence_of_element_located((By.ID, "Password"))).send_keys(password)
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.ID, "login"))).click()
             self.micro_status(f"Submitting OTP..."); otp_digits = list(otp)
             for i in range(6): self.driver.find_element(By.ID, f"code{i+1}").send_keys(otp_digits[i])
             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']")))
             return True, None
         except Exception as e:
             error_message = f"Error during OTP submission: {str(e)}"; print(f"[Bot Log] ERROR during OTP submission: {error_message}")
             return False, error_message
     def start_processing(self, process_type, patient_data, **kwargs):
         if process_type == 'void':
         return []
     def process_void_list(self, patient_data):
+        results = []
+        for index, record in enumerate(patient_data):
             if self.termination_event.is_set(): print("[Bot Log] Termination detected."); break
+            patient_name = record['Name']; patient_prn = record.get('PRN', '')
             status = 'Skipped - No PRN'
             if patient_prn and str(patient_prn).strip():
+                self.micro_status(f"Processing VOID for '{patient_name}' ({index + 1}/{len(patient_data)})...")
                 status = self._process_single_void(patient_name, patient_prn)
             else:
+                self.micro_status(f"Skipping '{patient_name}' (No PRN)."); time.sleep(0.5)
+            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': index + 1, 'remaining': len(patient_data) - (index + 1), 'status': status})
         return results
     def process_refund_list(self, patient_data, start_date_str, end_date_str):
+        results = []
+        for index, record in enumerate(patient_data):
             if self.termination_event.is_set(): print("[Bot Log] Termination detected."); break
+            patient_name = record['Name']; patient_prn = record.get('PRN', '')
+            self.micro_status(f"Processing REFUND for '{patient_name}' ({index + 1}/{len(patient_data)})...")
+            status = self._process_single_refund(patient_name, patient_prn, start_date_str, end_date_str)
+            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': index + 1, 'remaining': len(patient_data) - (index + 1), 'status': status})
         return results
     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")
+            search_successful = False
+            for attempt in range(15):
+                try:
+                    self.micro_status(f"Searching... (Attempt {attempt + 1})")
+                    WebDriverWait(self.driver, 2).until(EC.presence_of_element_located((By.XPATH, "//div[contains(@class, 'table-wrapper')]")))
+                    search_box = WebDriverWait(self.driver, 2).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); search_successful = True; break
+                except Exception: time.sleep(1)
+            if not search_successful: raise Exception("Failed to search for patient.")
+            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...")
                 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)
+                self.micro_status(f"Entering PRN: {patient_prn}...")
+                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:
+            print(f"An error occurred during VOID for {patient_name}: {e}"); return 'Error'
+    def _get_calendar_months(self):
         try:
+            titles = self.driver.find_elements(By.XPATH, "//div[contains(@class, 'vc-title')]")
+            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")
+        self.micro_status(f"Navigating calendar to {target_month_str}...")
+        for _ in range(24):
+            visible_months = self._get_calendar_months()
+            if any(d.strftime("%B %Y") == target_month_str for d in visible_months):
+                self.micro_status(f"Found month. Selecting day {target_date.day}.")
+                day_format = "%#d" if os.name == 'nt' else "%-d"
+                expected_aria_label = target_date.strftime(f"%A, %B {day_format}, %Y")
+                day_xpath = f"//span[@aria-label='{expected_aria_label}']"
+                day_element = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.XPATH, day_xpath)))
+                self.driver.execute_script("arguments[0].click();", day_element)
+                return
+            if target_date < visible_months[0]:
+                self.driver.find_element(By.XPATH, "//div[contains(@class, 'vc-arrow') and contains(@class, 'is-left')]").click()
+            else:
+                self.driver.find_element(By.XPATH, "//div[contains(@class, 'vc-arrow') and contains(@class, 'is-right')]").click()
+            time.sleep(0.5)
+        raise Exception(f"Could not navigate to date {target_date.strftime('%Y-%m-%d')}")
     def _set_date_range_on_page(self, start_date_str, end_date_str):
+        self.micro_status("Opening calendar...")
+        date_button = WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[contains(text(), '-')]]")))
+        time.sleep(1); date_button.click()
+        start_date = datetime.strptime(start_date_str, "%Y-%m-%d"); end_date = datetime.strptime(end_date_str, "%Y-%m-%d")
+        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()
+        self.micro_status("Date range set. Waiting for data to filter...")
+        time.sleep(3)
+    def _process_single_refund(self, patient_name, patient_prn, start_date_str, end_date_str):
         try:
+            self.micro_status(f"Navigating to Refund page for '{patient_name}'")
+            self.driver.get("https://gateway.quantumepay.com/credit-card/refund")
+            self._set_date_range_on_page(start_date_str, end_date_str)
+            search_successful = False
+            for attempt in range(5):
+                try:
+                    self.micro_status(f"Searching... (Attempt {attempt + 1})")
+                    search_box = WebDriverWait(self.driver, 5).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); search_successful = True; break
+                except Exception: time.sleep(1)
+            if not search_successful: raise Exception("Failed to search for patient.")
+            time.sleep(3)
+            # This is a placeholder for the actual refund action.
+            # You would find the correct row and click the 'Refund' button.
+            self.micro_status("Placeholder: Performing refund action...")
             time.sleep(2)
+            return 'Done'
         except Exception as e:
+            print(f"An error occurred while processing REFUND for {patient_name}: {e}"); return 'Error'
     def shutdown(self):
         try: