feat(ddma-eligibility) - v1

apps/SeleniumService/agent.py

@@ -1,4 +1,4 @@
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, Request, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 import uvicorn
 import asyncio
@@ -7,6 +7,8 @@ from selenium_eligibilityCheckWorker import AutomationMassHealthEligibilityCheck
 from selenium_claimStatusCheckWorker import AutomationMassHealthClaimStatusCheck
 from selenium_preAuthWorker import AutomationMassHealthPreAuth
 import os
+import time
+import helpers_ddma_eligibility as hddma
 
 from dotenv import load_dotenv
 load_dotenv() 
@@ -137,6 +139,79 @@ async def start_workflow(request: Request):
             async with lock:
                 active_jobs -= 1
 
+# Endpoint:5 -  DDMA eligibility (background, OTP)
+
+async def _ddma_worker_wrapper(sid: str, data: dict, url: str):
+    """
+    Background worker that:
+      - acquires semaphore (to keep 1 selenium at a time),
+      - updates active/queued counters,
+      - runs the DDMA flow via helpers.start_ddma_run.
+    """
+    global active_jobs, waiting_jobs
+    async with semaphore:
+        async with lock:
+            waiting_jobs -= 1
+            active_jobs += 1
+        try:
+            await hddma.start_ddma_run(sid, data, url)
+        finally:
+            async with lock:
+                active_jobs -= 1
+
+
+@app.post("/ddma-eligibility")
+async def ddma_eligibility(request: Request):
+    """
+    Starts a DDMA eligibility session in the background.
+    Body: { "data": { ... }, "url"?: string }
+    Returns: { status: "started", session_id: "<uuid>" }
+    """
+    global waiting_jobs
+
+    body = await request.json()
+    data = body.get("data", {})
+
+    # create session
+    sid = hddma.make_session_entry()
+    hddma.sessions[sid]["type"] = "ddma_eligibility"
+    hddma.sessions[sid]["last_activity"] = time.time()
+
+    async with lock:
+        waiting_jobs += 1
+
+    # run in background (queued under semaphore)
+    asyncio.create_task(_ddma_worker_wrapper(sid, data, url="https://providers.deltadentalma.com/onboarding/start/"))
+
+    return {"status": "started", "session_id": sid}
+
+
+@app.post("/submit-otp")
+async def submit_otp(request: Request):
+    """
+    Body: { "session_id": "<sid>", "otp": "123456" }
+    Node / frontend call this when user provides OTP.
+    """
+    body = await request.json()
+    sid = body.get("session_id")
+    otp = body.get("otp")
+    if not sid or not otp:
+        raise HTTPException(status_code=400, detail="session_id and otp required")
+
+    res = hddma.submit_otp(sid, otp)
+    if res.get("status") == "error":
+        raise HTTPException(status_code=400, detail=res.get("message"))
+    return res
+
+
+@app.get("/session/{sid}/status")
+async def session_status(sid: str):
+    s = hddma.get_session_status(sid)
+    if s.get("status") == "not_found":
+        raise HTTPException(status_code=404, detail="session not found")
+    return s
+
+
 # ✅ Status Endpoint
 @app.get("/status")
 async def get_status():

apps/SeleniumService/helpers_ddma_eligibility.py

@@ -0,0 +1,212 @@
+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_DDMA_eligibilityCheckWorker import AutomationDeltaDentalMAEligibilityCheck
+
+# In-memory session store
+sessions: Dict[str, Dict[str, Any]] = {}
+
+SESSION_OTP_TIMEOUT = int(os.getenv("SESSION_OTP_TIMEOUT", "120"))  # seconds
+
+
+def make_session_entry() -> str:
+    """Create a new session entry and return its ID."""
+    import uuid
+    sid = str(uuid.uuid4())
+    sessions[sid] = {
+        "status": "created",     # created -> running -> waiting_for_otp -> otp_submitted -> completed / error
+        "created_at": time.time(),
+        "last_activity": time.time(),
+        "bot": None,             # worker instance
+        "driver": None,          # selenium webdriver
+        "otp_event": asyncio.Event(),
+        "otp_value": None,
+        "result": None,
+        "message": None,
+        "type": None,
+    }
+    return sid
+
+
+async def cleanup_session(sid: str):
+    """Close driver (if any) and remove session entry."""
+    s = sessions.get(sid)
+    if not s:
+        return
+    try:
+        driver = s.get("driver")
+        if driver:
+            try:
+                driver.quit()
+            except Exception:
+                pass
+    finally:
+        sessions.pop(sid, None)
+        print(f"[helpers] cleaned session {sid}")
+
+
+async def _remove_session_later(sid: str, delay: int = 20):
+    await asyncio.sleep(delay)
+    await cleanup_session(sid)
+
+
+async def start_ddma_run(sid: str, data: dict, url: str):
+    """
+    Run the DDMA workflow for a session (WITHOUT managing semaphore/counters).
+    Called by agent.py inside a wrapper that handles queue/counters.
+    """
+    s = sessions.get(sid)
+    if not s:
+        return {"status": "error", "message": "session not found"}
+
+    s["status"] = "running"
+    s["last_activity"] = time.time()
+
+    try:
+        bot = AutomationDeltaDentalMAEligibilityCheck({"data": data})
+        bot.config_driver()
+
+        s["bot"] = bot
+        s["driver"] = bot.driver
+        s["last_activity"] = time.time()
+
+        # Navigate to login URL
+        try:
+            if not url:
+                raise ValueError("URL not provided for DDMA run")
+            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
+        login_result = bot.login()
+
+        # OTP required path
+        if isinstance(login_result, str) and login_result == "OTP_REQUIRED":
+            s["status"] = "waiting_for_otp"
+            s["message"] = "OTP required for login"
+            s["last_activity"] = time.time()
+
+            try:
+                await asyncio.wait_for(s["otp_event"].wait(), timeout=SESSION_OTP_TIMEOUT)
+            except asyncio.TimeoutError:
+                s["status"] = "error"
+                s["message"] = "OTP timeout"
+                await cleanup_session(sid)
+                return {"status": "error", "message": "OTP not provided in time"}
+
+            otp_value = s.get("otp_value")
+            if not otp_value:
+                s["status"] = "error"
+                s["message"] = "OTP missing after event"
+                await cleanup_session(sid)
+                return {"status": "error", "message": "OTP missing after event"}
+
+            # Submit OTP in the same Selenium window
+            try:
+                driver = s["driver"]
+                wait = WebDriverWait(driver, 30)
+
+                otp_input = wait.until(
+                    EC.presence_of_element_located(
+                        (By.XPATH, "//input[contains(@aria-lable,'Verification code') or contains(@placeholder,'Enter your verification code')]")
+                    )
+                )
+                otp_input.clear()
+                otp_input.send_keys(otp_value)
+
+                try:
+                    submit_btn = wait.until(
+                        EC.element_to_be_clickable(
+                            (By.XPATH, "//button[@type='button' and @aria-label='Verify']")
+                        )
+                    )
+                    submit_btn.click()
+                except Exception:
+                    otp_input.send_keys("\n")
+
+                s["status"] = "otp_submitted"
+                s["last_activity"] = time.time()
+                await asyncio.sleep(0.5)
+            except Exception as e:
+                s["status"] = "error"
+                s["message"] = f"Failed to submit OTP into page: {e}"
+                await cleanup_session(sid)
+                return {"status": "error", "message": s["message"]}
+
+        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}
+
+        # Step 1
+        step1_result = bot.step1()
+        if isinstance(step1_result, str) and step1_result.startswith("ERROR"):
+            s["status"] = "error"
+            s["message"] = step1_result
+            await cleanup_session(sid)
+            return {"status": "error", "message": step1_result}
+
+        # Step 2 (PDF)
+        step2_result = bot.step2()
+        if isinstance(step2_result, dict) and step2_result.get("status") == "success":
+            s["status"] = "completed"
+            s["result"] = step2_result
+            s["message"] = "completed"
+            asyncio.create_task(_remove_session_later(sid, 30))
+            return step2_result
+        else:
+            s["status"] = "error"
+            if isinstance(step2_result, dict):
+                s["message"] = step2_result.get("message", "unknown error")
+            else:
+                s["message"] = str(step2_result)
+            await cleanup_session(sid)
+            return {"status": "error", "message": s["message"]}
+
+    except Exception as e:
+        s["status"] = "error"
+        s["message"] = f"worker exception: {e}"
+        await cleanup_session(sid)
+        return {"status": "error", "message": s["message"]}
+
+
+def submit_otp(sid: str, otp: str) -> Dict[str, Any]:
+    """Set OTP for a session and wake waiting runner."""
+    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") == "completed" else None,
+    }

apps/SeleniumService/selenium_DDMA_eligibilityCheckWorker.py

@@ -0,0 +1,272 @@
+from selenium import webdriver
+from selenium.common import TimeoutException
+from selenium.webdriver.chrome.service import Service
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from webdriver_manager.chrome import ChromeDriverManager
+import time
+import os
+import shutil
+import stat
+
+class AutomationDeltaDentalMAEligibilityCheck:    
+    def __init__(self, data):
+        self.headless = False
+        self.driver = None
+
+        self.data = data.get("data", {}) if isinstance(data, dict) else {}
+
+
+        # Flatten values for convenience
+        self.memberId = self.data.get("memberId", "")
+        self.dateOfBirth = self.data.get("dateOfBirth", "")
+        self.massddma_username = self.data.get("massddmaUsername", "")
+        self.massddma_password = self.data.get("massddmaPassword", "")
+
+        self.download_dir = os.path.abspath("seleniumDownloads")
+        os.makedirs(self.download_dir, exist_ok=True)
+    
+
+    def config_driver(self):
+        options = webdriver.ChromeOptions()
+        if self.headless:
+            options.add_argument("--headless")
+
+        # Add PDF download preferences
+        prefs = {
+            "download.default_directory": self.download_dir,
+            "plugins.always_open_pdf_externally": True,
+            "download.prompt_for_download": False,
+            "download.directory_upgrade": True
+        }
+        options.add_experimental_option("prefs", prefs)
+
+        s = Service(ChromeDriverManager().install())
+        driver = webdriver.Chrome(service=s, options=options)
+        self.driver = driver
+
+    def login(self):
+        """
+        Attempts login and detects OTP.
+        Returns:
+          - "Success" -> logged in
+          - "OTP_REQUIRED" -> page requires OTP (we do NOT block here)
+          - "ERROR:..." -> error occurred
+        """
+        wait = WebDriverWait(self.driver, 30)
+        try:
+            email_field = wait.until(EC.presence_of_element_located((By.XPATH, "//input[@name='username' and @type='text']")))
+            email_field.clear()
+            email_field.send_keys(self.massddma_username)
+
+            password_field = wait.until(EC.presence_of_element_located((By.XPATH, "//input[@name='password' and @type='password']")))
+            password_field.clear()
+            password_field.send_keys(self.massddma_password)
+            
+             # Click Remember me checkbox
+            remember_me_checkbox = wait.until(EC.element_to_be_clickable(
+                (By.XPATH, "//label[.//span[contains(text(),'Remember me')]]")
+            ))
+            remember_me_checkbox.click()
+            
+            login_button = wait.until(EC.element_to_be_clickable((By.XPATH, "//button[@type='button' and @aria-label='Sign in']")))
+            login_button.click()
+
+
+            # 1) Detect OTP presence (adjust the XPath/attributes to the actual site)
+            try:
+                otp_candidate = WebDriverWait(self.driver, 30).until(
+                    EC.presence_of_element_located(
+                        (By.XPATH, "//input[contains(@aria-lable,'Verification code') or contains(@placeholder,'Enter your verification code')]")
+                    )
+                )
+                if otp_candidate:
+                    print("[DDMA worker] OTP input detected -> OTP_REQUIRED")
+                    return "OTP_REQUIRED"
+            except TimeoutException:
+                pass
+
+            # 2) Detect successful login by presence of a known post-login element
+            try:
+                logged_in_el = WebDriverWait(self.driver, 5).until(
+                    EC.presence_of_element_located((By.XPATH, "//a[text()='Member Eligibility' or contains(., 'Member Eligibility')]"))
+                )
+                if logged_in_el:
+                    return "Success"
+            except TimeoutException:
+                # last chance: see if URL changed
+                if "dashboard" in self.driver.current_url or "providers" in self.driver.current_url:
+                    return "Success"
+
+            return "ERROR:LOGIN FAILED - unable to detect success or OTP"
+        except Exception as e:
+            print(f"[DDMA worker] login exception: {e}")
+            return f"ERROR:LOGIN FAILED: {e}"
+
+    def step1(self):
+        wait = WebDriverWait(self.driver, 30)
+
+        try:
+            eligibility_link = wait.until(
+            EC.element_to_be_clickable((By.XPATH, "//a[text()='Member Eligibility']"))
+            )
+            eligibility_link.click()
+
+            time.sleep(3)
+
+            # Fill Member ID
+            member_id_input = wait.until(EC.presence_of_element_located((By.XPATH, '//*[@id="Text1"]')))
+            member_id_input.clear()
+            member_id_input.send_keys(self.memberId)
+
+            # Fill DOB parts
+            try:
+                dob_parts = self.dateOfBirth.split("-")
+                year = dob_parts[0]           # "1964"
+                month = dob_parts[1].zfill(2) # "04"
+                day = dob_parts[2].zfill(2)   # "17"
+            except Exception as e:
+                print(f"Error parsing DOB: {e}")
+                return "ERROR: PARSING DOB"
+
+            wait.until(EC.presence_of_element_located((By.XPATH, '//*[@id="Text2"]'))).send_keys(month)
+            wait.until(EC.presence_of_element_located((By.XPATH, '//*[@id="Text3"]'))).send_keys(day)
+            wait.until(EC.presence_of_element_located((By.XPATH, '//*[@id="Text4"]'))).send_keys(year)
+
+            # Click Continue button
+            continue_btn = wait.until(EC.element_to_be_clickable((By.XPATH, '//input[@type="submit" and @value="Add Member"]')))
+            continue_btn.click()
+            
+            # Check for error message
+            try:
+                error_msg = WebDriverWait(self.driver, 5).until(EC.presence_of_element_located(
+                    (By.XPATH, "//td[@class='text_err_msg' and contains(text(), 'Invalid Medicaid ID or Date of Birth')]")
+                ))
+                if error_msg:
+                    print("Error: Invalid Member ID or Date of Birth.")
+                    return  "ERROR: INVALID MEMBERID OR DOB"
+            except TimeoutException:
+                pass
+
+            return "Success"
+
+        except Exception as e: 
+            print(f"Error while step1 i.e Cheking the MemberId and DOB in: {e}")
+            return "ERROR:STEP1"
+
+    
+    def step2(self):
+        def wait_for_pdf_download(timeout=60):
+            for _ in range(timeout):
+                files = [f for f in os.listdir(self.download_dir) if f.endswith(".pdf")]
+                if files:
+                    return os.path.join(self.download_dir, files[0])
+                time.sleep(1)
+            raise TimeoutError("PDF did not download in time")
+
+        def _unique_target_path():
+            """
+            Create a unique filename using memberId.
+            """
+            safe_member = "".join(c for c in str(self.memberId) if c.isalnum() or c in "-_.")
+            filename = f"eligibility_{safe_member}.pdf"
+            return os.path.join(self.download_dir, filename)
+
+        wait = WebDriverWait(self.driver, 90)
+        tmp_created_path = None
+
+        try:
+
+            eligibilityElement = wait.until(EC.presence_of_element_located((By.XPATH, 
+            f"//table[@id='Table3']//tr[td[contains(text(), '{self.memberId}')]]/td[3]")))
+            eligibilityText = eligibilityElement.text
+
+            txReportElement = wait.until(EC.element_to_be_clickable((By.XPATH,
+            f"//table[@id='Table3']//tr[td[contains(text(), '{self.memberId}')]]//input[@value='Tx Report']"
+            )))
+
+            txReportElement.click()
+
+            # wait for the PDF to fully appear
+            downloaded_path = wait_for_pdf_download()
+            # generate unique target path (include memberId)
+            target_path = _unique_target_path()
+            # It's possible Chrome writes a file with a fixed name: copy/rename it to our target name.
+            shutil.copyfile(downloaded_path, target_path)
+            # ensure the copied file is writable / stable
+            os.chmod(target_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH)
+
+
+            print("PDF downloaded at:", target_path)
+
+            return {
+                "status": "success",
+                "eligibility": eligibilityText,
+                "pdf_path": target_path
+            }
+        except Exception as e:
+            print(f"ERROR: {str(e)}")
+
+            # Empty the download folder (remove files / symlinks only)
+            try:
+                dl = os.path.abspath(self.download_dir)
+                if os.path.isdir(dl):
+                    for name in os.listdir(dl):
+                        item = os.path.join(dl, name)
+                        try:
+                            if os.path.isfile(item) or os.path.islink(item):
+                                os.remove(item)
+                                print(f"[cleanup] removed: {item}")
+                        except Exception as rm_err:
+                            print(f"[cleanup] failed to remove {item}: {rm_err}")
+                    print(f"[cleanup] emptied download dir: {dl}")
+                else:
+                    print(f"[cleanup] download dir does not exist: {dl}")
+            except Exception as cleanup_exc:
+                print(f"[cleanup] unexpected error while cleaning downloads dir: {cleanup_exc}")
+
+
+            return {
+                "status": "error",
+                "message": str(e),
+            }
+
+        finally:
+            if self.driver:
+                self.driver.quit()
+
+    def main_workflow(self, url):
+        try: 
+            self.config_driver()
+            self.driver.maximize_window()
+            self.driver.get(url)
+            time.sleep(3)
+
+            login_result = self.login()
+            if login_result.startswith("ERROR"):
+                return {"status": "error", "message": login_result}
+            if login_result == "OTP_REQUIRED":
+                return {"status": "otp_required", "message": "OTP required after login"}
+
+            step1_result = self.step1()
+            if step1_result.startswith("ERROR"):
+                return {"status": "error", "message": step1_result}
+
+            step2_result = self.step2()
+            if step2_result.get("status") == "error":
+                return {"status": "error", "message": step2_result.get("message")}
+
+            return step2_result
+        except Exception as e: 
+            return {
+                "status": "error",
+                "message": e
+            }
+        
+        finally:
+            try:
+                if self.driver:
+                    self.driver.quit()
+            except Exception:
+                pass