Spaces:

sonuprasad23
/

quantum-bot

Running

App Files Files Community

sonuprasad23 commited on Sep 14, 2025

Commit

0f47fe3

1 Parent(s): 1675488

Almost Done

Browse files

Files changed (2) hide show

server.py +65 -46
worker.py +78 -82

server.py CHANGED Viewed

@@ -43,9 +43,44 @@ class GmailApiService:
             self.service = build('gmail', 'v1', credentials=credentials)
             print("[Server Log] Gmail API Service initialized successfully")
         except Exception as e: print(f"[Server Log] Gmail API Error: {e}")
     def send_report(self, recipients, subject, body, attachments=None):
-        # Using the provided beautiful email template logic
         if not self.service or not recipients: return False
         try:
             from googleapiclient.errors import HttpError
@@ -58,7 +93,7 @@ class GmailApiService:
                     message.attach(part)
             raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode('utf-8')
             sent_message = self.service.users().messages().send(userId='me', body={'raw': raw_message}).execute()
-            print(f"[Server Log] Email sent successfully! Message ID: {sent_message['id']}"); return True
         except Exception as e: print(f"[Server Log] Failed to send email: {e}"); return False
 class GoogleDriveService:
@@ -71,9 +106,9 @@ class GoogleDriveService:
             creds_json = base64.b64decode(base64_creds).decode('utf-8'); creds_dict = json.loads(creds_json)
             self.creds = service_account.Credentials.from_service_account_info(creds_dict, scopes=['https://www.googleapis.com/auth/drive'])
             self.service = build('drive', 'v3', credentials=self.creds)
-            print("[Server Log] Google Drive Service initialized successfully.")
-        except Exception as e: print(f"[Server Log] G-Drive ERROR: Could not initialize service: {e}")
     def upload_file(self, filename, file_content):
         if not self.service: return False
         try:
@@ -81,8 +116,8 @@ class GoogleDriveService:
             file_metadata = {'name': filename, 'parents': [self.folder_id]}
             media = MediaIoBaseUpload(io.BytesIO(file_content.encode('utf-8')), mimetype='text/csv', resumable=True)
             self.service.files().create(body=file_metadata, media_body=media, fields='id').execute()
-            print(f"[Server Log] File '{filename}' uploaded to Google Drive."); return True
-        except Exception as e: print(f"[Server Log] G-Drive ERROR: File upload failed: {e}"); return False
 email_service = GmailApiService()
 drive_service = GoogleDriveService()
@@ -96,17 +131,13 @@ def run_automation_process(session_id):
     global bot_instance
     results = []; is_terminated = False; is_crash = False
     try:
-        data = session_data.get(session_id, {}); patient_data = data.get('patient_data')
-        if not patient_data: raise ValueError("No patient data prepared for automation.")
         socketio.emit('initial_stats', {'total': len(patient_data)})
-        if data.get('mode') == 'void':
             results = bot_instance.process_void_list(patient_data)
-        elif data.get('mode') == 'refund':
-            results = bot_instance.process_refund_list(patient_data, data['startDate'], data['endDate'])
-        else:
-            raise ValueError("Invalid automation mode specified.")
         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
@@ -118,21 +149,21 @@ def run_automation_process(session_id):
         if session_id in session_data: del session_data[session_id]
 def generate_and_send_reports(session_id, results, is_crash_report=False, is_terminated=False):
-    # This function uses the provided beautiful email template from the other script
-    print("[Server Log] Preparing final reports...")
     data = session_data.get(session_id, {})
-    if not data: print("[Server Log] Session data not found."); return
     full_df = pd.DataFrame(data.get('patient_data_for_report'))
     if results:
         result_df = pd.DataFrame(results)
         if not result_df.empty:
-            result_df.set_index('Name', inplace=True); 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']]
-    bad_df = final_report_df[final_report_df['Status'].isin(['Bad', 'Not Done'])]
     skipped_df = final_report_df[final_report_df['Status'] == 'Skipped - No PRN']
     timestamp = datetime.now().strftime("%d_%b_%Y"); custom_name = data.get('filename') or timestamp
@@ -147,23 +178,20 @@ def generate_and_send_reports(session_id, results, is_crash_report=False, is_ter
         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"
     stats = {
         'total': len(full_df), 'processed': len(results),
         'successful': len(full_df[full_df['Status'] == 'Done']),
         'bad': len(bad_df), 'skipped': len(skipped_df)
     }
     subject = f"Automation Report [{status_text.upper()}]: {custom_name}"
-    # Using the provided beautiful email template logic
     professional_body = email_service.create_professional_email_template(subject, status_text, stats, custom_name)
     email_service.send_report(data.get('emails'), subject, professional_body, attachments)
     socketio.emit('process_complete', {'message': f'Process {status_text}. Report sent.'})
 @app.route('/')
 def status_page():
-    return "<h1>Hillside Automation Backend is running.</h1>"
 def extract_patient_name(raw_name):
     if not isinstance(raw_name, str): return ""
@@ -171,11 +199,11 @@ def extract_patient_name(raw_name):
     return re.sub(r'[:\d\-\s]+$', '', name_only).strip()
 @app.route('/process_files_for_automation', methods=['POST'])
-def handle_void_file_processing():
     session_id = 'user_session'
     try:
         if 'app_data' not in request.files or 'quantum_data' not in request.files:
-            return jsonify({"error": "Both files are required for Void process."}), 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'])
@@ -190,12 +218,14 @@ def handle_void_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
         session_data[session_id]['patient_data'] = master_df.to_dict('records')
         socketio.emit('data_processed')
-        return jsonify({"message": "Void data processed successfully."})
     except Exception as e:
         return jsonify({"error": str(e)}), 500
 @socketio.on('connect')
@@ -206,19 +236,8 @@ def handle_connect():
 @socketio.on('initialize_session')
 def handle_init(data):
     session_id = 'user_session'
-    session_data[session_id] = data
-    if data.get('mode') == 'refund':
-        try:
-            file_content = base64.b64decode(data['fileContent']).decode('utf-8')
-            df = pd.read_csv(io.StringIO(file_content))
-            if 'Name' not in df.columns: raise ValueError("Refund file must contain 'Name' column.")
-            if 'PRN' not in df.columns: df['PRN'] = ''
-            session_data[session_id]['patient_data'] = df.to_dict('records')
-            session_data[session_id]['patient_data_for_report'] = df
-        except Exception as e:
-            socketio.emit('error', {'message': f"Error processing refund file: {e}"})
-            return
 @socketio.on('start_login')
 def handle_login(credentials):
     global bot_instance
@@ -248,7 +267,7 @@ def handle_terminate():
 if __name__ == '__main__':
     print("====================================================================")
-    print("  🤗 Hillside Automation - Definitive Multi-Workflow")
     print(f"  Frontend URL: {FRONTEND_ORIGIN}")
     print(f"  Port: {os.getenv('PORT', 7860)}")
     print("====================================================================")

             self.service = build('gmail', 'v1', credentials=credentials)
             print("[Server Log] Gmail API Service initialized successfully")
         except Exception as e: print(f"[Server Log] Gmail API Error: {e}")
+    def create_professional_email_template(self, subject, status_text, stats, custom_name):
+        status_color = "#28a745" if "completed" in status_text else "#ffc107" if "terminated" in status_text else "#dc3545"
+        current_date = datetime.now().strftime("%B %d, %Y at %I:%M %p")
+        html_template = f"""
+        <!DOCTYPE html>
+        <html><head><title>{subject}</title><style>
+        body{{font-family: 'Segoe UI', sans-serif; background-color: #f8f8f8; color: #2c2c2c;}}
+        .email-container{{max-width: 700px; margin: 20px auto; background-color: #ffffff; border-radius: 12px; overflow: hidden; box-shadow: 0 8px 32px rgba(139, 0, 0, 0.15);}}
+        .header{{background: linear-gradient(135deg, #8A0303 0%, #4c00ff 100%); color: white; padding: 40px 30px; text-align: center;}}
+        .header h1{{font-size: 32px;}} .header p{{font-size: 18px; opacity: 0.95;}}
+        .status-banner{{background: {status_color}; color: white; text-align: center; padding: 18px; font-size: 16px; font-weight: 600; text-transform: uppercase;}}
+        .content{{padding: 40px 30px;}} h3{{color: #8A0303; margin-bottom: 20px; font-size: 20px;}}
+        .stats-grid{{display: grid; grid-template-columns: repeat(auto-fit, minmax(140px, 1fr)); gap: 20px; margin: 35px 0;}}
+        .stat-card{{background: #f8f9fa; border: 1px solid #e0e0e0; border-radius: 12px; padding: 25px 15px; text-align: center;}}
+        .stat-number{{font-size: 36px; font-weight: 700; color: #4c00ff; margin-bottom: 10px;}}
+        .attachments-section{{background: #f8f5ff; border: 1px solid #e0e0e0; border-radius: 12px; padding: 25px; margin: 35px 0;}}
+        .footer{{background: #2c2c2c; color: white; padding: 35px 30px; text-align: center;}}
+        </style></head>
+        <body><div class="email-container"><div class="header"><h1>Hillside's Quantum Automation</h1><p>Patient Processing Report</p></div>
+        <div class="status-banner">Process {status_text}</div>
+        <div class="content"><h3>Processing Results</h3>
+        <div class="stats-grid">
+            <div class="stat-card"><div class="stat-number">{stats['total']}</div><div>Total in File</div></div>
+            <div class="stat-card"><div class="stat-number">{stats['processed']}</div><div>Attempted</div></div>
+            <div class="stat-card"><div class="stat-number" style="color: var(--success);">{stats['successful']}</div><div>Done</div></div>
+            <div class="stat-card"><div class="stat-number" style="color: var(--warning);">{stats['bad']}</div><div>Bad State</div></div>
+            <div class="stat-card"><div class="stat-number" style="color: var(--skipped);">{stats['skipped']}</div><div>Skipped</div></div>
+        </div>
+        <div class="attachments-section"><h3>Attached Reports</h3>
+        <ul><li><b>{custom_name}_Full.csv:</b> The complete report with the final status for every patient.</li>
+        <li><b>{custom_name}_Bad.csv:</b> A filtered list of patients that resulted in a "Bad" state.</li>
+        <li><b>{custom_name}_Skipped.csv:</b> A filtered list of patients that were skipped due to having no PRN.</li></ul></div></div>
+        <div class="footer"><p>&copy; {datetime.now().year} Hillside Automation. This is an automated report.</p></div></div></body></html>
+        """
+        return html_template
     def send_report(self, recipients, subject, body, attachments=None):
         if not self.service or not recipients: return False
         try:
             from googleapiclient.errors import HttpError
                     message.attach(part)
             raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode('utf-8')
             sent_message = self.service.users().messages().send(userId='me', body={'raw': raw_message}).execute()
+            print(f"[Server Log] Email sent! ID: {sent_message['id']}"); return True
         except Exception as e: print(f"[Server Log] Failed to send email: {e}"); return False
 class GoogleDriveService:
             creds_json = base64.b64decode(base64_creds).decode('utf-8'); creds_dict = json.loads(creds_json)
             self.creds = service_account.Credentials.from_service_account_info(creds_dict, scopes=['https://www.googleapis.com/auth/drive'])
             self.service = build('drive', 'v3', credentials=self.creds)
+            print("[Server Log] Google Drive Service initialized.")
+        except Exception as e: print(f"[Server Log] G-Drive ERROR: {e}")
     def upload_file(self, filename, file_content):
         if not self.service: return False
         try:
             file_metadata = {'name': filename, 'parents': [self.folder_id]}
             media = MediaIoBaseUpload(io.BytesIO(file_content.encode('utf-8')), mimetype='text/csv', resumable=True)
             self.service.files().create(body=file_metadata, media_body=media, fields='id').execute()
+            print(f"[Server Log] File '{filename}' uploaded to G-Drive."); return True
+        except Exception as e: print(f"[Server Log] G-Drive ERROR: {e}"); return False
 email_service = GmailApiService()
 drive_service = GoogleDriveService()
     global bot_instance
     results = []; is_terminated = False; is_crash = False
     try:
+        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':
+            results = bot_instance.process_refund_list(patient_data, data.get('start_date'), data.get('end_date'))
         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
         if session_id in session_data: del session_data[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)
         if not result_df.empty:
+            result_df.set_index('Name', inplace=True)
+            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']]
+    bad_df = final_report_df[final_report_df['Status'] == 'Bad']
     skipped_df = final_report_df[final_report_df['Status'] == 'Skipped - No PRN']
     timestamp = datetime.now().strftime("%d_%b_%Y"); custom_name = data.get('filename') or timestamp
         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"
     stats = {
         'total': len(full_df), 'processed': len(results),
         'successful': len(full_df[full_df['Status'] == 'Done']),
         'bad': len(bad_df), 'skipped': len(skipped_df)
     }
     subject = f"Automation Report [{status_text.upper()}]: {custom_name}"
     professional_body = email_service.create_professional_email_template(subject, status_text, stats, custom_name)
     email_service.send_report(data.get('emails'), subject, professional_body, attachments)
     socketio.emit('process_complete', {'message': f'Process {status_text}. Report sent.'})
 @app.route('/')
 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 extract_patient_name(raw_name):
     if not isinstance(raw_name, str): return ""
     return re.sub(r'[:\d\-\s]+$', '', name_only).strip()
 @app.route('/process_files_for_automation', methods=['POST'])
+def handle_file_processing():
     session_id = 'user_session'
     try:
         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'])
         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'] = master_df.to_dict('records')
         socketio.emit('data_processed')
+        print(f"[Server Log] Data prepared. Total records: {len(master_df)}")
+        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')
 @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')}
 @socketio.on('start_login')
 def handle_login(credentials):
     global bot_instance
 if __name__ == '__main__':
     print("====================================================================")
+    print("  🤗 Hillside Automation - Definitive Dual-Workflow Version")
     print(f"  Frontend URL: {FRONTEND_ORIGIN}")
     print(f"  Port: {os.getenv('PORT', 7860)}")
     print("====================================================================")

worker.py CHANGED Viewed

@@ -2,6 +2,7 @@ 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
@@ -11,7 +12,6 @@ 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):
@@ -36,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})"
-            })
             return True, None
         except Exception as e:
-            error_message = f"Message: {str(e)}"; print(f"CRITICAL ERROR in WebDriver Initialization: {error_message}")
             return False, error_message
     def micro_status(self, message):
@@ -63,7 +61,7 @@ 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}")
             return False, error_message
     def submit_otp(self, otp):
@@ -75,37 +73,63 @@ class QuantumBot:
             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 process_void_list(self, patient_data):
-        return self._process_list(patient_data, self._process_single_void_patient)
-    def process_refund_list(self, patient_data, start_date, end_date):
-        return self._process_list(patient_data, self._process_single_refund_patient, start_date=start_date, end_date=end_date)
-    def _process_list(self, patient_data, processing_function, **kwargs):
         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 '{patient_name}' ({index + 1}/{len(patient_data)})...")
-            status = processing_function(patient_name, patient_prn, **kwargs)
             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})
         return results
-    def _process_single_void_patient(self, patient_name, patient_prn):
-        if not patient_prn or not str(patient_prn).strip():
-            self.micro_status(f"Skipping '{patient_name}' (No PRN).")
-            time.sleep(0.5)
-            return 'Skipped - No PRN'
         try:
             self.micro_status(f"Navigating to Void page for '{patient_name}'")
             self.driver.get("https://gateway.quantumepay.com/credit-card/void")
-            # ... (The rest of the robust void logic goes here) ...
             search_successful = False
             for attempt in range(15):
                 try:
@@ -128,6 +152,7 @@ class QuantumBot:
                 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))
@@ -141,16 +166,33 @@ class QuantumBot:
         except Exception as e:
             print(f"An error occurred while processing {patient_name}: {e}"); return 'Error'
-    def _process_single_refund_patient(self, patient_name, patient_prn, start_date, end_date):
         try:
             self.micro_status(f"Navigating to Refund page for '{patient_name}'")
-            self._navigate_and_verify("https://gateway.quantumepay.com/credit-card/refund", "//button[.//span[contains(text(), '-')]]")
-            self._set_date_range_on_page(start_date, end_date)
-            # ... (The rest of the robust refund logic from your script goes here) ...
             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)
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.presence_of_element_located((By.XPATH, f"//tr[contains(., \"{patient_name}\")]")))
             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()
@@ -161,67 +203,21 @@ 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':
-                    contact_input = WebDriverWait(self.driver, 5).until(EC.element_to_be_clickable((By.NAME, "company_contact")))
-                    if contact_input.get_attribute('value') == 'N/A': contact_input.clear()
-                    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(2)
-                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 'Not Done'
         except Exception as e:
-            print(f"An error occurred while processing {patient_name}: {e}")
-            self.micro_status(f"An error occurred for '{patient_name}'. Retrying...")
-            return 'RETRY' # This special status is not used in the final version but is good practice
-    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: 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):
-                day_format = "%#d" if os.name == 'nt' else "%-d"
-                day_xpath = f"//span[@aria-label='{target_date.strftime(f'%A, %B {day_format}, %Y')}']"
-                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()
-            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 to set date range...")
-        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.")
-        time.sleep(2)
-    def _navigate_and_verify(self, url, verification_xpath):
-        self.micro_status(f"Navigating to page...")
-        self.driver.get(url)
-        time.sleep(3)
-        try: WebDriverWait(self.driver, 15).until(EC.element_to_be_clickable((By.XPATH, verification_xpath)))
-        except TimeoutException:
-            self.micro_status("Page not ready, refreshing..."); self.driver.refresh(); time.sleep(3)
-            WebDriverWait(self.driver, 15).until(EC.element_to_be_clickable((By.XPATH, verification_xpath)))
     def shutdown(self):
         try:
             if self.driver: self.driver.quit()

 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
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.common.exceptions import TimeoutException
 from datetime import datetime
 class QuantumBot:
     def __init__(self, socketio, app):
             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})"})
             return True, None
         except Exception as e:
+            error_message = f"Message: {str(e)}"; print(f"CRITICAL ERROR: {error_message}")
             return False, error_message
     def micro_status(self, message):
             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: {error_message}")
             return False, error_message
     def submit_otp(self, otp):
             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: {error_message}")
             return False, error_message
+    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(self, start_date_str, end_date_str):
+        self.micro_status("Opening calendar to set date range...")
+        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() # Click away to close calendar
+        time.sleep(3)
+    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', '')
+            if not patient_prn or not str(patient_prn).strip():
+                self.micro_status(f"Skipping '{patient_name}' (No PRN).")
+                status = 'Skipped - No PRN'; time.sleep(0.5)
+            else:
+                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(patient_data) - len(results), '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:
                 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")))
+                self.micro_status("Clearing Contact Name field...")
                 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))
         except Exception as e:
             print(f"An error occurred while processing {patient_name}: {e}"); return 'Error'
+    def process_refund_list(self, patient_data, start_date, end_date):
+        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', '')
+            if not patient_prn or not str(patient_prn).strip():
+                self.micro_status(f"Skipping '{patient_name}' (No PRN).")
+                status = 'Skipped - No PRN'; time.sleep(0.5)
+            else:
+                self.micro_status(f"Processing '{patient_name}' ({index + 1}/{len(patient_data)})...")
+                status = self._process_single_refund(patient_name, patient_prn, start_date, end_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': len(results), 'remaining': len(patient_data) - len(results), 'status': status})
+        return results
+    def _process_single_refund(self, patient_name, patient_prn, start_date, end_date):
         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(start_date, end_date)
             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)
+            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("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")))
+                self.micro_status("Clearing Contact Name field...")
+                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 while processing {patient_name}: {e}"); return 'Error'
     def shutdown(self):
         try:
             if self.driver: self.driver.quit()