Almost Done

server.py

@@ -137,7 +137,8 @@ def run_automation_process(session_id):
         if workflow == 'void':
             results = bot_instance.process_void_list(patient_data)
         elif workflow == 'refund':
-            results = bot_instance.process_refund_list(patient_data, data.get('start_date'), data.get('end_date'))
+            date_range = {'start_date': data.get('start_date'), 'end_date': data.get('end_date')}
+            results = bot_instance.process_refund_list(patient_data, date_range)
         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
@@ -151,7 +152,7 @@ def run_automation_process(session_id):
 def generate_and_send_reports(session_id, results, is_crash_report=False, is_terminated=False):
     data = session_data.get(session_id, {})
     if not data: return
-
+    
     full_df = pd.DataFrame(data.get('patient_data_for_report'))
     if results:
         result_df = pd.DataFrame(results)
@@ -177,7 +178,7 @@ 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 due to an error" if is_crash_report else "completed successfully"
+    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']),
@@ -218,7 +219,7 @@ def handle_file_processing():
         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.copy()
+        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')
@@ -236,7 +237,13 @@ def handle_connect():
 @socketio.on('initialize_session')
 def handle_init(data):
     session_id = 'user_session'
-    session_data[session_id] = {'emails': data['emails'], 'filename': data['filename'], 'workflow': data['workflow'], 'start_date': data.get('start_date'), 'end_date': data.get('end_date')}
+    session_data[session_id] = {
+        'emails': data['emails'], 
+        'filename': data['filename'],
+        'workflow': data['workflow'],
+        'start_date': data.get('start_date'),
+        'end_date': data.get('end_date')
+    }
     
 @socketio.on('start_login')
 def handle_login(credentials):

worker.py

@@ -2,6 +2,7 @@ import time
 import threading
 import subprocess
 import pandas as pd
+import os
 from selenium import webdriver
 from selenium.webdriver.chrome.service import Service as ChromeService
 from selenium.webdriver.chrome.options import Options as ChromeOptions
@@ -35,12 +36,10 @@ 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})"
-            })
+            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)}"; print(f"CRITICAL ERROR in WebDriver Initialization: {error_message}")
+            error_message = f"Message: {str(e)}"; print(f"CRITICAL ERROR: {error_message}")
             return False, error_message
 
     def micro_status(self, message):
@@ -53,10 +52,8 @@ class QuantumBot:
 
     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...")
+            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()
@@ -64,23 +61,21 @@ class QuantumBot:
             WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.presence_of_element_located((By.ID, "code1")))
             return True, None
         except Exception as e:
-            error_message = f"Error during login: {str(e)}"; print(f"[Bot Log] ERROR during login: {error_message}")
+            error_message = f"Error during login: {str(e)}"; print(f"[Bot Log] ERROR: {error_message}")
             return False, error_message
 
     def submit_otp(self, otp):
         try:
-            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])
+            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}")
+            error_message = f"Error during OTP submission: {str(e)}"; print(f"[Bot Log] ERROR: {error_message}")
             return False, error_message
-            
+
     def _get_calendar_months(self):
         try:
             titles = self.driver.find_elements(By.XPATH, "//div[contains(@class, 'vc-title')]")
@@ -114,30 +109,21 @@ class QuantumBot:
         self.driver.find_element(By.TAG_NAME, "body").click()
         time.sleep(3)
 
-    def process_patient_list(self, patient_data, workflow, date_range=None):
+    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'; 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 _process_single_void(self, patient_name, patient_prn):
@@ -178,12 +164,34 @@ 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)