use axum::{
extract::{Extension, Path},
http::StatusCode,
response::IntoResponse,
Json,
};
use log::error;
use std::sync::Arc;
use crate::{
application::dto::scrape_response::{ScrapeResultDto, ScrapeStatusResponseDto},
domain::models::TaskStatus,
domain::repositories::{
scrape_result_repository::ScrapeResultRepository, task_repository::TaskRepository,
},
i18n::{I18nBundle, Locale},
presentation::handlers::response_builder::{errors_locale, ApiResponse},
presentation::middleware::auth_middleware::AuthState,
};
pub async fn get_scrape_status(
Path(id): Path<crate::domain::id::Id>,
Extension(task_repository): Extension<Arc<dyn TaskRepository>>,
Extension(result_repository): Extension<Arc<dyn ScrapeResultRepository>>,
Extension(auth_state): Extension<AuthState>,
Extension(locale): Extension<Locale>,
Extension(bundle): Extension<Arc<I18nBundle>>,
) -> impl IntoResponse {
let team_id = auth_state.team_id;
match task_repository.find_by_id(id).await {
Ok(Some(task)) => {
if task.team_id != team_id {
return errors_locale::forbidden(&locale, &bundle, "api-access-denied");
}
let result_data = fetch_result_dto(result_repository.as_ref(), &task).await;
let error = failure_error_message(&task, &locale, &bundle);
let response = ScrapeStatusResponseDto {
id: task.id,
status: task.status.to_string(),
url: task.url,
created_at: task.created_at.naive_utc(),
completed_at: task.completed_at.map(|dt| dt.naive_utc()),
result: result_data,
metadata: task.payload.get("metadata").cloned(),
error,
};
(StatusCode::OK, Json(ApiResponse::success(response))).into_response()
}
Ok(None) => errors_locale::not_found(&locale, &bundle, "api-task-not-found"),
Err(e) => {
error!("Failed to get task status {}: {}", id, e);
errors_locale::internal_server_error(&locale, &bundle, "api-internal-error")
}
}
}
async fn fetch_result_dto(
result_repository: &dyn ScrapeResultRepository,
task: &crate::domain::models::Task,
) -> Option<ScrapeResultDto> {
if task.status != TaskStatus::Completed {
return None;
}
match result_repository.find_by_task_id(task.id).await {
Ok(Some(result)) => {
let mut dto = ScrapeResultDto {
content: result.content,
status_code: result.status_code as u16,
content_type: Some(result.content_type),
response_time_ms: result.response_time_ms,
headers: Some(result.headers),
meta_data: Some(result.meta_data),
screenshot: result.screenshot,
created_at: result.created_at.naive_utc(),
};
dto.filter_sensitive_headers();
Some(dto)
}
Ok(None) => {
error!("No scrape result found for completed task {}", task.id);
None
}
Err(e) => {
error!("Failed to fetch scrape result for task {}: {}", task.id, e);
None
}
}
}
fn failure_error_message(
task: &crate::domain::models::Task,
locale: &Locale,
bundle: &I18nBundle,
) -> Option<String> {
if task.status == TaskStatus::Failed {
task.payload
.get("error")
.and_then(|e| e.as_str())
.map(|s| s.to_string())
.or(Some(crate::i18n::t(locale, bundle, "api-task-failed")))
} else {
None
}
}