Plan: Worker Portal Redesign — Stage 5 MR4: Case Detail Composition

# rulesets/georgia/composition/case_detail.toml
# TOML keys match Rust field names: shell_per_role ↔
# RawComposition.shell_per_role.

[shell_per_role.eligibility_worker]
strategy = "tabs"

[shell_per_role.supervisor]
strategy = "scroll"

[shell_per_role.analyst]
strategy = "card_grid"

[shell_per_role.jurisdiction_admin]
strategy = "tabs"

[[sections]]
item = "case-detail-household-section"
row = 0
span = 12

# ... 19 more (full TOML in D6 below)

// crates/canopy-composition/src/types.rs

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct RawComposition {
    /// Dashboard / SignIn shells use this scalar form. CaseDetail
    /// IGNORES this field — see `shell_per_role`.
    #[serde(default)]
    pub shell: String,

    /// CaseDetail-only per-role shell strategy table. Map from
    /// `role_slug` to `RoleShellEntry`. Loader picks the entry
    /// matching the request role.
    #[serde(default)]
    pub shell_per_role: HashMap<String, RoleShellEntry>,

    /// Dashboard surfaces use `items`. CaseDetail uses `sections`.
    /// Both deserialize via `Vec<ComposedItem>`; loader picks the
    /// right one per surface.
    #[serde(default)]
    pub items: Vec<ComposedItem>,

    #[serde(default)]
    pub sections: Vec<ComposedItem>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RoleShellEntry {
    /// `"tabs"` | `"scroll"` | `"card_grid"`.
    pub strategy: String,
}

ComposableSurface::CaseDetail => {
    let entry = raw.shell_per_role.get(&role.0).ok_or_else(|| {
        CompositionLoadError::ShellNotConfiguredForRole {
            role: role.0.clone(),
        }
    })?;
    ShellSpec::CaseDetail {
        shell: parse_case_detail_shell(&entry.strategy),
    }
}

{
  "shell_per_role": {
    "eligibility_worker": { "strategy": "tabs" },
    "supervisor":         { "strategy": "tabs" },
    "analyst":            { "strategy": "tabs" },
    "jurisdiction_admin": { "strategy": "tabs" }
  },
  "sections": []
}

pub struct RenderedSection {
    pub slug: String,         // "case-detail-notices-section"
    pub short_slug: String,   // "notices"
    pub display_name: String, // "Notices"
    pub span: u8,
    pub row: u8,
    pub has_badge: bool,
    pub badge_label: String,  // e.g. "4", empty when has_badge=false
    pub flag_kind: String,    // "neutral" | "error" | "warning"
    pub html: String,
}

pub async fn get_case_detail(
    AuthenticatedWorker(session): AuthenticatedWorker,
    Extension(theme): Extension<Arc<ThemeConfig>>,
    Extension(clients): Extension<Arc<ServiceClients>>,
    Extension(svc_token): Extension<canopy_auth::ServiceTokenSource>,
    Extension(db): Extension<DbPool>,
    Extension(comp): Extension<Arc<CompositionState>>,
    Extension(web_config): Extension<Arc<WebConfig>>,
    Path(household_id): Path<String>,
    Query(query): Query<CaseDetailQuery>,
) -> Result<Html<String>, StatusCode> {
    let surface = ComposableSurface::CaseDetail;
    let juris = JurisdictionSlug(web_config.jurisdiction.clone());
    let idp = comp.composition_loader.idp_for(&juris).await.map_err(|e| {
        tracing::error!(error = %e, "case_detail idp_for failed");
        StatusCode::INTERNAL_SERVER_ERROR
    })?;
    let role = role_slug_for_worker(&session.role);
    let user_id = crate::api::dashboard::parse_user_id(&session.worker_id);

    let composed = comp
        .composition_loader
        .load_composition(db.inner(), &juris, &role, user_id.as_ref(), surface, &idp)
        .await
        .map_err(|e| {
            tracing::error!(error = %e, "case_detail load_composition failed");
            StatusCode::INTERNAL_SERVER_ERROR
        })?;

    // MR4a compat shim: empty composition → legacy Program::tabs() rendering.
    if composed.items.is_empty() {
        return legacy_render_tabs_dispatch(/* … */).await;
    }

    // Resolve active program — explicit query param wins; otherwise primary.
    let active_program: Program = query
        .program
        .as_deref()
        .and_then(Program::parse_slug)
        .unwrap_or_else(|| pick_primary_program_blocking(&household_id, &clients));

    // Fan out section fetches in parallel. dispatch_fetch applies the
    // section_applies_to_program filter (D7).
    let fetches = composed.items.iter().map(|item| {
        sections::dispatch_fetch(
            item,
            active_program,
            comp.composition_loader.plugins(),
            &clients,
            &household_id,
            &session,
        )
    });
    let sections_vec: Vec<RenderedSection> = futures::future::join_all(fetches).await;

    // Render hero to String (pre-rendered embed pattern).
    let hero = build_case_identity_hero(&clients, &household_id, active_program, &session).await;
    let identity_hero_html = hero.render().map_err(|e| {
        tracing::error!(error = %e, "case identity hero render failed");
        StatusCode::INTERNAL_SERVER_ERROR
    })?;

    let case_number = presentational_case_number(&household_id);

    // target_section allowlist guard — prevent attacker-controlled values
    // flowing into Location header / init_json.
    let allowed_focus: std::collections::HashSet<&str> =
        sections_vec.iter().map(|s| s.short_slug.as_str()).collect();
    let active_section: String = query
        .focus_section
        .as_deref()
        .filter(|s| allowed_focus.contains(s))
        .unwrap_or("determination")
        .to_string();
    let active_section_html = pick_active_section_html(&sections_vec, &active_section);
    let init_json = serde_json::to_string(&serde_json::json!({
        "focus_section": active_section.clone(),
        "household_id": household_id,
    }))
    .expect("init_json serialize");

    let shell_strategy = match &composed.shell {
        ShellSpec::CaseDetail { shell } => *shell,
        other => {
            tracing::error!(?other, "get_case_detail produced non-CaseDetail surface");
            return Err(StatusCode::INTERNAL_SERVER_ERROR);
        }
    };
    let rendered = match shell_strategy {
        CaseDetailShell::Scroll => ScrollShellTemplate { /* … */ }.render(),
        CaseDetailShell::CardGrid => CardGridShellTemplate { /* … */ }.render(),
        CaseDetailShell::Tabs => TabsShellTemplate { /* … */ }.render(),
    };
    rendered.map(Html).map_err(|e| {
        tracing::error!(error = %e, "case detail shell render failed");
        StatusCode::INTERNAL_SERVER_ERROR
    })
}

#[derive(Debug, Deserialize)]
pub struct CaseDetailQuery {
    pub focus_section: Option<String>,
    pub program: Option<String>,
}

// services/canopy-web/src/case_detail/util.rs

use canopy_composition::CaseSectionDef;
use crate::api::case_detail::Program;

/// True if the section's manifest `programs = [...]` includes the
/// current program. Manifest validator only accepts the 5 canonical
/// program slugs (no "all" token — cross-program sections enumerate
/// all 5 explicitly per D4).
pub fn section_applies_to_program(def: &CaseSectionDef, program: Program) -> bool {
    def.programs.iter().any(|p| p == program.slug())
}

pub async fn dispatch_fetch(
    item: &ComposedItem,
    active_program: Program,
    plugins: &dyn PluginSource,
    clients: &ServiceClients,
    household_id: &str,
    session: &SessionData,
) -> RenderedSection {
    let (_plugin, def) = match plugins.find_case_section(&item.item) {
        Some(pair) => pair,
        None => return unknown_section::render_error(&item.item.0),
    };

    // Apply program filter — placeholder for non-applicable sections.
    if !section_applies_to_program(def, active_program) {
        return placeholder_for_program(item, def, active_program);
    }

    match item.item.0.as_str() {
        "case-detail-household-section"     => household::fetch(clients, household_id, session).await,
        "case-detail-income-section"        => income::fetch(clients, household_id, session).await,
        "case-detail-determination-section" => determination::fetch(clients, household_id, active_program).await,
        "case-detail-notices-section"       => notices::fetch(clients, household_id, session).await,
        // ... 16 more slugs (9 real + 7 stubs)
        _ => unknown_section::render_error(&item.item.0),
    }
}

// services/canopy-web/src/case_detail/util.rs

/// Strip the `case-detail-` prefix AND `-section` suffix from a
/// composition item slug. Each removed exactly once via strip_prefix
/// / strip_suffix (not trim_*_matches).
pub fn short_section_slug(slug: &str) -> &str {
    let after_prefix = slug.strip_prefix("case-detail-").unwrap_or(slug);
    after_prefix.strip_suffix("-section").unwrap_or(after_prefix)
}

// services/canopy-web/src/api/case_detail.rs (helper)

const ALLOWED_FOCUS_SECTIONS: &[&str] = &[
    "household", "income", "determination", "notices", "appeals",
    "activity", "abawd", "work-req", "time-limits", "categories",
    "authorization", "nutrition", "guidance",
    "persons", "assets", "expenses", "verifications", "audit",
    "cross-program", "documents",
];

pub fn safe_focus_section(input: Option<&str>) -> &'static str {
    input
        .and_then(|s| ALLOWED_FOCUS_SECTIONS.iter().find(|&&allowed| allowed == s).copied())
        .unwrap_or("determination")
}

let qs = safe_focus_section(form.target_section.as_deref());
Ok(Redirect::to(&format!(
    "/cases/{}?focus_section={}",
    form.household_id, qs,
)))

// services/canopy-web/static/js/canopy-web.js (inside the existing
// `alpine:init` listener, around line 75).

Alpine.data('caseDetailFocus', () => ({
  _cfg: null,
  focusedSection: '',

  init() {
    const node = document.getElementById('case-detail-init');
    if (!node) return;
    try {
      this._cfg = JSON.parse(node.textContent);
    } catch (e) { return; }
    const params = new URLSearchParams(window.location.search);
    this.focusedSection = params.get('focus_section') || this._cfg.focus_section || '';
    if (this.focusedSection) this._scrollAndFocus(this.focusedSection);
  },

  focusSection(ev) {
    const slug = ev.currentTarget.dataset.sectionSlug;
    if (!slug) return;
    this.focusedSection = slug;
    this._scrollAndFocus(slug);
  },

  _scrollAndFocus(slug) {
    const target = document.getElementById('sec-' + slug);
    if (!target) return;
    target.scrollIntoView({ behavior: 'smooth', block: 'start' });
    setTimeout(() => { target.focus({ preventScroll: true }); }, 350);
  },
}));

#[derive(Template)]
#[template(path = "case_detail/_identity_hero.html")]
pub struct CaseIdentityHero {
    pub case_number: String,
    pub head_of_household_name: String,
    pub county: String,
    pub member_summary: String,        // "4 members"
    pub current_benefit: String,       // "$540 / month" or empty
    pub certification_period: String,  // "Through 2026-09-30" or empty
    pub program_chips: Vec<ProgramChip>,
}

#[derive(Serialize)]
pub struct ProgramChip {
    pub slug: String,
    pub label: String,
    pub status: String,
    pub status_class: String,
}