Function handle_get_draft_policy

crates/openshell-server/src/grpc/policy.rs:2462–2518

(
    state: &Arc<ServerState>,
    request: Request<GetDraftPolicyRequest>,
)

}

pub(super) async fn handle_get_draft_policy(
    state: &Arc<ServerState>,
    request: Request<GetDraftPolicyRequest>,
) -> Result<Response<GetDraftPolicyResponse>, Status> {
    let principal = request
        .extensions()
        .get::<Principal>()
        .cloned()
        .ok_or_else(|| Status::unauthenticated("missing principal"))?;
    let req = request.into_inner();
    if req.name.is_empty() {
        return Err(Status::invalid_argument("name is required"));
    }

    let sandbox =
        resolve_sandbox_by_name_for_principal(state.store.as_ref(), &principal, &req.name).await?;
    let sandbox_id = sandbox.object_id().to_string();

    let status_filter = if req.status_filter.is_empty() {
        None
    } else {
        Some(req.status_filter.as_str())
    };

    let records = state
        .store
        .list_draft_chunks(&sandbox_id, status_filter)
        .await
        .map_err(|e| Status::internal(format!("list draft chunks failed: {e}")))?;

    let draft_version = state
        .store
        .get_draft_version(&sandbox_id)
        .await
        .map_err(|e| Status::internal(format!("get draft version failed: {e}")))?;

    let chunks: Vec<PolicyChunk> = records
        .into_iter()
        .map(|r| draft_chunk_record_to_proto(&r))
        .collect::<Result<Vec<_>, _>>()?;

    let last_analyzed_at_ms = chunks.iter().map(|c| c.created_at_ms).max().unwrap_or(0);

    debug!(
        sandbox_id = %sandbox_id,
        chunk_count = chunks.len(),
        draft_version = draft_version,
        "GetDraftPolicy: served draft chunks"
    );

    Ok(Response::new(GetDraftPolicyResponse {
        chunks,
        rolling_summary: String::new(),
        draft_version: u64::try_from(draft_version).unwrap_or(0),
        last_analyzed_at_ms,
    }))
}