Almost Done

server.py

@@ -134,11 +134,9 @@ def run_automation_process(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_void_list(patient_data)
-        elif workflow == 'refund':
-            start_date = data.get('start_date'); end_date = data.get('end_date')
-            results = bot_instance.process_refund_list(patient_data, start_date, end_date)
+        
+        results = bot_instance.process_patient_list(patient_data, workflow, data)
+        
         is_terminated = bot_instance.termination_event.is_set()
     except Exception as e:
         print(f"[Server Log] Fatal error in automation thread: {e}"); is_crash = True
@@ -198,7 +196,7 @@ def status_page():
 def handle_connect():
     print(f'Frontend connected.')
     emit('email_list', {'emails': get_email_list()})
-
+    
 @socketio.on('get_email_list')
 def handle_get_email_list():
     emit('email_list', {'emails': get_email_list()})
@@ -214,17 +212,18 @@ def handle_init(data):
     })
     try:
         app_b64 = data.get('app_data_b64'); quantum_b64 = data.get('quantum_data_b64')
+        app_filename = data.get('app_data_filename', '').lower()
+        quantum_filename = data.get('quantum_data_filename', '').lower()
         if not app_b64 or not quantum_b64:
             emit('error', {'message': 'Both data files are required.'}); return
 
         def load_df_from_b64(b64str, filename):
-            raw = base64.b64decode(b64str)
-            bio = io.BytesIO(raw)
+            raw = base64.b64decode(b64str); bio = io.BytesIO(raw)
             if filename.endswith('.xlsx'): return pd.read_excel(bio)
             return pd.read_csv(bio)
 
-        df_app = load_df_from_b64(app_b64, "app_data.xlsx") # Filename doesn't matter, only extension
-        df_quantum = load_df_from_b64(quantum_b64, "quantum_data.csv")
+        df_app = load_df_from_b64(app_b64, app_filename)
+        df_quantum = load_df_from_b64(quantum_b64, quantum_filename)
 
         if 'Patient Name' not in df_app.columns or 'PRN' not in df_app.columns:
             emit('error', {'message': "App Data must contain 'Patient Name' and 'PRN' columns."}); return

worker.py

@@ -2,6 +2,8 @@ import time
 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
@@ -75,7 +77,7 @@ class QuantumBot:
         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 _get_calendar_months(self):
         try:
             titles = self.driver.find_elements(By.XPATH, "//div[contains(@class, 'vc-title')]")
@@ -108,41 +110,30 @@ class QuantumBot:
         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):
+        if workflow == 'void':
+            return self.process_void_list(patient_data)
+        elif workflow == 'refund':
+            return self.process_refund_list(patient_data, date_range['start_date'], date_range['end_date'])
+        return []
+
+    def process_void_list(self, patient_data):
         results = []
-        records_to_process = list(patient_data)
-        for index, record in enumerate(records_to_process):
+        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', '')
             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.2)
+                status = 'Skipped - No PRN'; self.micro_status(f"Skipping '{patient_name}' (No PRN)."); time.sleep(0.2)
             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':
-                    status = self._process_single_refund(patient_name, patient_prn, date_range['start_date'], date_range['end_date'])
+                self.micro_status(f"Processing '{patient_name}' ({index + 1}/{len(patient_data)})...")
+                status = self._process_single_void(patient_name, patient_prn)
             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
-                })
+                self.socketio.emit('stats_update', {'processed': len(results), 'remaining': len(patient_data) - len(results), 'status': status})
         return results
 
-    def _force_clear_and_fill(self, locator, text_to_fill):
-        element = WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable(locator))
-        element.click()
-        element.send_keys(Keys.CONTROL + "a")
-        element.send_keys(Keys.BACK_SPACE)
-        if text_to_fill:
-            element.send_keys(str(text_to_fill))
-
     def _process_single_void(self, patient_name, patient_prn):
         try:
             self.micro_status(f"Navigating to Void page for '{patient_name}'")
@@ -166,8 +157,11 @@ class QuantumBot:
             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...")
-                self._force_clear_and_fill((By.NAME, "company_name"), patient_name)
-                self._force_clear_and_fill((By.NAME, "company_contact"), patient_prn)
+                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'
@@ -178,12 +172,33 @@ class QuantumBot:
         except Exception as e:
             print(f"An error occurred while processing {patient_name}: {e}"); return 'Error'
 
-    def _process_single_refund(self, patient_name, patient_prn, start_date, end_date):
+    def process_refund_list(self, patient_data, start_date, end_date):
+        results = []
         try:
             self.micro_status(f"Navigating to Refund page...")
             self.driver.get("https://gateway.quantumepay.com/credit-card/refund")
             self._set_date_range(start_date, end_date)
-            self.micro_status(f"Searching for '{patient_name}'...")
+            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', '')
+                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.2)
+                else:
+                    self.micro_status(f"Processing '{patient_name}' ({index + 1}/{len(patient_data)})...")
+                    status = self._process_single_refund(patient_name, patient_prn)
+                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})
+        except Exception as e:
+            print(f"A fatal error occurred during the Refund workflow: {e}")
+            self.micro_status("A fatal error stopped the Refund process.")
+        return results
+
+    def _process_single_refund(self, patient_name, patient_prn):
+        try:
+            self.micro_status(f"Searching for '{patient_name}' on Refund page...")
             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)
@@ -196,8 +211,11 @@ class QuantumBot:
             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...")
-                self._force_clear_and_fill((By.NAME, "company_name"), patient_name)
-                self._force_clear_and_fill((By.NAME, "company_contact"), patient_prn)
+                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'