use std::sync::Arc;
use axum::Json;
use axum::extract::rejection::QueryRejection;
use axum::extract::{Query, State};
use axum::response::IntoResponse;
use chrono::Utc;
use second_brain_core::digest::{DEFAULT_WINDOW, Digest, Window};
use serde::Deserialize;
use super::project_names::refuse_unknown_project;
use super::{bad_request, internal_error};
use crate::AppState;
#[derive(Deserialize)]
pub(super) struct DigestQuery {
since: Option<String>,
project: Option<String>,
}
fn read_digest(
state: &AppState,
window: Window,
project: Option<&str>,
) -> anyhow::Result<Result<Digest, String>> {
if let Some(project) = project
&& let Some(refusal) = refuse_unknown_project(&state.sqlite, project)?
{
return Ok(Err(refusal));
}
Ok(Ok(Digest::read(&state.sqlite, window, project)?))
}
pub(super) async fn digest(
State(state): State<Arc<AppState>>,
query: Result<Query<DigestQuery>, QueryRejection>,
) -> axum::response::Response {
let request = query
.map_err(|rejection| rejection.body_text())
.and_then(|Query(q)| {
let since = q.since.as_deref().unwrap_or(DEFAULT_WINDOW);
Ok((Window::parse(since, Utc::now())?, q.project))
});
let (window, project) = match request {
Ok(request) => request,
Err(message) => return bad_request(message),
};
let result =
tokio::task::spawn_blocking(move || read_digest(&state, window, project.as_deref())).await;
match result {
Ok(Ok(Ok(digest))) => Json(digest).into_response(),
Ok(Ok(Err(message))) => bad_request(message),
Ok(Err(e)) => internal_error(e),
Err(e) => internal_error(e),
}
}