Added new feature

requirements.txt

@@ -8,3 +8,4 @@ selenium
 google-api-python-client
 google-auth-httplib2
 google-auth-oauthlib
+openpyxl

server.py

@@ -1,3 +1,4 @@
+# server.py - Enhanced with File Processing and PRN Support
 import eventlet
 eventlet.monkey_patch()
 
@@ -23,206 +24,623 @@ load_dotenv()
 
 app = Flask(__name__)
 app.config['SECRET_KEY'] = 'secret-key-for-hillside-automation'
+
 FRONTEND_ORIGIN = os.getenv('FRONTEND_URL', 'https://quantbot.netlify.app')
-CORS(app, resources={r"/*": {"origins": [FRONTEND_ORIGIN, "http://localhost:3000", "http://127.0.0.1:5500", "null"]}})
-socketio = SocketIO(app, cors_allowed_origins=[FRONTEND_ORIGIN, "http://localhost:3000", "http://127.0.0.1:5500", "null"], async_mode='eventlet')
+CORS(app, resources={r"/*": {"origins": [FRONTEND_ORIGIN, "http://localhost:3000", "http://127.0.0.1:5500"]}})
+socketio = SocketIO(app, cors_allowed_origins=[FRONTEND_ORIGIN, "http://localhost:3000", "http://127.0.0.1:5500"], async_mode='eventlet')
 
 bot_instance = None
 session_data = {}
 
+# File Processing Functions
+def standardize_name(name):
+    if not isinstance(name, str):
+        return ""
+    
+    match = re.match(r'^([\w\s,-]+?)\s*(?:ID|$)', name)
+    if not match:
+        return ""
+    
+    clean_name = match.group(1).strip().lower()
+    
+    if ',' in clean_name:
+        parts = [p.strip() for p in clean_name.split(',')]
+        clean_name = "".join(reversed(parts))
+    
+    return re.sub(r'[^a-z0-9]', '', clean_name)
+
+def create_prn_lookup(df_app):
+    prn_dict = {}
+    for index, row in df_app.iterrows():
+        key = standardize_name(row['Patient Name'])
+        if key:
+            prn_dict[key] = row['PRN']
+    return prn_dict
+
+def process_files_for_automation(app_data_file, quantum_data_file):
+    """Process two files and return merged data with Name and PRN columns"""
+    try:
+        # Read files based on extension
+        if app_data_file.filename.endswith('.xlsx'):
+            df_app = pd.read_excel(app_data_file)
+        else:
+            df_app = pd.read_csv(app_data_file)
+            
+        if quantum_data_file.filename.endswith('.xlsx'):
+            df_quantum = pd.read_excel(quantum_data_file)
+        else:
+            df_quantum = pd.read_csv(quantum_data_file)
+        
+        # Validate required columns
+        if 'Patient Name' not in df_app.columns or 'PRN' not in df_app.columns:
+            raise ValueError("App Data file must contain 'Patient Name' and 'PRN' columns.")
+        if 'Name' not in df_quantum.columns:
+            raise ValueError("Quantum Data file must contain a 'Name' column.")
+        
+        # Filter out empty PRN values
+        df_app_filtered = df_app.dropna(subset=['PRN'])
+        df_app_filtered = df_app_filtered[df_app_filtered['PRN'].astype(str).str.strip() != '']
+        
+        # Create PRN lookup dictionary
+        prn_lookup_dict = create_prn_lookup(df_app_filtered)
+        
+        # Match PRNs for each name in Quantum Data
+        prn_list = []
+        for name in df_quantum['Name']:
+            lookup_key = standardize_name(name)
+            prn_value = prn_lookup_dict.get(lookup_key, "")
+            prn_list.append(prn_value)
+        
+        # Create final DataFrame with Name and PRN columns
+        final_df = pd.DataFrame({
+            'Name': df_quantum['Name'],
+            'PRN': prn_list
+        })
+        
+        # Add Status column for automation tracking
+        final_df['Status'] = ''
+        
+        return final_df
+        
+    except Exception as e:
+        raise Exception(f"File processing error: {str(e)}")
+
 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)
-            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)
+            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)
+            
+            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)
             print("[Gmail API] Service initialized successfully")
-        except Exception as e: print(f"[Gmail API] Error: {e}")
+            
+        except Exception as e:
+            print(f"[Gmail API] Error: {e}")
+    
+    def create_professional_email_template(self, subject, status_text, stats, custom_name):
+        """Create professional blood red, white & violet themed email template"""
+        
+        status_color = "#8B0000" if "successfully" in status_text else "#DC143C" if "error" in status_text else "#8A2BE2"
+        current_date = datetime.now().strftime("%B %d, %Y at %I:%M %p")
+        
+        html_template = f"""
+        <!DOCTYPE html>
+        <html lang="en">
+        <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>{subject}</title>
+            <style>
+                * {{
+                    margin: 0;
+                    padding: 0;
+                    box-sizing: border-box;
+                }}
+                
+                body {{
+                    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+                    line-height: 1.6;
+                    color: #2c2c2c;
+                    background-color: #f8f8f8;
+                }}
+                
+                .email-container {{
+                    max-width: 700px;
+                    margin: 20px auto;
+                    background-color: #ffffff;
+                    box-shadow: 0 8px 32px rgba(139, 0, 0, 0.15);
+                    border-radius: 12px;
+                    overflow: hidden;
+                }}
+                
+                .header {{
+                    background: linear-gradient(135deg, #8B0000 0%, #DC143C 50%, #8A2BE2 100%);
+                    color: white;
+                    padding: 40px 30px;
+                    text-align: center;
+                    position: relative;
+                }}
+                
+                .header h1 {{
+                    font-size: 32px;
+                    font-weight: 700;
+                    margin-bottom: 8px;
+                    text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
+                }}
+                
+                .header p {{
+                    font-size: 18px;
+                    opacity: 0.95;
+                    font-weight: 300;
+                    letter-spacing: 1px;
+                }}
+                
+                .status-banner {{
+                    background: {status_color};
+                    color: white;
+                    text-align: center;
+                    padding: 18px;
+                    font-size: 16px;
+                    font-weight: 600;
+                    text-transform: uppercase;
+                    letter-spacing: 1.5px;
+                    box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.2);
+                }}
+                
+                .content {{
+                    padding: 40px 30px;
+                }}
+                
+                .report-info {{
+                    background: linear-gradient(135deg, #f8f8f8 0%, #ffffff 100%);
+                    border-left: 6px solid #8A2BE2;
+                    padding: 25px;
+                    margin-bottom: 35px;
+                    border-radius: 8px;
+                    box-shadow: 0 4px 12px rgba(138, 43, 226, 0.1);
+                }}
+                
+                .info-grid {{
+                    display: grid;
+                    grid-template-columns: 1fr 1fr;
+                    gap: 20px;
+                    margin-bottom: 20px;
+                }}
+                
+                .info-item {{
+                    display: flex;
+                    justify-content: space-between;
+                    align-items: center;
+                    padding: 15px 0;
+                    border-bottom: 2px solid #f0f0f0;
+                }}
+                
+                .stats-grid {{
+                    display: grid;
+                    grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+                    gap: 20px;
+                    margin-bottom: 25px;
+                }}
+                
+                .stat-card {{
+                    background: linear-gradient(135deg, #ffffff 0%, #f8f8f8 100%);
+                    border: 2px solid #e0e0e0;
+                    border-radius: 12px;
+                    padding: 25px 15px;
+                    text-align: center;
+                    box-shadow: 0 4px 15px rgba(0, 0, 0, 0.08);
+                }}
+                
+                .stat-number {{
+                    font-size: 36px;
+                    font-weight: 800;
+                    color: #8A2BE2;
+                    margin-bottom: 10px;
+                }}
+                
+                .attachments-section {{
+                    background: linear-gradient(135deg, #8A2BE2 0%, #9370DB 100%);
+                    color: white;
+                    border-radius: 12px;
+                    padding: 25px;
+                    margin: 35px 0;
+                }}
+                
+                .footer {{
+                    background: linear-gradient(135deg, #2c2c2c 0%, #8B0000 100%);
+                    color: white;
+                    padding: 35px 30px;
+                    text-align: center;
+                }}
+            </style>
+        </head>
+        <body>
+            <div class="email-container">
+                <div class="header">
+                    <h1>Hillside Medical Group</h1>
+                    <p>Patient Processing Report</p>
+                </div>
+                
+                <div class="status-banner">
+                    Process {status_text.title()}
+                </div>
+                
+                <div class="content">
+                    <div class="report-info">
+                        <h3>Report Summary</h3>
+                        <div class="info-grid">
+                            <div class="info-item">
+                                <span>Report Name</span>
+                                <span>{custom_name}</span>
+                            </div>
+                            <div class="info-item">
+                                <span>Generated</span>
+                                <span>{current_date}</span>
+                            </div>
+                            <div class="info-item">
+                                <span>Status</span>
+                                <span style="color: {status_color};">{status_text.title()}</span>
+                            </div>
+                            <div class="info-item">
+                                <span>Processing Type</span>
+                                <span>Automated with PRN</span>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <div class="stats-grid">
+                        <div class="stat-card">
+                            <div class="stat-number">{stats['total']}</div>
+                            <div>Total Records</div>
+                        </div>
+                        <div class="stat-card">
+                            <div class="stat-number">{stats['processed']}</div>
+                            <div>Processed</div>
+                        </div>
+                        <div class="stat-card">
+                            <div class="stat-number">{stats['successful']}</div>
+                            <div>Completed</div>
+                        </div>
+                        <div class="stat-card">
+                            <div class="stat-number">{stats['failed']}</div>
+                            <div>Requires Review</div>
+                        </div>
+                    </div>
+                    
+                    <div class="attachments-section">
+                        <h3>Report Files</h3>
+                        <div style="padding: 15px 0;">
+                            <div>📄 {custom_name}_Full.csv - Complete patient processing report with PRN data</div>
+                        </div>
+                        <div style="padding: 15px 0;">
+                            <div>📄 {custom_name}_Bad.csv - Records requiring manual review</div>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="footer">
+                    <h4>Hillside Medical Group</h4>
+                    <p>Automated patient processing with PRN integration</p>
+                    <div style="margin-top: 25px; font-size: 12px;">
+                        Report generated {current_date}
+                    </div>
+                </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
+        if not self.service:
+            print("[Gmail API] Service not initialized")
+            return False
+        
+        if not recipients:
+            print("[Gmail API] No recipients provided")
+            return False
+        
         try:
             from googleapiclient.errors import HttpError
-            message = MIMEMultipart(); message['From'] = self.sender_email; message['To'] = ', '.join(recipients); message['Subject'] = subject
+            
+            print(f"[Gmail API] Sending report to: {recipients}")
+            
+            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}"')
+                    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)
+            
             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
-        except Exception as e: print(f"[Gmail API] Error: {e}"); return False
+            
+            gmail_message = {'raw': raw_message}
+            sent_message = self.service.users().messages().send(
+                userId='me', 
+                body=gmail_message
+            ).execute()
+            
+            print(f"[Gmail API] Email sent successfully! Message ID: {sent_message['id']}")
+            return True
+            
+        except HttpError as error:
+            print(f"[Gmail API] HTTP Error: {error}")
+            return False
+        except Exception as e:
+            print(f"[Gmail API] Error: {e}")
+            return False
 
 class GoogleDriveService:
     def __init__(self):
-        self.creds = None; self.service = None
+        self.creds = None
+        self.service = None
         self.folder_id = os.getenv('GOOGLE_DRIVE_FOLDER_ID')
         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 or not self.folder_id: raise ValueError("Google Drive secrets not found.")
-            creds_json = base64.b64decode(base64_creds).decode('utf-8'); creds_dict = json.loads(creds_json)
+            if not base64_creds or not self.folder_id:
+                raise ValueError("Google Drive secrets not found.")
+            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("[G-Drive] Service initialized successfully.")
-        except Exception as e: print(f"[G-Drive] ERROR: Could not initialize Google Drive service: {e}")
+        except Exception as e:
+            print(f"[G-Drive] ERROR: Could not initialize Google Drive service: {e}")
     
     def upload_file(self, filename, file_content):
-        if not self.service: return False
+        if not self.service:
+            return False
         try:
             from googleapiclient.http import MediaIoBaseUpload
             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"[G-Drive] File '{filename}' uploaded successfully."); return True
-        except Exception as e: print(f"[G-Drive] ERROR: File upload failed: {e}"); return False
+            print(f"[G-Drive] File '{filename}' uploaded successfully.")
+            return True
+        except Exception as e:
+            print(f"[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: return [line.strip() for line in f if line.strip()]
-    except FileNotFoundError: return []
+        with open('config/emails.conf', 'r') as f:
+            return [line.strip() for line in f if line.strip()]
+    except FileNotFoundError:
+        return []
 
 def run_automation_process(session_id):
     global bot_instance
-    results = []; is_terminated = False; is_crash = False
+    results = []
+    is_terminated = False
+    is_crash = False
     try:
-        data = session_data.get(session_id, {}); patient_data = data.get('patient_data')
-        socketio.emit('initial_stats', {'total': len(patient_data)})
-        results = bot_instance.process_patient_list(patient_data)
+        data = session_data.get(session_id, {})
+        csv_content = data.get('csv_content')
+        df = pd.read_csv(io.StringIO(csv_content))
+        
+        # Ensure required columns exist
+        if 'Name' not in df.columns:
+            raise ValueError("CSV must contain 'Name' column")
+        if 'PRN' not in df.columns:
+            df['PRN'] = ''  # Add empty PRN column if missing
+        if 'Status' not in df.columns:
+            df.insert(len(df.columns), 'Status', '')
+            
+        # Create patient list with Name and PRN
+        patient_records = []
+        for index, row in df.iterrows():
+            if row['Status'] not in ['Done', 'Bad']:
+                patient_records.append({
+                    'Name': row['Name'],
+                    'PRN': row['PRN'] if pd.notna(row['PRN']) else ''
+                })
+        
+        socketio.emit('initial_stats', {'total': len(patient_records)})
+        results = bot_instance.process_patient_list(patient_records)
         is_terminated = bot_instance.termination_event.is_set()
+        
     except Exception as e:
-        print(f"Fatal error in automation thread: {e}"); is_crash = True
+        print(f"Fatal error in automation thread: {e}")
+        is_crash = True
         socketio.emit('error', {'message': f'A fatal error occurred: {e}'})
     finally:
         socketio.emit('micro_status_update', {'message': 'Generating final reports...'})
         generate_and_send_reports(session_id, results, is_crash_report=is_crash, is_terminated=is_terminated)
-        if bot_instance: bot_instance.shutdown(); bot_instance = None
-        if session_id in session_data: del session_data[session_id]
+        if bot_instance:
+            bot_instance.shutdown()
+            bot_instance = None
+        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):
     if not results:
-        socketio.emit('process_complete', {'message': 'No patients were processed.'}); return
-    data = session_data.get(session_id, {});
+        socketio.emit('process_complete', {'message': 'No patients were processed.'})
+        return
+        
+    data = session_data.get(session_id, {})
+    original_df = pd.read_csv(io.StringIO(data.get('csv_content')))
     
-    # Use the prepared data as the base for the final report
-    full_df = pd.DataFrame(data.get('patient_data_for_report'))
-    result_df = pd.DataFrame(results)
-
-    if not result_df.empty:
-        result_df = result_df.set_index(['Name', 'PRN'])
-        full_df = full_df.set_index(['Name', 'PRN'])
-        full_df.update(result_df)
-        full_df.reset_index(inplace=True)
-
+    # Ensure all required columns exist
+    if 'Name' not in original_df.columns:
+        raise ValueError("Original CSV must contain 'Name' column")
+    if 'PRN' not in original_df.columns:
+        original_df['PRN'] = ''
+    if 'Status' not in original_df.columns:
+        original_df['Status'] = ''
+        
+    # Update status based on results
+    result_df = pd.DataFrame(results).set_index('Name')
+    original_df.set_index('Name', inplace=True)
+    original_df.update(result_df[['Status']])  # Only update Status column
+    full_df = original_df.reset_index()
+    
+    # Create bad records report
     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"
+    
+    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"
     full_report_content = full_df.to_csv(index=False)
     
     drive_service.upload_file(full_report_name, full_report_content)
     
-    attachments = {full_report_name: full_report_content, bad_report_name: bad_df.to_csv(index=False)}
-    status_text = "terminated by user" if is_terminated else "crashed" if is_crash_report else "completed"
-    subject = f"Automation Report [{status_text.upper()}]: {custom_name}"
-    body = f"The process was {status_text}. The full report is in Google Drive and also attached."
+    attachments = {
+        full_report_name: full_report_content, 
+        bad_report_name: bad_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"
     
-    email_service.send_report(data.get('emails'), subject, 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 standardize_name(name):
-    if not isinstance(name, str): return ""
-    match = re.match(r'^([\w\s,-]+?)\s*(?:ID|$)', name)
-    if not match: return ""
-    clean_name = match.group(1).strip().lower()
-    if ',' in clean_name:
-        parts = [p.strip() for p in clean_name.split(',')]
-        clean_name = "".join(reversed(parts))
-    return re.sub(r'[^a-z0-9]', '', clean_name)
+    stats = {
+        'total': len(full_df),
+        'processed': len(results),
+        'successful': len([r for r in results if r['Status'] == 'Done']),
+        'failed': len([r for r in results if r['Status'] == 'Bad'])
+    }
+    
+    subject = f"Patient Processing Report - {status_text.title()}: {custom_name}"
+    
+    professional_body = email_service.create_professional_email_template(
+        subject, status_text, stats, custom_name
+    )
+    
+    email_success = email_service.send_report(data.get('emails'), subject, professional_body, attachments)
+    
+    if email_success:
+        socketio.emit('process_complete', {'message': f'Process {status_text}. Report sent successfully.'})
+    else:
+        socketio.emit('process_complete', {'message': f'Process {status_text}. Email sending failed.'})
 
+# File Processing Endpoint
 @app.route('/process_files_for_automation', methods=['POST'])
-def process_files_for_automation():
-    session_id = 'user_session'
-    if 'app_data' not in request.files or 'quantum_data' not in request.files:
-        return jsonify({"error": "Both files are required."}), 400
+def handle_file_processing():
     try:
-        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'])
+        app_data_file = request.files.get('app_data')
+        quantum_data_file = request.files.get('quantum_data')
+        
+        if not app_data_file or not quantum_data_file:
+            return jsonify({"error": "Both files are required."}), 400
+        
+        # Process files and create merged DataFrame
+        merged_df = process_files_for_automation(app_data_file, quantum_data_file)
         
-        df_app_filtered = df_app.dropna(subset=['PRN']); df_app_filtered = df_app_filtered[df_app_filtered['PRN'].astype(str).str.strip() != '']
-        prn_lookup = {standardize_name(row['Patient Name']): row['PRN'] for _, row in df_app_filtered.iterrows()}
+        # Convert to CSV string
+        csv_content = merged_df.to_csv(index=False)
         
-        patient_data_for_automation = []
-        for _, row in df_quantum.iterrows():
-            prn = prn_lookup.get(standardize_name(row['Name']), "")
-            if prn:
-                patient_data_for_automation.append({'Name': row['Name'], 'PRN': prn})
+        # Store in session for automation
+        session_data['user_session']['csv_content'] = csv_content
         
-        # Save the original quantum data for the final report
-        session_data[session_id]['patient_data_for_report'] = df_quantum[['Name']].to_dict('records')
-        session_data[session_id]['patient_data'] = patient_data_for_automation
+        # Emit success to frontend
+        socketio.emit('data_processed', {
+            'total_records': len(merged_df),
+            'records_with_prn': len(merged_df[merged_df['PRN'] != ''])
+        })
+        
+        return jsonify({
+            "success": True,
+            "total_records": len(merged_df),
+            "records_with_prn": len(merged_df[merged_df['PRN'] != '']),
+            "message": "Files processed successfully. Ready for automation."
+        })
         
-        socketio.emit('data_processed')
-        return jsonify({"message": "Data processed successfully."})
     except Exception as e:
         return jsonify({"error": str(e)}), 500
 
+@app.route('/')
+def status_page():
+    APP_STATUS_HTML = """<!DOCTYPE html><html lang="en"><head><title>Hillside Automation</title><style>body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica,Arial,sans-serif;display:flex;justify-content:center;align-items:center;height:100vh;margin:0;background:linear-gradient(135deg, #8B0000 0%, #DC143C 50%, #8A2BE2 100%);color:white;}.status-box{text-align:center;padding:40px 60px;background:rgba(255,255,255,0.15);border-radius:12px;box-shadow:0 8px 30px rgba(0,0,0,0.3);backdrop-filter:blur(10px);}h1{font-size:28px;margin-bottom:10px;} .indicator{font-size:18px;font-weight:600;padding:12px 20px;border-radius:25px;background:rgba(255,255,255,0.2);border:2px solid white;color:white;margin:15px 0;}.info{margin-top:20px;opacity:0.9;}</style></head><body><div class="status-box"><h1>Hillside Automation</h1><div class="indicator">Patient Processing System with PRN</div><div class="info">Chrome: Ready<br>Email: Gmail API<br>Drive: Integrated<br>File Processing: Active<br><br><a href="https://quantbot.netlify.app" style="color:#fff;">quantbot.netlify.app</a></div></div></body></html>"""
+    return Response(APP_STATUS_HTML)
+
 @socketio.on('connect')
 def handle_connect():
-    print(f'Frontend connected.')
+    print(f'Frontend connected from: {FRONTEND_ORIGIN}')
     emit('email_list', {'emails': get_email_list()})
 
 @socketio.on('initialize_session')
 def handle_init(data):
     session_id = 'user_session'
-    session_data[session_id] = {'emails': data['emails'], 'filename': data['filename']}
-    # Bot creation is now handled by the /process endpoint
-
-@socketio.on('start_login')
-def handle_login(credentials):
     global bot_instance
-    if bot_instance: bot_instance.shutdown()
+    session_data[session_id] = {
+        'emails': data['emails'], 
+        'filename': data['filename'],
+        'csv_content': ''  # Will be set by file processing
+    }
+    
+    if bot_instance:
+        bot_instance.shutdown()
     bot_instance = QuantumBot(socketio, app)
+
     is_success, error_message = bot_instance.initialize_driver()
     if is_success:
-        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}'})
+        emit('bot_initialized')
     else:
-        emit('error', {'message': f'Failed to initialize bot: {error_message}'})
+        emit('error', {'message': f'Failed to initialize automation 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.'})
+    if not bot_instance:
+        return emit('error', {'message': 'Bot not initialized.'})
     is_success, error_message = bot_instance.submit_otp(data['otp'])
     if is_success:
         emit('login_successful')
         session_id = 'user_session'
         socketio.start_background_task(run_automation_process, session_id)
-    else: emit('error', {'message': f'OTP failed: {error_message}'})
+    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 bot_instance:
+        print("Termination signal received.")
+        bot_instance.stop()
 
 if __name__ == '__main__':
     print("====================================================================")
-    print("  🤗 Hillside Automation - Two-Phase Processing")
-    print(f"  Frontend URL: {FRONTEND_ORIGIN}")
-    print(f"  Port: {os.getenv('PORT', 7860)}")
+    print("  Hillside Medical Group - Enhanced Patient Processing System")
+    print("  Features: File Processing + PRN Integration + Gmail API Reports")
+    print(f"  Frontend: {FRONTEND_ORIGIN}")
     print("====================================================================")
-    socketio.run(app, host='0.0.0.0', port=int(os.getenv('PORT', 7860)))
+    socketio.run(app, host='0.0.0.0', port=int(os.getenv('PORT', 7860)))

worker.py

@@ -1,6 +1,8 @@
+# worker.py - Enhanced with PRN Support
 import time
 import threading
 import subprocess
+
 from selenium import webdriver
 from selenium.webdriver.chrome.service import Service as ChromeService
 from selenium.webdriver.chrome.options import Options as ChromeOptions
@@ -11,34 +13,54 @@ 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):
+        """Kill any existing Chrome processes to prevent conflicts"""
         try:
-            subprocess.run(['pkill', '-f', 'chromium'], check=True, timeout=5)
+            subprocess.run(['pkill', '-f', 'chrome'], capture_output=True, text=True, timeout=5)
+            subprocess.run(['pkill', '-f', 'chromium'], capture_output=True, text=True, timeout=5)
             time.sleep(1)
-        except Exception:
+        except:
             pass
 
     def initialize_driver(self):
         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("--remote-debugging-port=0")
             options.add_argument("--window-size=1920,1080")
+            options.add_argument("--no-first-run")
+            options.add_argument("--disable-extensions")
+            
             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}")
+            
             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}")
+            error_message = f"Message: {str(e)}"
+            print(f"CRITICAL ERROR in WebDriver Initialization: {error_message}")
             return False, error_message
 
     def micro_status(self, message):
@@ -47,93 +69,195 @@ 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. Finishing current patient...")
+        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...")
-            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()
+            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()
             self.micro_status("Waiting for OTP screen...")
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.presence_of_element_located((By.ID, "code1")))
+            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])
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.ID, "login"))).click()
+            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']")))
+            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):
+    def process_patient_list(self, patient_records):
+        """Process list of patient records with Name and PRN"""
         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['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})
+        for index, patient_record in enumerate(patient_records):
+            if self.termination_event.is_set():
+                print("[Bot] Termination detected. Stopping process.")
+                break
+                
             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
+                    'processed': len(results),
+                    'remaining': len(patient_records) - len(results)
+                })
+                
+            patient_name = patient_record['Name']
+            patient_prn = patient_record.get('PRN', '')
+            
+            self.micro_status(f"Processing '{patient_name}' with PRN '{patient_prn}' ({index + 1}/{len(patient_records)})...")
+            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
                 })
+                
         return results
 
     def _process_single_patient(self, patient_name, patient_prn):
+        """Process single patient with Name and PRN support"""
         try:
             self.micro_status(f"Navigating to Void page for '{patient_name}'")
             self.driver.get("https://gateway.quantumepay.com/credit-card/void")
+
+            # Search for patient
             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.")
+                    self.micro_status(f"Searching for patient (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)
+            
+            # Click patient row and open transaction details
             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()
+            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()
+
+            # Add to Vault
             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()
+            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)
-
-                if patient_prn and pd.notna(patient_prn):
-                    self.micro_status(f"Entering PRN: {patient_prn}...")
-                    contact_input = WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable((By.NAME, "last_name")))
-                    contact_input.clear(); contact_input.send_keys(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'
+                # Fill Company Name (required)
+                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)
+                
+                # Fill Company Contact (PRN) if available
+                if patient_prn and patient_prn.strip():
+                    try:
+                        self.micro_status(f"Adding PRN '{patient_prn}' to Company Contact...")
+                        contact_input = WebDriverWait(self.driver, 5).until(
+                            EC.element_to_be_clickable((By.NAME, "last_name"))
+                        )
+                        contact_input.clear()
+                        contact_input.send_keys(patient_prn)
+                        self.micro_status("PRN added successfully")
+                    except TimeoutException:
+                        self.micro_status("Company Contact field not found, skipping PRN")
+                else:
+                    self.micro_status("No PRN provided, skipping Company Contact field")
+                
+                # Save Changes
+                WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
+                    EC.element_to_be_clickable((By.XPATH, "//button/span[normalize-space()='Save Changes']"))
+                ).click()
+                
+                # Confirm
+                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()
+                try:
+                    WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
+                        EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Cancel']]"))
+                    ).click()
+                except:
+                    pass
                 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}")