Function handle_edit_draft_chunk

crates/openshell-server/src/grpc/policy.rs:2849–2900

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

}

pub(super) async fn handle_edit_draft_chunk(
    state: &Arc<ServerState>,
    request: Request<EditDraftChunkRequest>,
) -> Result<Response<EditDraftChunkResponse>, Status> {
    let req = request.into_inner();
    if req.name.is_empty() {
        return Err(Status::invalid_argument("name is required"));
    }
    if req.chunk_id.is_empty() {
        return Err(Status::invalid_argument("chunk_id is required"));
    }
    let proposed_rule = req
        .proposed_rule
        .ok_or_else(|| Status::invalid_argument("proposed_rule is required"))?;

    let sandbox = state
        .store
        .get_message_by_name::<Sandbox>(&req.name)
        .await
        .map_err(|e| Status::internal(format!("fetch sandbox failed: {e}")))?
        .ok_or_else(|| Status::not_found("sandbox not found"))?;
    let sandbox_id = sandbox.object_id().to_string();

    let chunk = state
        .store
        .get_draft_chunk(&req.chunk_id)
        .await
        .map_err(|e| Status::internal(format!("fetch chunk failed: {e}")))?
        .ok_or_else(|| Status::not_found("chunk not found"))?;
    ensure_chunk_belongs_to_sandbox(&chunk, &sandbox_id)?;

    if chunk.status != "pending" {
        return Err(Status::failed_precondition(format!(
            "chunk status is '{}', expected 'pending'",
            chunk.status
        )));
    }

    let rule_bytes = proposed_rule.encode_to_vec();
    state
        .store
        .update_draft_chunk_rule(&req.chunk_id, &rule_bytes)
        .await
        .map_err(|e| Status::internal(format!("update chunk rule failed: {e}")))?;

    info!(
        chunk_id = %req.chunk_id,
        "EditDraftChunk: proposed rule updated"
    );

    Ok(Response::new(EditDraftChunkResponse {}))
}

pub(super) async fn handle_undo_draft_chunk(
    state: &Arc<ServerState>,