Fixing this

server.py

@@ -1,10 +1,23 @@
+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
+from selenium.webdriver.common.by import By
+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 datetime import datetime
+import os
+
+# Socket / Flask stack
 import eventlet
 eventlet.monkey_patch()
 
-import pandas as pd
 import io
-import threading
-import os
 import base64
 import json
 import re
@@ -12,7 +25,6 @@ from datetime import datetime
 from flask import Flask, Response, request, jsonify
 from flask_socketio import SocketIO, emit
 from flask_cors import CORS
-from worker import QuantumBot
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 from email.mime.base import MIMEBase
@@ -21,6 +33,269 @@ from dotenv import load_dotenv
 
 load_dotenv()
 
+
+class QuantumBot:
+    def __init__(self, socketio, app):
+        self.socketio = socketio
+        self.app = app
+        self.driver = None
+        self.DEFAULT_TIMEOUT = 30
+        self.termination_event = threading.Event()
+
+    def initialize_driver(self):
+        try:
+            self.micro_status("Initializing headless browser with stable configuration...")
+            options = ChromeOptions()
+            options.binary_location = "/usr/bin/chromium"
+
+            # Minimal, stable args
+            options.add_argument("--headless=new")
+            options.add_argument("--no-sandbox")
+            options.add_argument("--disable-dev-shm-usage")
+            options.add_argument("--window-size=1920,1080")
+
+            service = ChromeService(executable_path="/usr/bin/chromedriver")
+            self.driver = webdriver.Chrome(service=service, options=options)
+            self.micro_status("Browser initialized successfully.")
+            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):
+        print(f"[Bot Log] {message}")
+        with self.app.app_context():
+            self.socketio.emit('micro_status_update', {'message': message})
+
+    def stop(self):
+        self.micro_status("Termination signal received...")
+        self.termination_event.set()
+
+    def login(self, username, password):
+        try:
+            self.micro_status("Navigating to login page...")
+            self.driver.get("https://gateway.quantumepay.com/account/login")
+            time.sleep(2)
+            self.micro_status("Entering credentials...")
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.ID, "Username"))).send_keys(username)
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((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")))
+            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):
+        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])
+            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}")
+            return False, error_message
+
+    def start_processing(self, process_type, patient_data, **kwargs):
+        if process_type == 'void':
+            return self.process_void_list(patient_data)
+        elif process_type == 'refund':
+            return self.process_refund_list(patient_data, kwargs.get('start_date'), kwargs.get('end_date'))
+        else:
+            return []
+
+    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', '')
+            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_void(patient_name, patient_prn)
+            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})
+                self.socketio.emit('stats_update', {'processed': index + 1, 'remaining': len(patient_data) - (index + 1), 'status': status})
+        return results
+
+    def process_refund_list(self, patient_data, start_date_str, end_date_str):
+        results = []
+        try:
+            self.micro_status("Navigating to Refund page to set date range...")
+            self.driver.get("https://gateway.quantumepay.com/credit-card/refund")
+            if not self._set_date_range_on_page(start_date_str, end_date_str):
+                raise Exception("Failed to set date range.")
+        except Exception as e:
+            self.micro_status(f"Critical error setting date range: {e}. Aborting refund process.")
+            for record in patient_data:
+                results.append({'Name': record['Name'], 'PRN': record.get('PRN', ''), 'Status': 'Error - Date Setup Failed'})
+            return 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 REFUND for '{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': index + 1, 'remaining': len(patient_data) - (index + 1), '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:
+                    self.micro_status(f"Searching... (Attempt {attempt + 1})")
+                    WebDriverWait(self.driver, 2).until(EC.presence_of_element_located((By.XPATH, "//div[contains(@class, 'table-wrapper')]")))
+                    search_box = WebDriverWait(self.driver, 2).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)
+                    search_successful = True
+                    break
+                except Exception:
+                    time.sleep(1)
+            if not search_successful:
+                raise Exception("Failed to search for patient.")
+            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("Adding to Vault...")
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button/span[normalize-space()='Add to Vault']"))).click()
+            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...")
+                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 during VOID for {patient_name}: {e}")
+            return 'Error'
+
+    def _get_calendar_months(self):
+        try:
+            titles = self.driver.find_elements(By.XPATH, "//div[contains(@class, 'vc-title')]")
+            return [datetime.strptime(title.text.strip(), "%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"
+                aria_label = target_date.strftime(f"%A, %B {day_format}, %Y")
+                day_xpath = f"//span[@aria-label='{aria_label}']"
+                day_element = WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable((By.XPATH, day_xpath)))
+                self.driver.execute_script("arguments.click();", day_element)
+                return
+            arrow_button_xpath = (
+                "//div[contains(@class, 'vc-arrow') and contains(@class, 'is-left')]"
+                if target_date < visible_months
+                else "//div[contains(@class, 'vc-arrow') and contains(@class, 'is-right')]"
+            )
+            self.driver.find_element(By.XPATH, arrow_button_xpath).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):
+        try:
+            self.micro_status("Opening calendar to set date range...")
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[contains(text(), '-')]]"))).click()
+            time.sleep(1)
+            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)
+            self.micro_status("Date range set. Waiting for data to filter...")
+            time.sleep(5)
+            return True
+        except Exception as e:
+            self.micro_status(f"Error setting date range: {e}")
+            return False
+
+    def _process_single_refund(self, patient_name, patient_prn):
+        try:
+            search_successful = False
+            for attempt in range(15):
+                try:
+                    self.micro_status(f"Searching for '{patient_name}'... (Attempt {attempt+1})")
+                    search_box = WebDriverWait(self.driver, 2).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)
+                    search_successful = True
+                    break
+                except Exception:
+                    time.sleep(1)
+            if not search_successful:
+                raise Exception("Failed to search for patient in Refund.")
+            time.sleep(3)
+            self.micro_status(f"Performing refund action for '{patient_name}'...")
+            time.sleep(2)
+            return "Done"
+        except Exception as e:
+            print(f"An error occurred during REFUND for {patient_name}: {e}")
+            return 'Error'
+
+    def shutdown(self):
+        try:
+            if self.driver:
+                self.driver.quit()
+            print("[Bot Log] Chrome session closed.")
+        except Exception as e:
+            print(f"[Bot Log] Error during shutdown: {e}")
+
+
 app = Flask(__name__)
 app.config['SECRET_KEY'] = 'secret-key-for-hillside-automation'
 FRONTEND_ORIGIN = os.getenv('FRONTEND_URL', 'https://quantbot.netlify.app')
@@ -84,6 +359,7 @@ class GmailApiService:
             print(f"[Server Log] Failed to send email: {e}")
             return False
 
+
 class GoogleDriveService:
     def __init__(self):
         self.creds = None
@@ -119,9 +395,11 @@ class GoogleDriveService:
             print(f"[Server Log] G-Drive ERROR: File upload failed: {e}")
             return False
 
+
 email_service = GmailApiService()
 drive_service = GoogleDriveService()
 
+
 def get_email_list():
     try:
         with open('config/emails.conf', 'r') as f:
@@ -129,6 +407,14 @@ def get_email_list():
     except FileNotFoundError:
         return []
 
+
+def extract_patient_name(raw_name):
+    if not isinstance(raw_name, str):
+        return ""
+    name_only = raw_name.split('DOB').strip()
+    return re.sub(r'[:\d\-\s]+$', '', name_only).strip()
+
+
 def run_automation_process(session_id):
     global bot_instance
     results = []
@@ -158,6 +444,7 @@ 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):
     data = session_data.get(session_id, {})
     if not data:
@@ -182,7 +469,6 @@ def generate_and_send_reports(session_id, results, is_crash_report=False, is_ter
     full_report_name = f"{custom_name}_Full.csv"
     bad_report_name = f"{custom_name}_Bad.csv"
     skipped_report_name = f"{custom_name}_Skipped.csv"
-
     full_report_content = final_report_df.to_csv(index=False)
     drive_service.upload_file(full_report_name, full_report_content)
 
@@ -191,7 +477,6 @@ 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" if is_crash_report else "Completed Successfully"
 
     stats = {
@@ -204,25 +489,19 @@ def generate_and_send_reports(session_id, results, is_crash_report=False, is_ter
     process_type_str = data.get('mode', 'Unknown').title()
     subject = f"{process_type_str} Automation Report [{status_text.upper()}]: {custom_name}"
 
-    professional_body = email_service.create_professional_email_template(
-        subject, status_text, stats, custom_name, process_type_str
-    )
+    professional_body = email_service.create_professional_email_template(subject, status_text, stats, custom_name, process_type_str)
 
     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 ""
-    name_only = raw_name.split('DOB').strip()
-    return re.sub(r'[:\d\-\s]+$', '', name_only).strip()
 
-# Existing HTTP route (kept as-is)
+# ------------ Existing HTTP route (kept unchanged) ------------
 @app.route('/process_and_initialize', methods=['POST'])
 def handle_file_processing_and_init():
     session_id = 'user_session'
@@ -265,7 +544,19 @@ def handle_file_processing_and_init():
         print(f"[Server Log] ERROR during file processing: {e}")
         return jsonify({"error": str(e)}), 500
 
-# NEW: Socket.IO handler to mirror the HTTP route for the base64 payload from the frontend
+
+# ------------ Socket.IO Handlers ------------
+@socketio.on('connect')
+def handle_connect():
+    print('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()})
+
+
 @socketio.on('initialize_and_process_files')
 def initialize_and_process_files(payload):
     session_id = 'user_session'
@@ -277,57 +568,57 @@ def initialize_and_process_files(payload):
             'start_date': payload.get('start_date'),
             'end_date': payload.get('end_date')
         }
+        session_data[session_id] = data
 
-        # Decode base64 content sent by the frontend
-        app_bytes = base64.b64decode(payload['app_data_content'])
-        quantum_bytes = base64.b64decode(payload['quantum_data_content'])
+        # Validate presence of base64 files
+        app_b64 = payload.get('app_data_content')
+        app_name = payload.get('app_data_filename', '')
+        quantum_b64 = payload.get('quantum_data_content')
+        quantum_name = payload.get('quantum_data_filename', '')
+        if not app_b64 or not quantum_b64:
+            emit('error', {'message': 'Both files are required.'})
+            return
 
-        # Read into DataFrames based on file extensions
-        if payload['app_data_filename'].lower().endswith('.xlsx'):
-            df_app = pd.read_excel(io.BytesIO(app_bytes))
-        else:
-            df_app = pd.read_csv(io.BytesIO(app_bytes))
+        # Decode base64 -> BytesIO
+        app_buf = io.BytesIO(base64.b64decode(app_b64))
+        quantum_buf = io.BytesIO(base64.b64decode(quantum_b64))
 
-        if payload['quantum_data_filename'].lower().endswith('.xlsx'):
-            df_quantum = pd.read_excel(io.BytesIO(quantum_bytes))
-        else:
-            df_quantum = pd.read_csv(io.BytesIO(quantum_bytes))
+        # Load frames as per file extension
+        df_app = pd.read_excel(app_buf) if app_name.endswith('.xlsx') else pd.read_csv(app_buf)
+        df_quantum = pd.read_excel(quantum_buf) if quantum_name.endswith('.xlsx') else pd.read_csv(quantum_buf)
 
-        # Validations (same as HTTP route)
+        # Validations
         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.")
+            emit('error', {'message': "App Data must contain 'Patient Name' and 'PRN' columns."})
+            return
         if 'Name' not in df_quantum.columns:
-            raise ValueError("Quantum Data must contain a 'Name' column.")
+            emit('error', {'message': "Quantum Data must contain a 'Name' column."})
+            return
 
+        # Filter and build lookup
         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()}
+        prn_lookup_dict = {
+            extract_patient_name(row['Patient Name']): row['PRN']
+            for _, row in df_app_filtered.iterrows()
+        }
 
+        # Attach PRN to Quantum data
         df_quantum['PRN'] = df_quantum['Name'].apply(lambda name: prn_lookup_dict.get(name, ""))
 
+        # Build master
         master_df = df_quantum.copy()
         master_df['Status'] = ''
 
         data['patient_data_for_report'] = master_df
         data['patient_data'] = master_df.to_dict('records')
 
-        session_data[session_id] = data
-
-        # Trigger the frontend to open the login modal
+        # Notify frontend to open login modal
         socketio.emit('data_processed')
     except Exception as e:
-        print(f"[Server Log] ERROR during file processing (socket): {e}")
-        socketio.emit('error', {'message': str(e)})
-
-@socketio.on('connect')
-def handle_connect():
-    print('Frontend connected.')
-    emit('email_list', {'emails': get_email_list()})
+        print(f"[Server Log] ERROR during file processing: {e}")
+        emit('error', {'message': str(e)})
 
-# Optional: respond to explicit client ask
-@socketio.on('get_email_list')
-def handle_get_email_list():
-    emit('email_list', {'emails': get_email_list()})
 
 @socketio.on('start_login')
 def handle_login(credentials):
@@ -345,6 +636,7 @@ def handle_login(credentials):
     else:
         emit('error', {'message': f'Failed to initialize bot: {error_message}'})
 
+
 @socketio.on('submit_otp')
 def handle_otp(data):
     if not bot_instance:
@@ -357,12 +649,14 @@ def handle_otp(data):
     else:
         emit('error', {'message': f'OTP failed: {error_message}'})
 
+
 @socketio.on('terminate_process')
 def handle_terminate():
     if bot_instance:
         print("Termination signal received.")
         bot_instance.stop()
 
+
 if __name__ == '__main__':
     print("====================================================================")
     print("  🤗 Hillside Automation - Definitive Multi-Workflow Platform")