Fixing this

server.py

@@ -165,41 +165,6 @@ def extract_patient_name(raw_name):
     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_and_init():
-    session_id = 'user_session'
-    try:
-        session_data_from_header = json.loads(request.headers.get('X-Session-Data'))
-        session_data[session_id] = session_data_from_header
-        
-        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()}
-        
-        df_quantum['PRN'] = df_quantum['Name'].apply(lambda name: prn_lookup_dict.get(name, ""))
-        
-        master_df = df_quantum.copy()
-        master_df['Status'] = ''
-        
-        # We save the full, merged dataframe for the final report
-        session_data[session_id]['patient_data_for_report'] = master_df
-        # We only process records that have a PRN
-        session_data[session_id]['patient_data'] = master_df[master_df['PRN'] != ''].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.')
@@ -208,24 +173,51 @@ def handle_connect():
 @socketio.on('initialize_session')
 def handle_init(data):
     session_id = 'user_session'
-    session_data[session_id] = data # Store mode, dates, emails etc.
+    session_data[session_id] = data
     
+    mode = data.get('mode')
+    
+    if mode == 'void':
+        try:
+            app_data_content = base64.b64decode(data['app_data_content']).decode('utf-8')
+            quantum_data_content = base64.b64decode(data['quantum_data_content']).decode('utf-8')
+
+            df_app = pd.read_excel(io.BytesIO(base64.b64decode(data['app_data_content']))) if data['app_data_filename'].endswith('.xlsx') else pd.read_csv(io.StringIO(app_data_content))
+            df_quantum = pd.read_excel(io.BytesIO(base64.b64decode(data['quantum_data_content']))) if data['quantum_data_filename'].endswith('.xlsx') else 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.")
+            
+            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()}
+            
+            df_quantum['PRN'] = df_quantum['Name'].apply(lambda name: prn_lookup_dict.get(name, ""))
+            
+            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')
+            
+            emit('data_processed')
+        except Exception as e:
+            print(f"[Server Log] ERROR during file processing: {e}")
+            emit('error', {'message': str(e)})
+    else: # For refund mode, we just need to initialize the bot
+        emit('data_processed')
+
+
+@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:
-        emit('bot_initialized')
+        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('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):
     if not bot_instance: return emit('error', {'message': 'Bot not initialized.'})

worker.py

@@ -12,7 +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 webdriver_manager.chrome import ChromeDriverManager
 
 class QuantumBot:
     def __init__(self, socketio, app):
@@ -22,16 +21,18 @@ class QuantumBot:
 
     def initialize_driver(self):
         try:
-            self.micro_status("Initializing browser...")
-            options = ChromeOptions()
-            options.add_argument("--start-maximized")
-            options.add_argument('--disable-blink-features=AutomationControlled')
-            options.add_experimental_option("excludeSwitches", ["enable-automation"])
-            options.add_experimental_option('useAutomationExtension', False)
+            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}")
             os.makedirs(self.download_dir, exist_ok=True)
             prefs = {"download.default_directory": self.download_dir}
             options.add_experimental_option("prefs", prefs)
-            service = ChromeService(ChromeDriverManager().install())
+            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})"
@@ -87,8 +88,12 @@ class QuantumBot:
         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 VOID for '{patient_name}' ({index + 1}/{len(patient_data)})...")
-            status = self._process_single_void_or_refund(patient_name, patient_prn, "void")
+            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_record(patient_name, patient_prn, "void")
+            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})
@@ -100,30 +105,36 @@ class QuantumBot:
         downloaded_df = self._download_report(start_date_str, end_date_str, "refund")
         if downloaded_df is None: raise Exception("Failed to download the refund report.")
         
+        if 'Name' not in downloaded_df.columns: raise Exception("Downloaded report is missing 'Name' column.")
+        if 'PRN' not in downloaded_df.columns: downloaded_df['PRN'] = ''
+        
         patient_data = downloaded_df.to_dict('records')
         self.socketio.emit('initial_stats', {'total': len(patient_data)})
 
         results = []
+        # The first record sets the date range, subsequent records reuse the page
+        is_first_record = True
         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_void_or_refund(patient_name, patient_prn, "refund", start_date_str, end_date_str, is_first_record=(index==0))
+            status = self._process_single_record(patient_name, patient_prn, "refund", start_date_str, end_date_str, is_first_record=is_first_record)
+            is_first_record = False # Only the first one needs to set the date
             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_or_refund(self, patient_name, patient_prn, mode, start_date_str=None, end_date_str=None, is_first_record=False):
+    def _process_single_record(self, patient_name, patient_prn, mode, start_date_str=None, end_date_str=None, is_first_record=False):
         try:
             page_url = f"https://gateway.quantumepay.com/credit-card/{mode}"
-            self.micro_status(f"Navigating to {mode.title()} page for '{patient_name}'")
-            self.driver.get(page_url)
-            time.sleep(3)
-
-            if mode == 'refund' and not is_first_record:
-                self._set_date_range_on_page(start_date_str, end_date_str)
+            if mode == 'void' or is_first_record:
+                self.micro_status(f"Navigating to {mode.title()} page for '{patient_name}'")
+                self.driver.get(page_url)
+                time.sleep(3)
+                if mode == 'refund':
+                    self._set_date_range_on_page(start_date_str, end_date_str)
 
             search_successful = False
             for attempt in range(5):
@@ -149,11 +160,10 @@ class QuantumBot:
                 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)
-                if patient_prn and str(patient_prn).strip() and str(patient_prn).lower() != 'nan':
-                    self.micro_status(f"Entering PRN: {patient_prn}...")
-                    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))
+                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'
@@ -231,5 +241,6 @@ class QuantumBot:
             if os.path.exists(self.download_dir):
                 import shutil
                 shutil.rmtree(self.download_dir)
+            self._kill_chrome_processes()
             print("[Bot Log] Chrome session and downloads cleaned up.")
         except Exception as e: print(f"[Bot Log] Error during shutdown: {e}")