Update worker.py

worker.py

@@ -1,11 +1,10 @@
-import os
-import re
 import time
 import threading
 import subprocess
-from datetime import datetime
-
 import pandas as pd
+import os
+import re
+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
@@ -15,7 +14,6 @@ from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.common.exceptions import TimeoutException, NoSuchElementException
 
-
 class QuantumBot:
     def __init__(self, socketio, app, logger):
         self.socketio = socketio
@@ -26,20 +24,17 @@ class QuantumBot:
         self.logger = logger
 
     def _kill_chrome_processes(self):
-        """Attempts to terminate lingering chromium processes."""
         try:
-            self.logger.info("Attempting to kill lingering chromium processes...")
+            self.logger.info("Attempting to kill any lingering chromium processes...")
             subprocess.run(['pkill', '-f', 'chromium'], check=True, timeout=5)
             time.sleep(1)
         except Exception as e:
-            self.logger.warning(f"Could not kill chrome processes (often normal): {e}")
+            self.logger.warning(f"Could not kill chrome processes: {e}")
 
     def initialize_driver(self):
-        """Sets up the Selenium WebDriver with headless options."""
         try:
             self.micro_status("Initializing headless browser...")
             self._kill_chrome_processes()
-
             options = ChromeOptions()
             options.binary_location = "/usr/bin/chromium"
             options.add_argument("--headless=new")
@@ -47,394 +42,227 @@ class QuantumBot:
             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"
-            )
+            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)
-
-            # Bypass bot detection
             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."
+            return False, "WebDriver initialization failed."
 
     def micro_status(self, message):
-        """Sends status updates to the frontend via SocketIO."""
+        """Updates the small status text on the frontend."""
         self.logger.info(message)
         with self.app.app_context():
             self.socketio.emit('micro_status_update', {'message': message})
 
     def stop(self):
-        """Signals the bot to terminate."""
         self.micro_status("Termination signal received...")
         self.termination_event.set()
 
     def login(self, username, password):
-        """Handles the initial login credentials screen."""
         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()
-
+            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("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.")
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.presence_of_element_located((By.ID, "code1")))
             return True, None
         except Exception:
             self.logger.exception("ERROR during login process")
-            return False, "An error occurred during login."
+            return False, "Login failed."
 
     def submit_otp(self, otp):
-        """Submits the 6-digit OTP code."""
         try:
             self.micro_status("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()
-
+            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 visible.")
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//span[text()='Payments']")))
             return True, None
         except Exception:
             self.logger.exception("ERROR during OTP submission")
             return False, "OTP submission failed."
 
     def _wait_for_page_load(self, timeout=None):
-        """Waits for the site's loading overlay to disappear."""
-        if timeout is None:
-            timeout = self.DEFAULT_TIMEOUT
-        loading_overlay_xpath = "//div[contains(@class, 'vld-background')]"
+        if timeout is None: timeout = self.DEFAULT_TIMEOUT
         try:
-            WebDriverWait(self.driver, timeout).until(
-                EC.invisibility_of_element_located((By.XPATH, loading_overlay_xpath))
-            )
-        except TimeoutException:
-            pass
+            WebDriverWait(self.driver, timeout).until(EC.invisibility_of_element_located((By.XPATH, "//div[contains(@class, 'vld-background')]")))
+        except: pass
 
     def _navigate_and_verify(self, url, verification_xpath):
-        """Navigates to a URL and verifies the page loaded via an element."""
-        self.micro_status(f"Navigating to {url.split('/')[-1]} page...")
+        self.micro_status(f"Navigating to {url.split('/')[-1]}...")
         self.driver.get(url)
         time.sleep(3)
         self._wait_for_page_load()
-
         try:
-            WebDriverWait(self.driver, 15).until(
-                EC.element_to_be_clickable((By.XPATH, verification_xpath))
-            )
-        except TimeoutException:
-            self.micro_status("Page not verified. Refreshing...")
+            WebDriverWait(self.driver, 15).until(EC.element_to_be_clickable((By.XPATH, verification_xpath)))
+        except:
             self.driver.refresh()
             time.sleep(5)
             self._wait_for_page_load()
-            WebDriverWait(self.driver, 15).until(
-                EC.element_to_be_clickable((By.XPATH, verification_xpath))
-            )
 
     def _get_calendar_months(self):
-        """Extracts visible months from the calendar widget."""
         try:
             titles = self.driver.find_elements(By.XPATH, "//div[contains(@class, 'vc-title')]")
             return [datetime.strptime(title.text, "%B %Y") for title in titles] if titles else []
-        except Exception as e:
-            self.logger.warning(f"Could not get calendar months: {e}")
-            return []
+        except: return []
 
     def _select_date_in_calendar(self, target_date):
-        """Navigates the calendar UI to pick a specific date."""
         target_month_str = target_date.strftime("%B %Y")
-        for _ in range(24):  # Look up to 2 years ahead/back
+        for _ in range(24):
             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"
-                day_label = target_date.strftime(f'%A, %B {day_format}, %Y')
-                day_xpath = f"//span[@aria-label='{day_label}']"
-                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)
+                day_xpath = f"//span[@aria-label='{target_date.strftime('%A, %B %-d, %Y')}']"
+                day_el = WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable((By.XPATH, day_xpath)))
+                self.driver.execute_script("arguments[0].click();", day_el)
                 return
-
-            # Determine direction to click
-            if target_date < visible_months[0]:
-                arrow = "//div[contains(@class, 'vc-arrow') and contains(@class, 'is-left')]"
-            else:
-                arrow = "//div[contains(@class, 'vc-arrow') and contains(@class, 'is-right')]"
-            
+            arrow = "//div[contains(@class, 'vc-arrow') and contains(@class, 'is-left')]" if target_date < visible_months[0] else "//div[contains(@class, 'vc-arrow') and contains(@class, 'is-right')]"
             self.driver.find_element(By.XPATH, arrow).click()
             time.sleep(0.5)
 
-        raise Exception(f"Could not navigate to date {target_date.strftime('%Y-%m-%d')}")
-
     def _set_date_range(self, start_date_str, end_date_str):
-        """Sets the date range filter on the current page."""
         self.micro_status("Setting date range...")
-        date_btn_xpath = "//button[.//span[contains(text(), '-')]]"
-        date_button = WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
-            EC.element_to_be_clickable((By.XPATH, date_btn_xpath))
-        )
-        time.sleep(1)
+        date_button = WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[contains(text(), '-')]]")))
         date_button.click()
         self._wait_for_page_load()
-
-        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._select_date_in_calendar(datetime.strptime(start_date_str, "%Y-%m-%d"))
         self._wait_for_page_load()
-        self._select_date_in_calendar(end_date)
+        self._select_date_in_calendar(datetime.strptime(end_date_str, "%Y-%m-%d"))
         self._wait_for_page_load()
-
-        # Close calendar by clicking away
         self.driver.find_element(By.TAG_NAME, "body").click()
-        self._wait_for_page_load()
 
-    def _clear_input_robust(self, locator, timeout=10):
-        """Clears an input field using standard keys and JS fallback."""
-        el = WebDriverWait(self.driver, timeout).until(
-            EC.element_to_be_clickable(locator)
-        )
+    def _clear_input_robust(self, locator):
+        el = WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable(locator))
         self.driver.execute_script("arguments[0].scrollIntoView({block:'center'});", el)
         el.click()
         el.send_keys(Keys.CONTROL, "a")
         el.send_keys(Keys.BACK_SPACE)
-        self._wait_for_page_load(timeout=2)
-
-        val = (el.get_attribute('value') or '').strip()
-        if val != '':
-            js_clear = (
-                "arguments[0].value='';"
-                "arguments[0].dispatchEvent(new Event('input',{bubbles:true}));"
-            )
-            self.driver.execute_script(js_clear, el)
+        self.driver.execute_script("arguments[0].value=''; arguments[0].dispatchEvent(new Event('input',{bubbles:true}));", el)
         return el
 
     def _type_text_robust(self, el, text):
-        """Types text into an element if the value is valid."""
         s = '' if text is None or pd.isna(text) else str(text).strip()
-        if s and s.lower() != 'nan':
-            el.send_keys(s)
+        if s and s.lower() != 'nan': el.send_keys(s)
 
     def _find_action_button(self, patient_name):
-        """Finds the kebab menu button for a row using multiple strategies."""
-        action_button_xpaths = [
+        xpaths = [
             f"//tr[contains(., \"{patient_name}\")]//td[contains(@class,'is-action')]//button",
-            f"//tr[contains(., \"{patient_name}\")]//button[contains(@class,'q-button')]",
-            f"//tr[contains(., \"{patient_name}\")]//td[last()]//button",
-            "//td[contains(@class,'is-action')]//button",
-            "//button[.//svg[contains(@data-icon,'more-vertical')]]",
-            (
-                "//td[contains(@class,'table-cell') and contains(@class,'is-action')]"
-                "//button[contains(@class,'q-button') and .//svg[contains(@data-icon,'more-vertical')]]"
-            ),
-            "//button[contains(@class,'q-button') and .//svg]",
-            "//td[last()]//button",
+            f"//tr[contains(., \"{patient_name}\")]//button",
+            "//td[contains(@class,'is-action')]//button"
         ]
-
-        for xpath in action_button_xpaths:
-            try:
-                button = WebDriverWait(self.driver, 5).until(
-                    EC.element_to_be_clickable((By.XPATH, xpath))
-                )
-                self.logger.info(f"Action button found with XPath: {xpath}")
-                return button
-            except TimeoutException:
-                continue
-        return None
-
-    def _find_transaction_detail_link(self):
-        """Finds the 'Transaction Detail' link in the dropdown menu."""
-        detail_xpaths = [
-            "//a[contains(@class,'dropdown-item') and normalize-space()='Transaction Detail']",
-            "//a[normalize-space()='Transaction Detail']",
-            "//div[contains(@class,'dropdown')]//a[contains(text(),'Transaction')]",
-            "//a[contains(text(),'Transaction Detail')]",
-            "//li//a[contains(text(),'Transaction')]",
-            "//*[contains(@class,'dropdown-item') and contains(text(),'Transaction')]",
-        ]
-
-        for xpath in detail_xpaths:
-            try:
-                link = WebDriverWait(self.driver, 5).until(
-                    EC.element_to_be_clickable((By.XPATH, xpath))
-                )
-                self.logger.info(f"Transaction Detail link found with XPath: {xpath}")
-                return link
-            except TimeoutException:
-                continue
+        for xpath in xpaths:
+            try: return WebDriverWait(self.driver, 5).until(EC.element_to_be_clickable((By.XPATH, xpath)))
+            except: continue
         return None
 
     def _safe_click(self, element, description="element"):
-        """Clicks an element normally, or via JS if normal click fails."""
-        try:
-            element.click()
-        except Exception as e:
-            self.logger.warning(f"Normal click on {description} failed ({e}), trying JS click...")
-            self.driver.execute_script("arguments[0].click();", element)
+        try: element.click()
+        except: self.driver.execute_script("arguments[0].click();", element)
 
-    def _save_debug_screenshot(self, patient_name, context="unknown"):
-        """Saves screenshot and logs partial source for debugging."""
+    def _save_debug_screenshot(self, patient_name, context):
         try:
-            safe_name = patient_name.replace(' ', '_').replace('/', '_')
-            screenshot_path = f"/tmp/debug_{safe_name}_{context}.png"
-            self.driver.save_screenshot(screenshot_path)
-            self.logger.error(f"Debug screenshot saved to {screenshot_path}")
-
-            page_source = self.driver.page_source
-            action_cells = re.findall(r'<td[^>]*action[^>]*>.*?</td>', page_source, re.DOTALL)
-            if action_cells:
-                self.logger.error(f"Action cell HTML sample: {action_cells[0][:500]}")
-            
-            buttons = re.findall(r'<button[^>]*>.*?</button>', page_source, re.DOTALL)
-            if buttons:
-                self.logger.error(f"Total buttons in page: {len(buttons)}")
-        except Exception as debug_err:
-            self.logger.warning(f"Debug logging failed: {debug_err}")
+            path = f"/tmp/debug_{patient_name.replace(' ','_')}_{context}.png"
+            self.driver.save_screenshot(path)
+        except: pass
 
     def _perform_core_patient_processing(self, patient_name, patient_prn):
         try:
-            # ============================================================
-            # STEP 1: Search for the patient
-            # ============================================================
             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)
-            self._wait_for_page_load()
-            time.sleep(2) 
+            search_box = WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//input[@placeholder='Search']")))
+            search_box.click(); search_box.clear(); search_box.send_keys(patient_name)
+            self._wait_for_page_load(); time.sleep(2)
 
-            # ============================================================
-            # STEP 2: Verify patient row exists
-            # ============================================================
-            row_xpath = f"//tr[contains(., \"{patient_name}\")]"
-            try:
-                WebDriverWait(self.driver, 10).until(
-                    EC.presence_of_element_located((By.XPATH, row_xpath))
-                )
-            except TimeoutException:
-                self.micro_status(f"Patient '{patient_name}' not found in table.")
+            if not self.driver.find_elements(By.XPATH, f"//tr[contains(., \"{patient_name}\")]"):
                 return 'Not Found'
 
-            # ============================================================
-            # STEP 3: Find and click the action button (kebab menu)
-            # ============================================================
-            self.micro_status("Opening transaction details...")
-            action_button = self._find_action_button(patient_name)
-
-            if action_button is None:
-                self.logger.error(f"Could not find action button for '{patient_name}'")
-                self._save_debug_screenshot(patient_name, "action_button")
-                return 'Error'
-
-            self._safe_click(action_button, "action button")
-            time.sleep(1) 
-
-            # ============================================================
-            # STEP 4: Find and click "Transaction Detail" link
-            # ============================================================
-            detail_link = self._find_transaction_detail_link()
-
-            if detail_link is None:
-                self.logger.error(f"Could not find 'Transaction Detail' link for '{patient_name}'.")
-                self._save_debug_screenshot(patient_name, "transaction_detail")
-                return 'Error'
-
-            self._safe_click(detail_link, "Transaction Detail link")
+            btn = self._find_action_button(patient_name)
+            if not btn: return 'Error'
+            self._safe_click(btn)
+            
+            detail_xpath = "//a[contains(@class,'dropdown-item') and normalize-space()='Transaction Detail']"
+            detail_link = WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable((By.XPATH, detail_xpath)))
+            self._safe_click(detail_link)
             self._wait_for_page_load()
-            time.sleep(1)
 
-            # ============================================================
-            # STEP 5: Add to Vault
-            # ============================================================
-            self.micro_status("Adding to Vault...")
-            add_to_vault_btn = WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
-                EC.element_to_be_clickable((By.XPATH, "//button/span[normalize-space()='Add to Vault']"))
-            )
-            self._safe_click(add_to_vault_btn, "Add to Vault button")
+            self.micro_status("Vaulting and Saving...")
+            WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable((By.XPATH, "//button/span[normalize-space()='Add to Vault']"))).click()
             self._wait_for_page_load()
-
-            # ============================================================
-            # STEP 6: Confirm the vault action
-            # ============================================================
-            confirm_btn = WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
-                EC.element_to_be_clickable((
-                    By.XPATH,
-                    "//div[@class='modal-footer']//button/span[normalize-space()='Confirm']"
-                ))
-            )
-            self._safe_click(confirm_btn, "Confirm button")
+            WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable((By.XPATH, "//div[@class='modal-footer']//button/span[normalize-space()='Confirm']"))).click()
             self._wait_for_page_load()
 
-            # ============================================================
-            # STEP 7: Save company name and contact (PRN)
-            # ============================================================
-            self.micro_status("Verifying success and saving data...")
-
-            company_el = self._clear_input_robust((By.NAME, "company_name"))
-            self._type_text_robust(company_el, patient_name)
-
-            contact_el = self._clear_input_robust((By.NAME, "company_contact"))
-            self._type_text_robust(contact_el, patient_prn)
+            try:
+                comp = self._clear_input_robust((By.NAME, "company_name"))
+                self._type_text_robust(comp, patient_name)
+                cont = self._clear_input_robust((By.NAME, "company_contact"))
+                self._type_text_robust(cont, patient_prn)
+                WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable((By.XPATH, "//button/span[normalize-space()='Save Changes']"))).click()
+                self._wait_for_page_load()
+                WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Confirm']]"))).click()
+                time.sleep(2); return 'Done'
+            except:
+                WebDriverWait(self.driver, 5).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Cancel']]"))).click()
+                return 'Bad'
+        except Exception:
+            return 'Error'
 
-            save_btn = WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
-                EC.element_to_be_clickable((
-                    By.XPATH,
-                    "//button/span[normalize-space()='Save Changes']"
-                ))
-            )
-            self._safe_click(save_btn, "Save Changes button")
-            
-            # Wait for save confirmation (adjust selector based on actual site behavior)
-            self._wait_for_page_load()
-            time.sleep(2)
+    def process_patient_list(self, patient_data, workflow, date_range=None):
+        """This is the main entry point called by server.py to update the frontend."""
+        self.logger.info(f"Starting {workflow} workflow...")
+        results = []
+        is_refund_setup_done = False
+        
+        if workflow == 'refund' and date_range:
+            try:
+                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'])
+                is_refund_setup_done = True
+            except: return []
+
+        for index, record in enumerate(patient_data):
+            if self.termination_event.is_set(): break
+            name = record['Name']; prn = record.get('PRN', '')
             
-            self.logger.info(f"Successfully processed patient: {patient_name}")
-            return 'Success'
-
-        except Exception as e:
-            self.logger.exception(f"Unexpected error processing patient '{patient_name}': {e}")
-            self._save_debug_screenshot(patient_name, "fatal_error")
-            return 'Error'
-        
+            if not prn:
+                status = 'Skipped - No PRN'
+            else:
+                self.micro_status(f"Processing {index+1}/{len(patient_data)}: {name}")
+                if workflow == 'void':
+                    self._navigate_and_verify("https://gateway.quantumepay.com/credit-card/void", "//input[@placeholder='Search']")
+                    status = self._perform_core_patient_processing(name, prn)
+                elif workflow == 'refund' and is_refund_setup_done:
+                    status = self._process_single_refund(name, prn, date_range)
+                else: status = 'Error'
+
+            results.append({'Name': name, 'PRN': prn, 'Status': status})
+            # IMPORTANT: Connects to Frontend
+            with self.app.app_context():
+                self.socketio.emit('log_update', {'name': name, 'prn': prn, 'status': status})
+                self.socketio.emit('stats_update', {'processed': len(results), 'remaining': len(patient_data)-len(results), 'status': status})
+        
+        return results
+
+    def _process_single_refund(self, name, prn, date_range):
+        status = self._perform_core_patient_processing(name, prn)
+        if status == 'Not Found':
+            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'])
+            status = self._perform_core_patient_processing(name, prn)
+        return status
+
+    def shutdown(self):
+        """Cleanup method called by server.py."""
+        try:
+            if self.driver: self.driver.quit()
+            self._kill_chrome_processes()
+        except: pass