#![allow(unused_variables)]
use crate::application::dto::task_query_request::{
CancelledTaskInfoDto, FailedTaskInfoDto, TaskCancelDataDto, TaskCancelRequestDto,
};
use crate::domain::repositories::task_repository::TaskRepository;
use crate::presentation::errors::CrawlRsError;
use crate::presentation::handlers::response_builder::{json_rejection_error, ApiResponse};
use crate::presentation::middleware::auth_middleware::AuthState;
use axum::{extract::Extension, Json};
use chrono::Utc;
use sdforge::validator::Validate;
use std::sync::Arc;
use super::task_queries::wait_for_tasks_completion;
pub async fn cancel_tasks<T: TaskRepository>(
Extension(auth_state): Extension<AuthState>,
Extension(task_repo): Extension<Arc<T>>,
payload: Result<Json<TaskCancelRequestDto>, axum::extract::rejection::JsonRejection>,
) -> Result<Json<ApiResponse<TaskCancelDataDto>>, CrawlRsError> {
let request = parse_cancel_request(payload)?;
let team_id = auth_state.team_id;
let force = request.force.unwrap_or(false);
let sync_wait_ms = request.sync_wait_ms.unwrap_or(5000);
let (cancelled_task_ids, failed_tasks) = task_repo
.batch_cancel(request.task_ids.clone(), team_id, force) .await?;
let sync_mode = sync_wait_ms > 0 && !cancelled_task_ids.is_empty();
if sync_mode {
wait_for_tasks_completion(
task_repo.as_ref(),
&cancelled_task_ids,
team_id,
sync_wait_ms,
500, )
.await?;
}
Ok(build_cancel_response(cancelled_task_ids, failed_tasks))
}
fn parse_cancel_request(
payload: Result<Json<TaskCancelRequestDto>, axum::extract::rejection::JsonRejection>,
) -> Result<TaskCancelRequestDto, CrawlRsError> {
let Json(request) = match payload {
Ok(parsed) => parsed,
Err(rej) => return Err(json_rejection_error(rej)),
};
if let Err(errors) = request.validate() {
return Err(CrawlRsError::Unprocessable(
crate::presentation::handlers::response_builder::validation_error_message(&errors),
));
}
if request.task_ids.is_empty() {
return Err(CrawlRsError::Validation(
"Task IDs cannot be empty".to_string(),
));
}
Ok(request)
}
fn build_cancel_response(
cancelled_task_ids: Vec<crate::domain::id::Id>,
failed_tasks: Vec<(crate::domain::id::Id, String)>,
) -> Json<ApiResponse<TaskCancelDataDto>> {
let cancelled_tasks: Vec<CancelledTaskInfoDto> = cancelled_task_ids
.into_iter()
.map(|task_id| CancelledTaskInfoDto {
task_id,
status: "cancelled".to_string(),
cancelled_at: Utc::now().into(),
})
.collect();
let failed_tasks_info: Vec<FailedTaskInfoDto> = failed_tasks
.into_iter()
.map(|(task_id, reason)| FailedTaskInfoDto { task_id, reason })
.collect();
let total_cancelled = cancelled_tasks.len() as u64;
let total_failed = failed_tasks_info.len() as u64;
Json(ApiResponse::success(TaskCancelDataDto {
cancelled_tasks,
failed_tasks: failed_tasks_info,
total_cancelled,
total_failed,
}))
}