cjw/Oxicloud
1
0
Fork 0
Code Issues Pull Requests Actions 4 Packages Projects Releases Wiki Activity

feat: folder ownership scoping, batch operations integration, frontend audit fixes

Browse Source 
Backend:
- Add owner_id to Folder entity + FolderDto (DB user_id column)
- Add list_folders_by_owner to FolderRepository trait + PG impl
- Add list_folders_for_owner to FolderUseCase + FolderService
- Rewrite FolderHandler: all endpoints now scope by AuthUser
- Remove dead handler methods (list_folders_inner, list_folders_for_user, is_user_home_folder, folder_belongs_to_user)
- Add ownership check in get_folder (returns 404 on mismatch)

Batch operations:
- Add trash_service + zip_service to BatchOperationService
- New methods: trash_files, trash_folders, move_folders, download_zip
- New handlers: trash_batch, move_folders_batch, download_batch
- New routes: POST /api/batch/trash, /api/batch/folders/move, /api/batch/download

Frontend:
- Replace findUserHomeFolder (~130 lines) with resolveHomeFolder (~35 lines)
- Remove client-side folder filtering in loadFiles (backend now scopes)
- Rewrite batchDelete: N requests -> 1 POST /api/batch/trash
- Rewrite batchMove: N requests -> 2 POST max (files + folders)
- Rewrite batchDownload: N requests -> 1 POST /api/batch/download (ZIP)
- Search moved to backend, share system uses backend API
- Dark mode fixes, frontend audit improvements
This commit is contained in:
Dionisio
2026-02-15 23:45:11 +01:00
parent 6e1b77f244
commit 7737ed90c7
33 changed files with 3078 additions and 1958 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/interfaces/api/handlers/search_handler.rs
+89 -71
View File
@@ -12,43 +12,32 @@ use crate::common::di::AppState;
/**
* Handler for search operations through the API.
*
* This handler exposes endpoints related to search functionality,
* allowing users to search for files and folders using various criteria.
* All search processing (filtering, scoring, sorting, categorization,
* formatting) is performed server-side. These handlers are thin HTTP
* adapters that delegate to the SearchUseCase.
*/
pub struct SearchHandler;
impl SearchHandler {
/**
* Performs a search based on the criteria provided as query parameters.
*
* This endpoint allows simple searches directly with URL parameters.
*
* @param state Application state with services
* @param query_params Search parameters as query string
* @return HTTP response with the search results
*/
/// GET /search — simple query-parameter-based search.
pub async fn search_files_get(
State(state): State<AppState>,
Query(params): Query<SearchParams>,
) -> impl IntoResponse {
info!("API: File search with parameters: {:?}", params);
// Extract the search service or return error if not available
let search_service = match &state.applications.search_service {
Some(service) => service,
None => {
error!("Search service not available");
return (
StatusCode::SERVICE_UNAVAILABLE,
Json(json!({
"error": "Search service is not available"
})),
Json(json!({ "error": "Search service is not available" })),
)
.into_response();
}
};
// Convert search parameters to DTO
let search_criteria = SearchCriteriaDto {
name_contains: params.query,
file_types: params
@@ -64,13 +53,14 @@ impl SearchHandler {
recursive: params.recursive.unwrap_or(true),
limit: params.limit.unwrap_or(100),
offset: params.offset.unwrap_or(0),
sort_by: params.sort_by.unwrap_or_else(|| "relevance".to_string()),
};
// Perform the search
match search_service.search(search_criteria).await {
Ok(results) => {
info!(
"Search completed, {} files and {} folders found",
"Search completed in {}ms — {} files, {} folders",
results.query_time_ms,
results.files.len(),
results.folders.len()
);
@@ -80,51 +70,37 @@ impl SearchHandler {
error!("Search error: {}", err);
(
StatusCode::INTERNAL_SERVER_ERROR,
Json(json!({
"error": format!("Search error: {}", err)
})),
Json(json!({ "error": format!("Search error: {}", err) })),
)
.into_response()
}
}
}
/**
* Performs an advanced search based on a complete JSON criteria object.
*
* This endpoint allows more complex searches with all possible criteria
* provided in the request body.
*
* @param state Application state with services
* @param criteria Complete search criteria
* @return HTTP response with the search results
*/
/// POST /search/advanced — full criteria in the request body.
pub async fn search_files_post(
State(state): State<AppState>,
Json(criteria): Json<SearchCriteriaDto>,
) -> impl IntoResponse {
info!("API: Advanced file search");
// Extract the search service or return error if not available
let search_service = match &state.applications.search_service {
Some(service) => service,
None => {
error!("Search service not available");
return (
StatusCode::SERVICE_UNAVAILABLE,
Json(json!({
"error": "Search service is not available"
})),
Json(json!({ "error": "Search service is not available" })),
)
.into_response();
}
};
// Perform the search
match search_service.search(criteria).await {
Ok(results) => {
info!(
"Search completed, {} files and {} folders found",
"Advanced search completed in {}ms — {} files, {} folders",
results.query_time_ms,
results.files.len(),
results.folders.len()
);
@@ -134,51 +110,79 @@ impl SearchHandler {
error!("Search error: {}", err);
(
StatusCode::INTERNAL_SERVER_ERROR,
Json(json!({
"error": format!("Search error: {}", err)
})),
Json(json!({ "error": format!("Search error: {}", err) })),
)
.into_response()
}
}
}
/**
* Clears the search results cache.
*
* This endpoint is useful for forcing fresh searches after significant
* changes in the file system.
*
* @param state Application state with services
* @return HTTP response indicating success or error
*/
pub async fn clear_search_cache(State(state): State<AppState>) -> impl IntoResponse {
info!("API: Clearing search cache");
/// GET /search/suggest — lightweight autocomplete suggestions.
pub async fn suggest_files(
State(state): State<AppState>,
Query(params): Query<SuggestParams>,
) -> impl IntoResponse {
info!("API: Search suggestions for {:?}", params.query);
// Extract the search service or return error if not available
let search_service = match &state.applications.search_service {
Some(service) => service,
None => {
error!("Search service not available");
return (
StatusCode::SERVICE_UNAVAILABLE,
Json(json!({
"error": "Search service is not available"
})),
Json(json!({ "error": "Search service is not available" })),
)
.into_response();
}
};
let limit = params.limit.unwrap_or(10).min(20);
match search_service
.suggest(&params.query, params.folder_id.as_deref(), limit)
.await
{
Ok(suggestions) => {
info!(
"Suggestions completed in {}ms — {} results",
suggestions.query_time_ms,
suggestions.suggestions.len()
);
(StatusCode::OK, Json(suggestions)).into_response()
}
Err(err) => {
error!("Suggestions error: {}", err);
(
StatusCode::INTERNAL_SERVER_ERROR,
Json(json!({ "error": format!("Suggestions error: {}", err) })),
)
.into_response()
}
}
}
/// DELETE /search/cache — clears the search results cache.
pub async fn clear_search_cache(State(state): State<AppState>) -> impl IntoResponse {
info!("API: Clearing search cache");
let search_service = match &state.applications.search_service {
Some(service) => service,
None => {
error!("Search service not available");
return (
StatusCode::SERVICE_UNAVAILABLE,
Json(json!({ "error": "Search service is not available" })),
)
.into_response();
}
};
// Clear the cache
match search_service.clear_search_cache().await {
Ok(_) => {
info!("Search cache cleared successfully");
(
StatusCode::OK,
Json(json!({
"message": "Search cache cleared successfully"
})),
Json(json!({ "message": "Search cache cleared successfully" })),
)
.into_response()
}
@@ -186,9 +190,7 @@ impl SearchHandler {
error!("Error clearing search cache: {}", err);
(
StatusCode::INTERNAL_SERVER_ERROR,
Json(json!({
"error": format!("Error clearing search cache: {}", err)
})),
Json(json!({ "error": format!("Error clearing search cache: {}", err) })),
)
.into_response()
}
@@ -196,38 +198,38 @@ impl SearchHandler {
}
}
/// Search parameters for the GET endpoint
/// Search parameters for the GET /search endpoint
#[derive(Debug, serde::Deserialize)]
pub struct SearchParams {
/// Text to search for in file and folder names
/// Text to search in file and folder names
pub query: Option<String>,
/// Filter by file types (comma-separated extensions)
#[serde(rename = "type")]
pub type_filter: Option<String>,
/// Filter items created after this date (timestamp)
/// Created after this timestamp
pub created_after: Option<u64>,
/// Filter items created before this date (timestamp)
/// Created before this timestamp
pub created_before: Option<u64>,
/// Filter items modified after this date (timestamp)
/// Modified after this timestamp
pub modified_after: Option<u64>,
/// Filter items modified before this date (timestamp)
/// Modified before this timestamp
pub modified_before: Option<u64>,
/// Minimum size in bytes
/// Minimum file size in bytes
pub min_size: Option<u64>,
/// Maximum size in bytes
/// Maximum file size in bytes
pub max_size: Option<u64>,
/// Folder ID to limit the search scope
pub folder_id: Option<String>,
/// Recursive search in subfolders
/// Recursive search in subfolders (default: true)
pub recursive: Option<bool>,
/// Result limit for pagination
@@ -235,4 +237,20 @@ pub struct SearchParams {
/// Offset for pagination
pub offset: Option<usize>,
/// Sort order: relevance | name | name_desc | date | date_desc | size | size_desc
pub sort_by: Option<String>,
}
/// Parameters for the GET /search/suggest endpoint
#[derive(Debug, serde::Deserialize)]
pub struct SuggestParams {
/// Text to search for suggestions
pub query: String,
/// Folder ID to limit the suggestion scope
pub folder_id: Option<String>,
/// Maximum number of suggestions (default 10, max 20)
pub limit: Option<usize>,
}