Porject Uploaded

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.11-slim
+WORKDIR /app
+COPY . .
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    libssl-dev \
+    libffi-dev \
+    python3-dev \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+RUN pip install --no-cache-dir -r requirements.txt
+EXPOSE 7860
+CMD ["python", "server.py"]

config/emails.conf

@@ -0,0 +1,4 @@
+derinpatel@hillsidemedicalgroup.com
+bruno.carvalho@iglobalservices.net
+arajendra@hillsidemedicalgroup.com
+smahato@hillsidemedicalgroup.com

requirements.txt

@@ -0,0 +1,11 @@
+pandas
+Flask
+Flask-SocketIO
+Flask-Cors
+eventlet
+python-dotenv
+selenium
+webdriver-manager
+google-api-python-client
+google-auth-httplib2
+google-auth-oauthlib

server.py

@@ -0,0 +1,190 @@
+import eventlet
+eventlet.monkey_patch()
+
+import pandas as pd
+import io
+import threading
+import os
+import base64
+import json
+from datetime import datetime
+from flask import Flask, Response
+from flask_socketio import SocketIO, emit
+from flask_cors import CORS
+from worker import QuantumBot
+import smtplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from email.mime.base import MIMEBase
+from email import encoders
+from dotenv import load_dotenv
+
+load_dotenv()
+
+app = Flask(__name__)
+app.config['SECRET_KEY'] = 'secret-key-for-hillside-automation'
+CORS(app, resources={r"/*": {"origins": "*"}})
+socketio = SocketIO(app, cors_allowed_origins="*", async_mode='eventlet')
+
+bot_instance = None
+session_data = {}
+automation_thread = None
+
+class GoogleDriveService:
+    def __init__(self):
+        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
+            
+            # --- Definitive Secure Credential Loading ---
+            base64_creds = os.getenv('GDRIVE_SA_KEY_BASE64')
+            if not base64_creds:
+                raise ValueError("GDRIVE_SA_KEY_BASE64 secret not found.")
+            if not self.folder_id:
+                raise ValueError("GOOGLE_DRIVE_FOLDER_ID secret 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 securely from secrets.")
+        except Exception as e:
+            print(f"[G-Drive] CRITICAL ERROR: Could not initialize Google Drive service: {e}")
+
+    def upload_file(self, filename, file_content):
+        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
+
+class EmailService:
+    def __init__(self):
+        self.sender_email = os.getenv('EMAIL_SENDER')
+        self.password = os.getenv('EMAIL_PASSWORD')
+        self.smtp_server = "smtp.gmail.com"; self.smtp_port = 587
+        if not self.sender_email or not self.password: print("[Email] WARNING: Email credentials not found in secrets.")
+    def send_report(self, recipients, subject, body, attachments=None):
+        if not self.sender_email or not self.password: return False
+        try:
+            msg = MIMEMultipart(); msg['From'] = self.sender_email; msg['To'] = ", ".join(recipients); msg['Subject'] = subject
+            msg.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}"')
+                    msg.attach(part)
+            with smtplib.SMTP(self.smtp_server, self.smtp_port) as server:
+                server.starttls(); server.login(self.sender_email, self.password); server.send_message(msg)
+            print(f"Email sent successfully to {', '.join(recipients)}"); return True
+        except Exception as e: print(f"Failed to send email: {e}"); return False
+
+email_service = EmailService()
+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 []
+
+def run_automation_process(session_id):
+    global bot_instance
+    results = []; is_terminated = False; is_crash = False
+    try:
+        data = session_data.get(session_id, {}); csv_content = data.get('csv_content')
+        df = pd.read_csv(io.StringIO(csv_content));
+        if 'Status' not in df.columns: df.insert(1, 'Status', '')
+        patient_list = df[ (df['Status'] != 'Done') & (df['Status'] != 'Bad') ]['Name'].tolist()
+        socketio.emit('initial_stats', {'total': len(patient_list)})
+        results = bot_instance.process_patient_list(patient_list)
+        is_terminated = bot_instance.termination_event.is_set()
+    except Exception as e:
+        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]
+
+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, {}); original_df = pd.read_csv(io.StringIO(data.get('csv_content')))
+    if 'Status' not in original_df.columns: original_df.insert(1, 'Status', '')
+    result_df = pd.DataFrame(results).set_index('Name'); original_df.set_index('Name', inplace=True)
+    original_df.update(result_df); full_df = original_df.reset_index()
+    bad_df = full_df[full_df['Status'] == 'Bad'][['Name', '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"
+    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 due to an error" if is_crash_report else "completed successfully"
+    subject = f"Automation Report [{status_text.upper()}]: {custom_name}"
+    body = f"""<html><body><h2>Hillside's Quantum Automation Report</h2><p><b>The process was {status_text}.</b></p><p><b>Total Patients in File:</b> {len(full_df)}</p><p><b>Processed in this run:</b> {len(results)}</p><p><b>Successful ('Done'):</b> {len([r for r in results if r['Status'] == 'Done'])}</p><p><b>Bad State ('Bad'):</b> {len([r for r in results if r['Status'] == 'Bad'])}</p><p>The full report and a list of 'Bad' status patients from this run are attached.</p></body></html>"""
+    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:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica,Arial,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's Automation API</h1><div class="indicator active">● Active</div></div></body></html>
+    """
+    return Response(APP_STATUS_HTML)
+
+@socketio.on('connect')
+def handle_connect():
+    print('Frontend connected.'); emit('email_list', {'emails': get_email_list()})
+
+@socketio.on('initialize_session')
+def handle_init(data):
+    session_id = 'user_session'
+    session_data[session_id] = {'csv_content': data['content'], 'emails': data['emails'], 'filename': data['filename']}
+    global bot_instance
+    if bot_instance: bot_instance.shutdown()
+    bot_instance = QuantumBot(socketio, app)
+    if bot_instance.initialize_driver(): emit('bot_initialized')
+    else: emit('error', {'message': 'Failed to initialize the automation bot.'})
+
+@socketio.on('start_login')
+def handle_login(credentials):
+    if not bot_instance: return emit('error', {'message': 'Bot not initialized.'})
+    if bot_instance.login(credentials['username'], credentials['password']): emit('otp_required')
+    else: emit('error', {'message': 'Login failed. Please check credentials.'})
+
+@socketio.on('submit_otp')
+def handle_otp(data):
+    if not bot_instance: return emit('error', {'message': 'Bot not initialized.'})
+    if bot_instance.submit_otp(data['otp']):
+        emit('login_successful')
+        session_id = 'user_session'
+        socketio.start_background_task(target=run_automation_process, session_id=session_id)
+    else: emit('error', {'message': 'OTP was incorrect or timed out.'})
+
+@socketio.on('terminate_process')
+def handle_terminate():
+    if bot_instance: print("Termination signal received."); bot_instance.stop()
+
+if __name__ == '__main__':
+    print("====================================================================")
+    print("  Hillside Automation Backend - PRODUCTION READY")
+    print("  Make sure all secrets are set in your Hugging Face Space.")
+    print("  Listening on http://127.0.0.1:5000")
+    print("====================================================================")
+    socketio.run(app, host='0.0.0.0', port=int(os.getenv('PORT', 7860)))

worker.py

@@ -0,0 +1,150 @@
+import pandas as pd
+import time
+import io
+import threading
+from selenium import webdriver
+from selenium.webdriver.chrome.service import Service as ChromeService
+from selenium.webdriver.chrome.options import Options as ChromeOptions
+from webdriver_manager.chrome import ChromeDriverManager
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+
+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...")
+            options = ChromeOptions()
+            user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36"
+            options.add_argument(f'user-agent={user_agent}')
+            options.add_argument("--headless")
+            options.add_argument("--window-size=1920,1080")
+            options.add_argument('--disable-blink-features=AutomationControlled')
+            options.add_experimental_option("excludeSwitches", ["enable-automation"])
+            options.add_experimental_option('useAutomationExtension', False)
+            service = ChromeService(ChromeDriverManager().install())
+            self.driver = webdriver.Chrome(service=service, options=options)
+            self.driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
+                'source': "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
+            })
+            return True
+        except Exception as e:
+            print(f"CRITICAL ERROR in WebDriver Initialization: {e}")
+            self.micro_status(f"Error: Could not start browser. {e}")
+            return False
+
+    def micro_status(self, message):
+        print(f"[Bot Action] {message}")
+        with self.app.app_context():
+            self.socketio.emit('micro_status_update', {'message': message})
+
+    def stop(self):
+        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("Waiting for OTP screen...")
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.presence_of_element_located((By.ID, "code1")))
+            return True
+        except Exception as e:
+            print(f"[Bot] ERROR during login: {e}")
+            return False
+
+    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
+        except Exception as e:
+            print(f"[Bot] ERROR during OTP submission: {e}")
+            return False
+
+    def process_patient_list(self, patient_list):
+        results = []
+        for index, patient_name in enumerate(patient_list):
+            if self.termination_event.is_set():
+                print("[Bot] Termination detected. Stopping process.")
+                break
+            
+            with self.app.app_context():
+                self.socketio.emit('stats_update', {
+                    'processed': len(results),
+                    'remaining': len(patient_list) - len(results)
+                })
+            
+            self.micro_status(f"Processing '{patient_name}' ({index + 1}/{len(patient_list)})...")
+            status = self._process_single_patient(patient_name)
+            results.append({'Name': patient_name, 'Status': status})
+            
+            with self.app.app_context():
+                self.socketio.emit('log_update', {'name': patient_name, 'status': status})
+        return results
+
+    def _process_single_patient(self, patient_name):
+        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 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)
+            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)
+                WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button/span[normalize-space()='Save Changes']"))).click()
+                WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Confirm']]"))).click()
+                time.sleep(5)
+                return 'Done'
+            except TimeoutException:
+                self.micro_status(f"'{patient_name}' is in a bad state, cancelling.")
+                WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Cancel']]"))).click()
+                return 'Bad'
+        except Exception as e:
+            print(f"An error occurred while processing {patient_name}: {e}")
+            return 'Error'
+            
+    def shutdown(self):
+        if self.driver:
+            self.driver.quit()