feat: United/DentalHub claim submission automation and patient list sync

- Add full Selenium automation for United/DentalHub claim submission
  (steps 1-8: login, OTP, patient search, practitioner page, code entry,
  other coverage No, attachments, submit, Status & History PDF)
- Consolidate UnitedDH siteKey to UNITED_SCO throughout app
- Fix procedure date overwrite with Ctrl+A+Delete before typing service date
- Fix OTP popup reliability: emit every poll (no throttle)
- Fix Chrome session persistence: only clear cookies on startup
- Add touchPatient() to storage: claim submission now pushes patient to
  top of list across eligibility, claims, and documents pages

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

apps/SeleniumService/agent.py

@@ -21,6 +21,8 @@ import helpers_cca_eligibility as hcca
 import helpers_cca_claim as hcca_claim
 import helpers_cca_preauth as hcca_preauth
 import helpers_ddma_claim as hddma_claim
+import helpers_uniteddh_claim as huniteddh_claim
+import helpers_tuftssco_claim as htuftssco_claim
 
 # Import startup session-clear functions
 from ddma_browser_manager import clear_ddma_session_on_startup
@@ -628,6 +630,90 @@ async def ddma_claim(request: Request):
     return {"status": "started", "session_id": sid}
 
 
+async def _uniteddh_claim_worker_wrapper(sid: str, data: dict, url: str):
+    """Background worker for United/DentalHub claim submission."""
+    global active_jobs, waiting_jobs
+    async with semaphore:
+        async with lock:
+            waiting_jobs -= 1
+            active_jobs += 1
+        try:
+            await huniteddh_claim.start_uniteddh_claim_run(sid, data, url)
+        finally:
+            async with lock:
+                active_jobs -= 1
+
+
+@app.post("/uniteddh-claim")
+async def uniteddh_claim(request: Request):
+    """
+    Starts a United/DentalHub claim submission session in the background.
+    Logs in, searches patient, opens Member Information page, clicks Create claim,
+    fills service date and procedure codes.
+    Body: { "claim": { "uniteddhUsername": "...", "uniteddhPassword": "...", ... } }
+    Returns: { status: "started", session_id: "<uuid>" }
+    """
+    global waiting_jobs
+
+    body = await request.json()
+
+    sid = huniteddh_claim.make_session_entry()
+    huniteddh_claim.sessions[sid]["type"] = "uniteddh_claim"
+    huniteddh_claim.sessions[sid]["last_activity"] = time.time()
+
+    async with lock:
+        waiting_jobs += 1
+
+    asyncio.create_task(_uniteddh_claim_worker_wrapper(
+        sid, body,
+        url="https://app.dentalhub.com/app/login"
+    ))
+
+    return {"status": "started", "session_id": sid}
+
+
+async def _tuftssco_claim_worker_wrapper(sid: str, data: dict, url: str):
+    """Background worker for Tufts SCO (DentaQuest) claim submission."""
+    global active_jobs, waiting_jobs
+    async with semaphore:
+        async with lock:
+            waiting_jobs -= 1
+            active_jobs += 1
+        try:
+            await htuftssco_claim.start_tuftssco_claim_run(sid, data, url)
+        finally:
+            async with lock:
+                active_jobs -= 1
+
+
+@app.post("/tuftssco-claim")
+async def tuftssco_claim(request: Request):
+    """
+    Starts a Tufts SCO (DentaQuest) claim submission session in the background.
+    Logs in, searches patient, opens Member Information page, clicks Create claim,
+    fills service date and procedure codes.
+    Body: { "claim": { "dentaquestUsername": "...", "dentaquestPassword": "...", ... } }
+    Returns: { status: "started", session_id: "<uuid>" }
+    """
+    global waiting_jobs
+
+    body = await request.json()
+
+    sid = htuftssco_claim.make_session_entry()
+    htuftssco_claim.sessions[sid]["type"] = "tuftssco_claim"
+    htuftssco_claim.sessions[sid]["last_activity"] = time.time()
+
+    async with lock:
+        waiting_jobs += 1
+
+    asyncio.create_task(_tuftssco_claim_worker_wrapper(
+        sid, body,
+        url="https://providers.dentaquest.com/"
+    ))
+
+    return {"status": "started", "session_id": sid}
+
+
 async def _cca_preauth_worker_wrapper(sid: str, data: dict, url: str):
     """Background worker for CCA pre-authorization submission."""
     global active_jobs, waiting_jobs
@@ -692,6 +778,10 @@ async def submit_otp(request: Request):
         res = hdentaquest.submit_otp(sid, otp)
     elif sid in hddma_claim.sessions:
         res = hddma_claim.submit_otp(sid, otp)
+    elif sid in huniteddh_claim.sessions:
+        res = huniteddh_claim.submit_otp(sid, otp)
+    elif sid in htuftssco_claim.sessions:
+        res = htuftssco_claim.submit_otp(sid, otp)
     else:
         raise HTTPException(status_code=404, detail="session not found")
 
@@ -719,6 +809,10 @@ async def session_status(sid: str):
         s = hcca_preauth.get_session_status(sid)
     elif sid in hddma_claim.sessions:
         s = hddma_claim.get_session_status(sid)
+    elif sid in huniteddh_claim.sessions:
+        s = huniteddh_claim.get_session_status(sid)
+    elif sid in htuftssco_claim.sessions:
+        s = htuftssco_claim.get_session_status(sid)
     else:
         s = {"status": "not_found"}
     if s.get("status") == "not_found":

apps/SeleniumService/helpers_uniteddh_claim.py

@@ -0,0 +1,344 @@
+import os
+import time
+import asyncio
+from typing import Dict, Any
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.common.exceptions import WebDriverException, TimeoutException
+
+from selenium_UnitedDH_claimSubmitWorker import AutomationUnitedDHClaimSubmit
+
+sessions: Dict[str, Dict[str, Any]] = {}
+
+SESSION_OTP_TIMEOUT = int(os.getenv("SESSION_OTP_TIMEOUT", "120"))
+
+
+def make_session_entry() -> str:
+    import uuid
+    sid = str(uuid.uuid4())
+    sessions[sid] = {
+        "status": "created",
+        "created_at": time.time(),
+        "last_activity": time.time(),
+        "bot": None,
+        "driver": None,
+        "otp_event": asyncio.Event(),
+        "otp_value": None,
+        "result": None,
+        "message": None,
+    }
+    return sid
+
+
+async def cleanup_session(sid: str, message: str | None = None):
+    s = sessions.get(sid)
+    if not s:
+        return
+    try:
+        if s.get("status") not in ("completed", "error", "not_found"):
+            s["status"] = "error"
+        if message:
+            s["message"] = message
+        ev = s.get("otp_event")
+        if ev and not ev.is_set():
+            ev.set()
+    finally:
+        sessions.pop(sid, None)
+        print(f"[helpers_uniteddh_claim] cleaned session {sid}")
+
+
+async def _remove_session_later(sid: str, delay: int = 20):
+    await asyncio.sleep(delay)
+    await cleanup_session(sid)
+
+
+def _minimize_browser(bot):
+    try:
+        if bot and bot.driver:
+            try:
+                bot.driver.get("about:blank")
+            except Exception:
+                pass
+            try:
+                bot.driver.minimize_window()
+                print("[UnitedDH Claim] Browser minimized after error")
+                return
+            except Exception:
+                pass
+            try:
+                bot.driver.set_window_position(-10000, -10000)
+                print("[UnitedDH Claim] Browser moved off-screen after error")
+            except Exception:
+                pass
+    except Exception as e:
+        print(f"[UnitedDH Claim] Could not hide browser: {e}")
+
+
+async def start_uniteddh_claim_run(sid: str, data: dict, url: str):
+    """
+    Run the United/DentalHub claim workflow.
+    Login/OTP handling mirrors helpers_ddma_claim.py exactly.
+    Claim steps call selenium_UnitedDH_claimSubmitWorker.
+    """
+    s = sessions.get(sid)
+    if not s:
+        return {"status": "error", "message": "session not found"}
+
+    s["status"] = "running"
+    s["last_activity"] = time.time()
+
+    bot = None
+    try:
+        bot = AutomationUnitedDHClaimSubmit(data)
+        bot.config_driver()
+
+        s["bot"] = bot
+        s["driver"] = bot.driver
+        s["last_activity"] = time.time()
+
+        try:
+            bot.driver.maximize_window()
+            bot.driver.get(url)
+            await asyncio.sleep(1)
+        except Exception as e:
+            s["status"] = "error"
+            s["message"] = f"Navigation failed: {e}"
+            await cleanup_session(sid)
+            return {"status": "error", "message": s["message"]}
+
+        # --- Login ---
+        try:
+            login_result = bot.login(url)
+        except WebDriverException as wde:
+            s["status"] = "error"
+            s["message"] = f"Selenium driver error during login: {wde}"
+            await cleanup_session(sid, s["message"])
+            return {"status": "error", "message": s["message"]}
+        except Exception as e:
+            s["status"] = "error"
+            s["message"] = f"Unexpected error during login: {e}"
+            await cleanup_session(sid, s["message"])
+            return {"status": "error", "message": s["message"]}
+
+        # ── Already logged in ────────────────────────────────────────────────
+        if isinstance(login_result, str) and login_result == "ALREADY_LOGGED_IN":
+            print("[UnitedDH Claim] Session persisted — skipping OTP")
+            s["status"] = "running"
+            s["message"] = "Session persisted"
+
+        # ── OTP required ─────────────────────────────────────────────────────
+        elif isinstance(login_result, str) and login_result == "OTP_REQUIRED":
+            s["status"] = "waiting_for_otp"
+            s["message"] = "OTP required for login - please enter OTP in browser"
+            s["last_activity"] = time.time()
+
+            driver = s["driver"]
+            max_polls = SESSION_OTP_TIMEOUT
+            login_success = False
+
+            print(f"[UnitedDH Claim OTP] Waiting for user to enter OTP (polling browser for {SESSION_OTP_TIMEOUT}s)...")
+
+            for poll in range(max_polls):
+                await asyncio.sleep(1)
+                s["last_activity"] = time.time()
+
+                try:
+                    # Check if OTP was submitted via API (from app)
+                    otp_value = s.get("otp_value")
+                    if otp_value:
+                        print(f"[UnitedDH Claim OTP] OTP received from app: {otp_value}")
+                        try:
+                            otp_input = driver.find_element(By.XPATH,
+                                "//input[contains(@name,'otp') or contains(@name,'code') or @type='tel' or contains(@aria-label,'Verification') or contains(@placeholder,'code')]"
+                            )
+                            otp_input.clear()
+                            otp_input.send_keys(otp_value)
+                            try:
+                                verify_btn = driver.find_element(By.XPATH, "//button[@type='button' and @aria-label='Verify']")
+                                verify_btn.click()
+                                print("[UnitedDH Claim OTP] Clicked verify button (aria-label)")
+                            except:
+                                try:
+                                    verify_btn = driver.find_element(By.XPATH, "//button[contains(text(),'Verify') or contains(text(),'Submit') or @type='submit']")
+                                    verify_btn.click()
+                                    print("[UnitedDH Claim OTP] Clicked verify button (text/type)")
+                                except:
+                                    otp_input.send_keys("\n")
+                                    print("[UnitedDH Claim OTP] Pressed Enter as fallback")
+                            print("[UnitedDH Claim OTP] OTP typed and submitted via app")
+                            s["otp_value"] = None
+                            await asyncio.sleep(3)
+                        except Exception as type_err:
+                            print(f"[UnitedDH Claim OTP] Failed to type OTP from app: {type_err}")
+
+                    # Check current URL - if we're on dashboard/member page, login succeeded
+                    current_url = driver.current_url.lower()
+                    print(f"[UnitedDH Claim OTP Poll {poll+1}/{max_polls}] URL: {current_url[:60]}...")
+
+                    if "member" in current_url or "dashboard" in current_url or "eligibility" in current_url or "home" in current_url:
+                        try:
+                            WebDriverWait(driver, 5).until(
+                                EC.presence_of_element_located((By.XPATH,
+                                    '//input[@placeholder="Search by member ID"] | //input[contains(@placeholder,"Search")] | //*[contains(@class,"dashboard")]'
+                                ))
+                            )
+                            print("[UnitedDH Claim OTP] Dashboard/search element found - login successful!")
+                            login_success = True
+                            break
+                        except TimeoutException:
+                            print("[UnitedDH Claim OTP] On member page but search input not found, continuing to poll...")
+
+                    # Also check if OTP input is still visible
+                    try:
+                        driver.find_element(By.XPATH,
+                            "//input[contains(@name,'otp') or contains(@name,'code') or @type='tel' or contains(@aria-label,'Verification') or contains(@placeholder,'code') or contains(@placeholder,'Code')]"
+                        )
+                        print(f"[UnitedDH Claim OTP Poll {poll+1}] OTP input still visible - waiting...")
+                    except:
+                        if "login" in current_url or "app/login" in current_url:
+                            print("[UnitedDH Claim OTP] OTP input gone, trying to navigate to dashboard...")
+                            try:
+                                driver.get("https://app.dentalhub.com/app/dashboard")
+                                await asyncio.sleep(2)
+                            except:
+                                pass
+
+                except Exception as poll_err:
+                    print(f"[UnitedDH Claim OTP Poll {poll+1}] Error: {poll_err}")
+
+            if not login_success:
+                try:
+                    print("[UnitedDH Claim OTP] Final attempt - navigating to dashboard...")
+                    driver.get("https://app.dentalhub.com/app/dashboard")
+                    await asyncio.sleep(3)
+                    WebDriverWait(driver, 10).until(
+                        EC.presence_of_element_located((By.XPATH,
+                            '//input[@placeholder="Search by member ID"] | //input[contains(@placeholder,"Search")] | //*[contains(@class,"dashboard")]'
+                        ))
+                    )
+                    print("[UnitedDH Claim OTP] Dashboard element found - login successful!")
+                    login_success = True
+                except TimeoutException:
+                    s["status"] = "error"
+                    s["message"] = "OTP timeout - login not completed"
+                    await cleanup_session(sid)
+                    return {"status": "error", "message": "OTP not completed in time"}
+                except Exception as final_err:
+                    s["status"] = "error"
+                    s["message"] = f"OTP verification failed: {final_err}"
+                    await cleanup_session(sid)
+                    return {"status": "error", "message": s["message"]}
+
+            if login_success:
+                s["status"] = "running"
+                s["message"] = "Login successful after OTP"
+                print("[UnitedDH Claim OTP] Proceeding to claim steps...")
+
+        # ── Login succeeded without OTP ───────────────────────────────────────
+        elif isinstance(login_result, str) and login_result == "SUCCESS":
+            print("[UnitedDH Claim] Login succeeded without OTP")
+            s["status"] = "running"
+            s["message"] = "Login succeeded"
+
+        # ── Login error ───────────────────────────────────────────────────────
+        elif isinstance(login_result, str) and login_result.startswith("ERROR"):
+            s["status"] = "error"
+            s["message"] = login_result
+            await cleanup_session(sid)
+            return {"status": "error", "message": login_result}
+
+        # --- Claim steps ---
+        for step_name, step_fn in [
+            ("step1_search_patient",   bot.step1_search_patient),
+            ("step2_open_member_page", bot.step2_open_member_page),
+            ("step3_click_create_claim", bot.step3_click_create_claim),
+            ("step4_fill_claim_form",  bot.step4_fill_claim_form),
+            ("step5_attach_files",     bot.step5_attach_files),
+            ("step6_click_next",       bot.step6_click_next),
+            ("step7_submit_claim",     bot.step7_submit_claim),
+        ]:
+            result = step_fn()
+            print(f"[UnitedDH Claim] {step_name} result: {result}")
+            if isinstance(result, str) and result.startswith("ERROR"):
+                s["status"] = "error"
+                s["message"] = result
+                _minimize_browser(bot)
+                asyncio.create_task(_remove_session_later(sid, 30))
+                return {"status": "error", "message": result}
+
+        # --- Step 8: PDF + claim number ---
+        step8_result = bot.step8_save_confirmation_pdf()
+        print(f"[UnitedDH Claim] step8 result: {step8_result}")
+        if isinstance(step8_result, str) and step8_result.startswith("ERROR"):
+            print(f"[UnitedDH Claim] step8 warning (non-fatal): {step8_result}")
+            step8_result = {}
+
+        pdf_path = step8_result.get("pdf_path") if isinstance(step8_result, dict) else None
+        pdf_url = None
+        if pdf_path:
+            import os as _os
+            filename = _os.path.basename(pdf_path)
+            port = _os.getenv("PORT", "5002")
+            url_host = _os.getenv("HOST", "localhost")
+            pdf_url = f"http://{url_host}:{port}/downloads/{filename}"
+            print(f"[UnitedDH Claim] pdf_url: {pdf_url}")
+
+        claim_number = step8_result.get("claimNumber") if isinstance(step8_result, dict) else None
+
+        result = {
+            "status": "success",
+            "message": "United/DentalHub claim submitted successfully",
+            "claimNumber": claim_number,
+            "pdf_url": pdf_url,
+        }
+        s["status"] = "completed"
+        s["result"] = result
+        s["message"] = "completed"
+
+        # Close browser window (session preserved in profile via UnitedSCO browser manager)
+        try:
+            from unitedsco_browser_manager import get_browser_manager as _gbm
+            _gbm().quit_driver()
+            print("[UnitedDH Claim] Browser closed - session preserved in profile")
+        except Exception as close_err:
+            print(f"[UnitedDH Claim] Could not close browser (non-fatal): {close_err}")
+
+        asyncio.create_task(_remove_session_later(sid, 60))
+        return result
+
+    except Exception as e:
+        if s:
+            s["status"] = "error"
+            s["message"] = f"worker exception: {e}"
+        await cleanup_session(sid)
+        return {"status": "error", "message": f"worker exception: {e}"}
+
+
+def submit_otp(sid: str, otp: str) -> Dict[str, Any]:
+    s = sessions.get(sid)
+    if not s:
+        return {"status": "error", "message": "session not found"}
+    if s.get("status") != "waiting_for_otp":
+        return {"status": "error", "message": f"session not waiting for otp (state={s.get('status')})"}
+    s["otp_value"] = otp
+    s["last_activity"] = time.time()
+    try:
+        s["otp_event"].set()
+    except Exception:
+        pass
+    return {"status": "ok", "message": "otp accepted"}
+
+
+def get_session_status(sid: str) -> Dict[str, Any]:
+    s = sessions.get(sid)
+    if not s:
+        return {"status": "not_found"}
+    return {
+        "session_id": sid,
+        "status": s.get("status"),
+        "message": s.get("message"),
+        "created_at": s.get("created_at"),
+        "last_activity": s.get("last_activity"),
+        "result": s.get("result") if s.get("status") in ("completed", "error") else None,
+    }

apps/SeleniumService/unitedsco_browser_manager.py

@@ -43,100 +43,33 @@ class UnitedSCOBrowserManager:
 
     def clear_session_on_startup(self):
         """
-        Clear session cookies from Chrome profile on startup.
-        This forces a fresh login after PC restart.
-        Preserves device trust tokens (LocalStorage, IndexedDB) to avoid OTPs.
+        On startup, only clear the Cookies file so the login session is reset
+        but device trust tokens (Local Storage, IndexedDB) are preserved.
+        Preserving those lets Azure B2C recognise the device and skip OTP.
         """
-        print("[UnitedSCO BrowserManager] Clearing session on startup...")
-        
+        print("[UnitedSCO BrowserManager] Clearing cookies on startup (preserving device trust)...")
+
         try:
-            # Clear the credentials tracking file
+            # Clear credentials tracking so the next login re-saves the hash
             if os.path.exists(self._credentials_file):
                 os.remove(self._credentials_file)
                 print("[UnitedSCO BrowserManager] Cleared credentials tracking file")
-            
-            # Clear session-related files from Chrome profile
-            # These are the files that store login session cookies
-            session_files = [
-                "Cookies",
-                "Cookies-journal",
-                "Login Data",
-                "Login Data-journal",
-                "Web Data",
-                "Web Data-journal",
-            ]
-            
-            for filename in session_files:
-                filepath = os.path.join(self.profile_dir, "Default", filename)
-                if os.path.exists(filepath):
-                    try:
-                        os.remove(filepath)
-                        print(f"[UnitedSCO BrowserManager] Removed {filename}")
-                    except Exception as e:
-                        print(f"[UnitedSCO BrowserManager] Could not remove {filename}: {e}")
-            
-            # Also try root level (some Chrome versions)
-            for filename in session_files:
-                filepath = os.path.join(self.profile_dir, filename)
-                if os.path.exists(filepath):
-                    try:
-                        os.remove(filepath)
-                        print(f"[UnitedSCO BrowserManager] Removed root {filename}")
-                    except Exception as e:
-                        print(f"[UnitedSCO BrowserManager] Could not remove root {filename}: {e}")
-            
-            # Clear Session Storage (contains login state)
-            session_storage_dir = os.path.join(self.profile_dir, "Default", "Session Storage")
-            if os.path.exists(session_storage_dir):
-                try:
-                    shutil.rmtree(session_storage_dir)
-                    print("[UnitedSCO BrowserManager] Cleared Session Storage")
-                except Exception as e:
-                    print(f"[UnitedSCO BrowserManager] Could not clear Session Storage: {e}")
-            
-            # Clear Local Storage (may contain auth tokens)
-            local_storage_dir = os.path.join(self.profile_dir, "Default", "Local Storage")
-            if os.path.exists(local_storage_dir):
-                try:
-                    shutil.rmtree(local_storage_dir)
-                    print("[UnitedSCO BrowserManager] Cleared Local Storage")
-                except Exception as e:
-                    print(f"[UnitedSCO BrowserManager] Could not clear Local Storage: {e}")
-            
-            # Clear IndexedDB (may contain auth tokens)
-            indexeddb_dir = os.path.join(self.profile_dir, "Default", "IndexedDB")
-            if os.path.exists(indexeddb_dir):
-                try:
-                    shutil.rmtree(indexeddb_dir)
-                    print("[UnitedSCO BrowserManager] Cleared IndexedDB")
-                except Exception as e:
-                    print(f"[UnitedSCO BrowserManager] Could not clear IndexedDB: {e}")
-            
-            # Clear browser cache (prevents corrupted cached responses)
-            cache_dirs = [
-                os.path.join(self.profile_dir, "Default", "Cache"),
-                os.path.join(self.profile_dir, "Default", "Code Cache"),
-                os.path.join(self.profile_dir, "Default", "GPUCache"),
-                os.path.join(self.profile_dir, "Default", "Service Worker"),
-                os.path.join(self.profile_dir, "Cache"),
-                os.path.join(self.profile_dir, "Code Cache"),
-                os.path.join(self.profile_dir, "GPUCache"),
-                os.path.join(self.profile_dir, "Service Worker"),
-                os.path.join(self.profile_dir, "ShaderCache"),
-            ]
-            for cache_dir in cache_dirs:
-                if os.path.exists(cache_dir):
-                    try:
-                        shutil.rmtree(cache_dir)
-                        print(f"[UnitedSCO BrowserManager] Cleared {os.path.basename(cache_dir)}")
-                    except Exception as e:
-                        print(f"[UnitedSCO BrowserManager] Could not clear {os.path.basename(cache_dir)}: {e}")
-            
-            # Set flag to clear session via JavaScript after browser opens
-            self._needs_session_clear = True
-            
-            print("[UnitedSCO BrowserManager] Session cleared - will require fresh login")
-            
+
+            # Only remove cookie files — leave everything else intact
+            cookie_files = ["Cookies", "Cookies-journal"]
+            for filename in cookie_files:
+                for base in [os.path.join(self.profile_dir, "Default"), self.profile_dir]:
+                    filepath = os.path.join(base, filename)
+                    if os.path.exists(filepath):
+                        try:
+                            os.remove(filepath)
+                            print(f"[UnitedSCO BrowserManager] Removed {filepath}")
+                        except Exception as e:
+                            print(f"[UnitedSCO BrowserManager] Could not remove {filepath}: {e}")
+
+            self._needs_session_clear = False
+            print("[UnitedSCO BrowserManager] Cookies cleared — device trust tokens preserved")
+
         except Exception as e:
             print(f"[UnitedSCO BrowserManager] Error clearing session: {e}")