Updated logic for file processing

server.py

@@ -32,15 +32,12 @@ session_data = {}
 
 class GmailApiService:
     def __init__(self):
-        self.sender_email = os.getenv('EMAIL_SENDER')
-        self.service = None
+        self.sender_email = os.getenv('EMAIL_SENDER'); self.service = None
         try:
-            from google.oauth2 import service_account
-            from googleapiclient.discovery import build
+            from google.oauth2 import service_account; from googleapiclient.discovery import build
             base64_creds = os.getenv('GDRIVE_SA_KEY_BASE64')
             if not base64_creds: print("[Gmail API] WARNING: GDRIVE_SA_KEY_BASE64 not found."); return
-            creds_json = base64.b64decode(base64_creds).decode('utf-8')
-            creds_dict = json.loads(creds_json)
+            creds_json = base64.b64decode(base64_creds).decode('utf-8'); creds_dict = json.loads(creds_json)
             credentials = service_account.Credentials.from_service_account_info(creds_dict, scopes=['https://www.googleapis.com/auth/gmail.send'])
             if self.sender_email: credentials = credentials.with_subject(self.sender_email)
             self.service = build('gmail', 'v1', credentials=credentials)
@@ -51,20 +48,16 @@ class GmailApiService:
         if not self.service or not recipients: return False
         try:
             from googleapiclient.errors import HttpError
-            message = MIMEMultipart()
-            message['From'] = self.sender_email; message['To'] = ', '.join(recipients); message['Subject'] = subject
+            message = MIMEMultipart(); message['From'] = self.sender_email; message['To'] = ', '.join(recipients); message['Subject'] = subject
             message.attach(MIMEText(body, 'html'))
             if attachments:
                 for filename, content in attachments.items():
-                    part = MIMEBase('application', 'octet-stream')
-                    part.set_payload(content.encode('utf-8'))
-                    encoders.encode_base64(part)
-                    part.add_header('Content-Disposition', f'attachment; filename="{filename}"')
-                    message.attach(part)
+                    part = MIMEBase('application', 'octet-stream'); part.set_payload(content.encode('utf-8'))
+                    encoders.encode_base64(part); part.add_header('Content-Disposition', f'attachment; filename="{filename}"')
+                    msg.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"[Gmail API] Email sent successfully! Message ID: {sent_message['id']}")
-            return True
+            print(f"[Gmail API] Email sent successfully! Message ID: {sent_message['id']}"); return True
         except Exception as e: print(f"[Gmail API] Error: {e}"); return False
 
 class GoogleDriveService:
@@ -121,19 +114,20 @@ def generate_and_send_reports(session_id, results, is_crash_report=False, is_ter
         socketio.emit('process_complete', {'message': 'No patients were processed.'}); return
     data = session_data.get(session_id, {})
     
-    full_df = pd.DataFrame(data.get('patient_data_for_report'))
-    # --- Definitive Data Type Fix ---
-    full_df['Status'] = full_df['Status'].astype('object')
-    
+    # --- Definitive Reporting Fix ---
+    # Create the base of the report from the processed data which includes Name and PRN
+    report_base_df = pd.DataFrame(data.get('patient_data_for_report'))
     result_df = pd.DataFrame(results)
 
     if not result_df.empty:
-        # Use a multi-index merge for robustness
-        full_df = full_df.set_index(['Name', 'PRN'])
-        result_df = result_df.set_index(['Name', 'PRN'])
-        full_df.update(result_df)
-        full_df.reset_index(inplace=True)
-
+        # Use a reliable merge to update the status
+        report_base_df = pd.merge(report_base_df, result_df[['Name', 'Status']], on='Name', how='left')
+        # Fill any rows that weren't processed with their original status (or blank)
+        report_base_df['Status_y'].fillna(report_base_df['Status_x'], inplace=True)
+        report_base_df.rename(columns={'Status_y': 'Status'}, inplace=True)
+        del report_base_df['Status_x']
+
+    full_df = report_base_df
     bad_df = full_df[full_df['Status'] == 'Bad'][['Name', 'PRN', 'Status']]
     timestamp = datetime.now().strftime("%d_%b_%Y"); custom_name = data.get('filename') or timestamp
     full_report_name = f"{custom_name}_Full.csv"; bad_report_name = f"{custom_name}_Bad.csv"
@@ -178,9 +172,10 @@ def handle_file_processing():
         filtered_df = final_df[final_df['PRN'] != ''].copy()
         
         patient_data_for_automation = filtered_df.to_dict('records')
-        
-        # Base DataFrame for the final report
+
+        # Base DataFrame for the final report now correctly includes PRN
         report_base_df = df_quantum.copy()
+        report_base_df = pd.merge(report_base_df, filtered_df[['Name', 'PRN']], on='Name', how='left')
         report_base_df['Status'] = ''
         report_base_df['Status'] = report_base_df['Status'].astype('object')
         

worker.py

@@ -6,17 +6,15 @@ 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
 
 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()
+        self.socketio = socketio; self.app = app; self.driver = None
+        self.DEFAULT_TIMEOUT = 30; self.termination_event = threading.Event()
 
     def _kill_chrome_processes(self):
         try:
@@ -29,12 +27,9 @@ class QuantumBot:
         try:
             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 = 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}")
@@ -45,8 +40,7 @@ class QuantumBot:
             })
             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 in WebDriver Initialization: {error_message}")
             return False, error_message
 
     def micro_status(self, message):
@@ -55,15 +49,12 @@ class QuantumBot:
             self.socketio.emit('micro_status_update', {'message': message})
 
     def stop(self):
-        self.micro_status("Termination signal received...")
-        self.termination_event.set()
+        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/")
-            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()
@@ -71,39 +62,34 @@ 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] ERROR during login: {error_message}")
+            error_message = f"Error during login: {str(e)}"; print(f"[Bot] 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])
+            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] ERROR during OTP submission: {error_message}")
+            error_message = f"Error during OTP submission: {str(e)}"; print(f"[Bot] ERROR during OTP submission: {error_message}")
             return False, error_message
 
     def process_patient_list(self, patient_data):
         results = []
         for index, record in enumerate(patient_data):
-            if self.termination_event.is_set():
-                print("[Bot] Termination detected.")
-                break
-            patient_name = record['Name']
-            patient_prn = record.get('PRN', '')
+            if self.termination_event.is_set(): print("[Bot] 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 = self._process_single_patient(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})
+                self.socketio.emit('stats_update', {
+                    'processed': len(results), 'remaining': len(patient_data) - len(results), 'status': status
+                })
         return results
 
     def _process_single_patient(self, patient_name, patient_prn):
@@ -116,15 +102,10 @@ class QuantumBot:
                     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.")
+                    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()
@@ -135,39 +116,36 @@ class QuantumBot:
             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)
+                company_input.clear(); company_input.send_keys(patient_name)
 
                 # --- Definitive PRN Handling Logic ---
                 try:
-                    contact_input = WebDriverWait(self.driver, 5).until(EC.element_to_be_clickable((By.NAME, "last_name")))
-                    self.micro_status("Clearing Company Contact field...")
-                    contact_input.clear()
+                    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)
                     if patient_prn and pd.notna(patient_prn) and str(patient_prn).strip():
                         self.micro_status(f"Entering PRN: {patient_prn}...")
                         contact_input.send_keys(str(patient_prn))
                     else:
-                        self.micro_status("No PRN provided, leaving Company Contact blank.")
+                        self.micro_status("No PRN provided, leaving Contact Name blank.")
                 except TimeoutException:
-                    self.micro_status("Company Contact field not found, skipping PRN step.")
+                    self.micro_status("Contact Name field not found, skipping PRN step.")
 
                 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'
+                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'
+            print(f"An error occurred while processing {patient_name}: {e}"); return 'Error'
 
     def shutdown(self):
         try:
-            if self.driver:
-                self.driver.quit()
+            if self.driver: self.driver.quit()
             self._kill_chrome_processes()
             print("[Bot] Chrome session closed and cleaned up.")
-        except Exception as e:
-            print(f"[Bot] Error during shutdown: {e}")
+        except Exception as e: print(f"[Bot] Error during shutdown: {e}")