feat: add CCA claim submission with Selenium automation

- Add CCA claim submit Selenium worker (login, fill form, attach docs, submit, capture dashboard PDF)
- Add CCA fee schedule (procedureCodesMH.json renamed, procedureCodesCCA.json added with D6010)
- Add backend route /api/claims/cca-claim, processor, and Selenium client
- Wire CCA claim handler in claims-page with job tracking and PDF preview popup
- Add insurance type dropdown in claim form (same options as eligibility page)
- Auto-populate insurance type from patient.insuranceProvider in claim form and patient edit form
- Map fee schedule by insurance type in Map Price button and combo buttons
- Fix CCA login speed (remove fixed sleeps, use readyState check)
- Fix CCA claim DOB format bug (was sending MM-DD-YYYY, now sends YYYY-MM-DD)
- Fix npiProviderId not saved for CCA claims
- Change Add Service → CCA Claim button (blue), MH → MH Claim

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

apps/Backend/src/queue/jobRunner.ts

@@ -16,6 +16,7 @@ import { runDeltaInsEligibilityProcessor } from "./processors/deltaInsEligibilit
 import { runUnitedSCOEligibilityProcessor } from "./processors/unitedSCOEligibilityProcessor";
 import { runDentaQuestEligibilityProcessor } from "./processors/dentaQuestEligibilityProcessor";
 import { runCCAEligibilityProcessor } from "./processors/ccaEligibilityProcessor";
+import { runCCAClaimProcessor } from "./processors/ccaClaimProcessor";
 import { runEligibilityHistoryProcessor } from "./processors/eligibilityHistoryProcessor";
 import { runCmspEligibilityHistoryRemainingProcessor } from "./processors/cmspEligibilityHistoryRemainingProcessor";
 import type { SeleniumJobData, OcrJobData } from "./queues";
@@ -132,6 +133,17 @@ export function enqueueSeleniumJob(data: SeleniumJobData): string {
         job.id
       );
     }
+    if (jobType === "cca-claim-submit") {
+      return runCCAClaimProcessor(
+        {
+          enrichedPayload: data.enrichedPayload,
+          userId: data.userId,
+          claimId: data.claimId,
+          socketId: data.socketId,
+        },
+        job.id
+      );
+    }
     if (jobType === "cca-eligibility-check") {
       return runCCAEligibilityProcessor(
         {

apps/Backend/src/queue/processors/ccaClaimProcessor.ts

@@ -0,0 +1,153 @@
+/**
+ * Processor for "cca-claim-submit" jobs.
+ * Submits a dental claim to CCA via the ScionDental portal.
+ *
+ * Flow:
+ *   1. POST /cca-claim to Python agent → get session_id
+ *   2. Emit selenium:cca_claim_started to frontend
+ *   3. Poll until completed/error
+ *   4. Emit result and update claim status in DB
+ */
+import { storage } from "../../storage";
+import {
+  forwardToSeleniumCCAClaimAgent,
+  getSeleniumCCAClaimSessionStatus,
+} from "../../services/seleniumCCAClaimClient";
+import { io } from "../../socket";
+
+function log(tag: string, msg: string, ctx?: any) {
+  console.log(`${new Date().toISOString()} [${tag}] ${msg}`, ctx ?? "");
+}
+
+function emitToSocket(socketId: string | undefined, event: string, payload: any) {
+  if (!socketId || !io) return;
+  try {
+    const socket = io.sockets.sockets.get(socketId);
+    if (socket) socket.emit(event, payload);
+  } catch (_) {}
+}
+
+async function pollUntilDone(
+  sessionId: string,
+  pollTimeoutMs = 10 * 60 * 1000
+): Promise<any> {
+  const maxAttempts = 1200;
+  const pollIntervalMs = 500;
+  const maxTransientErrors = 12;
+  let transientErrors = 0;
+  const deadline = Date.now() + pollTimeoutMs;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (Date.now() > deadline) {
+      throw new Error(`CCA claim polling timeout for session ${sessionId}`);
+    }
+    try {
+      const st = await getSeleniumCCAClaimSessionStatus(sessionId);
+      const status: string = st?.status ?? "unknown";
+      log("cca-claim-processor", `poll attempt=${attempt}`, { sessionId, status });
+      transientErrors = 0;
+
+      if (status === "completed") return st.result;
+      if (status === "error" || status === "not_found") {
+        throw new Error(st?.message || `CCA claim session ended with status: ${status}`);
+      }
+      await new Promise((r) => setTimeout(r, pollIntervalMs));
+    } catch (err: any) {
+      const isTerminal =
+        err?.response?.status === 404 ||
+        (typeof err?.message === "string" &&
+          (err.message.includes("not_found") || err.message.includes("polling timeout")));
+      if (isTerminal) throw err;
+      transientErrors++;
+      if (transientErrors > maxTransientErrors) {
+        throw new Error(`Too many transient errors polling CCA claim session ${sessionId}`);
+      }
+      const backoff = Math.min(30_000, 500 * Math.pow(2, transientErrors - 1));
+      await new Promise((r) => setTimeout(r, backoff));
+    }
+  }
+  throw new Error(`CCA claim polling exhausted all attempts for session ${sessionId}`);
+}
+
+export interface CCAClaimProcessorInput {
+  enrichedPayload: any;
+  userId: number;
+  claimId?: number;
+  socketId?: string;
+}
+
+export async function runCCAClaimProcessor(
+  input: CCAClaimProcessorInput,
+  jobId: string
+): Promise<{ status: string; claimNumber?: string | null; pdfFileId?: number | null }> {
+  const { enrichedPayload, userId, claimId, socketId } = input;
+
+  log("cca-claim-processor", "starting Python agent session", { claimId });
+  const agentResp = await forwardToSeleniumCCAClaimAgent(enrichedPayload);
+
+  if (!agentResp?.session_id) {
+    throw new Error("Python agent did not return a session_id for CCA claim");
+  }
+
+  const sessionId = agentResp.session_id as string;
+  log("cca-claim-processor", "got session_id", { sessionId });
+
+  emitToSocket(socketId, "selenium:cca_claim_started", { session_id: sessionId, jobId });
+
+  const seleniumResult = await pollUntilDone(sessionId);
+
+  if (!seleniumResult || seleniumResult.status === "error") {
+    throw new Error(seleniumResult?.message ?? "CCA claim session returned an error");
+  }
+
+  const claimNumber: string | null = seleniumResult?.claimNumber ?? null;
+  const pdfBase64: string = seleniumResult?.pdfBase64 ?? "";
+  const pdfFilename: string =
+    seleniumResult?.pdfFilename || `cca_claim_${claimId ?? "unknown"}_${Date.now()}.pdf`;
+
+  // Save PDF to patient's Claims document group
+  let pdfFileId: number | null = null;
+  if (pdfBase64 && enrichedPayload?.claim?.patientId) {
+    try {
+      const patientId = Number(enrichedPayload.claim.patientId);
+      const pdfBuffer = Buffer.from(pdfBase64, "base64");
+      let group = await storage.findPdfGroupByPatientTitleKey(patientId, "INSURANCE_CLAIM");
+      if (!group) {
+        group = await storage.createPdfGroup(patientId, "Claims", "INSURANCE_CLAIM");
+      }
+      const created = await storage.createPdfFile(group.id!, pdfFilename, pdfBuffer);
+      if (created && typeof created === "object" && "id" in created) {
+        pdfFileId = Number((created as any).id);
+      }
+      log("cca-claim-processor", "PDF saved", { pdfFilename, pdfFileId, patientId });
+    } catch (e: any) {
+      log("cca-claim-processor", "failed to save PDF", { error: e?.message });
+    }
+  }
+
+  // Update claim: status → REVIEW, persist claimNumber
+  if (claimId) {
+    try {
+      const updates: Record<string, any> = { status: "REVIEW" };
+      if (claimNumber) updates.claimNumber = claimNumber;
+      await storage.updateClaim(claimId, updates);
+      log("cca-claim-processor", "claim updated", { claimId, claimNumber, status: "REVIEW" });
+    } catch (e: any) {
+      log("cca-claim-processor", "failed to update claim", { error: e?.message });
+    }
+  }
+
+  emitToSocket(socketId, "selenium:cca_claim_completed", {
+    jobId,
+    claimId,
+    claimNumber,
+    pdfFileId,
+    pdfFilename,
+    message: claimNumber
+      ? `CCA claim submitted — claim number: ${claimNumber}`
+      : "CCA claim submitted successfully",
+  });
+
+  log("cca-claim-processor", "done", { claimId, claimNumber });
+  return { status: "success", claimNumber, pdfFileId };
+}

apps/Backend/src/queue/queues.ts

@@ -11,6 +11,8 @@ export type SeleniumJobType =
   | "deltains-eligibility-check"
   | "unitedsco-eligibility-check"
   | "cca-eligibility-check"
+  | "cca-claim-submit"
+  | "tuftssco-eligibility-check"
   | "mh-eligibility-history-check"
   | "cmsp-eligibility-history-remaining-check";
 

apps/Backend/src/routes/index.ts

@@ -16,6 +16,7 @@ import insuranceStatusDeltaInsRoutes from "./insuranceStatusDeltaIns";
 import insuranceStatusUnitedSCORoutes from "./insuranceStatusUnitedSCO";
 import insuranceStatusTuftsSCORoutes from "./insuranceStatusTuftsSCO";
 import insuranceStatusCCARoutes from "./insuranceStatusCCA";
+import insuranceStatusCCAClaimRoutes from "./insuranceStatusCCAClaim";
 import paymentsRoutes from "./payments";
 import databaseManagementRoutes from "./database-management";
 import notificationsRoutes from "./notifications";
@@ -53,6 +54,7 @@ router.use("/insurance-status-deltains", insuranceStatusDeltaInsRoutes);
 router.use("/insurance-status-unitedsco", insuranceStatusUnitedSCORoutes);
 router.use("/insurance-status-tuftssco", insuranceStatusTuftsSCORoutes);
 router.use("/insurance-status-cca", insuranceStatusCCARoutes);
+router.use("/claims", insuranceStatusCCAClaimRoutes);
 router.use("/payments", paymentsRoutes);
 router.use("/database-management", databaseManagementRoutes);
 router.use("/notifications", notificationsRoutes);

apps/Backend/src/routes/insuranceStatusCCAClaim.ts

@@ -0,0 +1,95 @@
+import { Router, Request, Response } from "express";
+import { storage } from "../storage";
+import { enqueueSeleniumJob } from "../queue/jobRunner";
+import multer from "multer";
+
+const router = Router();
+const upload = multer({ storage: multer.memoryStorage() });
+
+/**
+ * POST /cca-claim
+ *
+ * Enqueues a CCA claim submission job.
+ * Accepts multipart/form-data with optional pdfs/images attachments.
+ *
+ * Body fields:
+ *   data     — JSON string with claim payload (memberId, dateOfBirth, serviceDate,
+ *              serviceLines, patientName, etc.)
+ *   socketId — socket.io client id
+ *   claimId  — existing claim DB id (optional)
+ *
+ * Response: { status: "queued", jobId: "…" }
+ */
+router.post(
+  "/cca-claim",
+  upload.fields([
+    { name: "pdfs", maxCount: 10 },
+    { name: "images", maxCount: 10 },
+  ]),
+  async (req: Request, res: Response): Promise<any> => {
+    if (!req.user?.id) {
+      return res.status(401).json({ error: "Unauthorized: user info missing" });
+    }
+
+    try {
+      const claimData =
+        typeof req.body.data === "string"
+          ? JSON.parse(req.body.data)
+          : req.body.data ?? {};
+
+      const pdfs =
+        (req.files as Record<string, Express.Multer.File[]>)?.pdfs ?? [];
+      const images =
+        (req.files as Record<string, Express.Multer.File[]>)?.images ?? [];
+
+      // Fetch CCA credentials
+      const credentials = await storage.getInsuranceCredentialByUserAndSiteKey(
+        req.user.id,
+        "CCA"
+      );
+      if (!credentials) {
+        return res.status(404).json({
+          error:
+            "No CCA credentials found. Please add them on the Settings page.",
+        });
+      }
+
+      const filesForQueue = [...pdfs, ...images].map((f) => ({
+        originalname: f.originalname,
+        bufferBase64: f.buffer.toString("base64"),
+        mimetype: f.mimetype,
+      }));
+
+      const enrichedPayload = {
+        claim: {
+          ...claimData,
+          cca_username: credentials.username,
+          cca_password: credentials.password,
+        },
+        files: filesForQueue,
+      };
+
+      const socketId: string | undefined = req.body.socketId;
+      const claimId: number | undefined = claimData.claimId
+        ? Number(claimData.claimId)
+        : undefined;
+
+      const jobId = enqueueSeleniumJob({
+        jobType: "cca-claim-submit",
+        userId: req.user.id,
+        socketId,
+        enrichedPayload,
+        claimId,
+      });
+
+      return res.json({ status: "queued", jobId });
+    } catch (err: any) {
+      console.error("[cca-claim route] error:", err);
+      return res.status(500).json({
+        error: err.message || "Failed to enqueue CCA claim job",
+      });
+    }
+  }
+);
+
+export default router;

apps/Backend/src/services/seleniumCCAClaimClient.ts

@@ -0,0 +1,24 @@
+import axios from "axios";
+
+const SELENIUM_BASE = process.env.SELENIUM_SERVICE_URL ?? "http://localhost:5002";
+
+/**
+ * POST /cca-claim
+ * Returns { status: "started", session_id: "<uuid>" }
+ */
+export async function forwardToSeleniumCCAClaimAgent(
+  data: Record<string, any>
+): Promise<{ status: string; session_id: string }> {
+  const resp = await axios.post(`${SELENIUM_BASE}/cca-claim`, data);
+  return resp.data;
+}
+
+/**
+ * GET /session/{sid}/status
+ */
+export async function getSeleniumCCAClaimSessionStatus(
+  sessionId: string
+): Promise<Record<string, any>> {
+  const resp = await axios.get(`${SELENIUM_BASE}/session/${sessionId}/status`);
+  return resp.data;
+}