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

style: apply cargo fmt to entire codebase

Browse Source 
Standardize code formatting across all 173 Rust source files
using rustfmt. No functional changes - purely cosmetic.

This establishes a consistent code style baseline for the
project going forward.
This commit is contained in:
Dionisio
2026-02-14 01:29:34 +01:00
parent 67137a3ef2
commit 4c98c5a657
173 changed files with 23368 additions and 17590 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/application/services/search_service.rs
+194 -166
View File
@@ -1,21 +1,21 @@
use std::sync::Arc;
use std::collections::HashMap;
use std::time::{Duration, Instant};
use std::sync::Mutex;
use async_trait::async_trait;
use std::collections::HashMap;
use std::sync::Arc;
use std::sync::Mutex;
use std::time::{Duration, Instant};
use tokio::time;
use crate::common::errors::Result;
use crate::application::dtos::search_dto::{SearchCriteriaDto, SearchResultsDto};
use crate::application::dtos::file_dto::FileDto;
use crate::application::dtos::folder_dto::FolderDto;
use crate::application::dtos::search_dto::{SearchCriteriaDto, SearchResultsDto};
use crate::application::ports::inbound::SearchUseCase;
use crate::application::ports::outbound::FolderStoragePort;
use crate::application::ports::storage_ports::FileReadPort;
use crate::common::errors::Result;
/**
* Search service implementation for files and folders.
*
*
* This service implements the advanced search functionality that allows
* users to find files and folders based on various criteria
* such as name, type, date and size. It also includes a cache to improve
@@ -24,16 +24,16 @@ use crate::application::ports::storage_ports::FileReadPort;
pub struct SearchService {
/// Repository for file operations
file_repository: Arc<dyn FileReadPort>,
/// Repository for folder operations
folder_repository: Arc<dyn FolderStoragePort>,
/// Search results cache with expiration time
search_cache: Arc<Mutex<HashMap<SearchCacheKey, CachedSearchResult>>>,
/// Cache validity duration in seconds
cache_ttl: u64,
/// Maximum cache size (number of stored results)
max_cache_size: usize,
}
@@ -43,7 +43,7 @@ pub struct SearchService {
struct SearchCacheKey {
/// Serialized representation of the search criteria
criteria_hash: String,
/// User ID (to isolate searches between users)
user_id: String,
}
@@ -52,7 +52,7 @@ struct SearchCacheKey {
struct CachedSearchResult {
/// Search results
results: SearchResultsDto,
/// Time when the cache entry was created
timestamp: Instant,
}
@@ -60,7 +60,7 @@ struct CachedSearchResult {
impl SearchService {
/**
* Creates a new instance of the search service.
*
*
* @param file_repository Repository for file operations
* @param folder_repository Repository for folder operations
* @param cache_ttl Cache time-to-live in seconds (0 to disable)
@@ -79,18 +79,18 @@ impl SearchService {
cache_ttl,
max_cache_size,
};
// Start cache cleanup task if TTL > 0
if cache_ttl > 0 {
Self::start_cache_cleanup_task(search_service.search_cache.clone(), cache_ttl);
}
search_service
}
/**
* Starts an asynchronous task to clean up expired cache entries.
*
*
* @param cache_ref Reference to the shared cache
* @param ttl_seconds TTL in seconds
*/
@@ -101,21 +101,21 @@ impl SearchService {
tokio::spawn(async move {
let cleanup_interval = Duration::from_secs(ttl_seconds / 2);
let ttl = Duration::from_secs(ttl_seconds);
loop {
time::sleep(cleanup_interval).await;
// Acquire lock and clean up expired entries
if let Ok(mut cache) = cache_ref.lock() {
let now = Instant::now();
// Identify expired entries
let expired_keys: Vec<SearchCacheKey> = cache
.iter()
.filter(|(_, result)| now.duration_since(result.timestamp) > ttl)
.map(|(key, _)| key.clone())
.collect();
// Remove expired entries
for key in expired_keys {
cache.remove(&key);
@@ -124,10 +124,10 @@ impl SearchService {
}
});
}
/**
* Creates a cache key from the search criteria.
*
*
* @param criteria Search criteria
* @param user_id User ID (to isolate cache between users)
* @return Cache key
@@ -135,16 +135,16 @@ impl SearchService {
fn create_cache_key(&self, criteria: &SearchCriteriaDto, user_id: &str) -> SearchCacheKey {
// Serialize criteria to generate a hash
let criteria_str = serde_json::to_string(criteria).unwrap_or_default();
SearchCacheKey {
criteria_hash: criteria_str,
user_id: user_id.to_string(),
}
}
/**
* Attempts to retrieve results from the cache.
*
*
* @param key Cache key
* @return Optionally, the results if they exist and have not expired
*/
@@ -153,24 +153,25 @@ impl SearchService {
if self.cache_ttl == 0 {
return None;
}
if let Ok(cache) = self.search_cache.lock()
&& let Some(cached_result) = cache.get(key) {
let now = Instant::now();
let ttl = Duration::from_secs(self.cache_ttl);
// Check if the entry has expired
if now.duration_since(cached_result.timestamp) < ttl {
return Some(cached_result.results.clone());
}
&& let Some(cached_result) = cache.get(key)
{
let now = Instant::now();
let ttl = Duration::from_secs(self.cache_ttl);
// Check if the entry has expired
if now.duration_since(cached_result.timestamp) < ttl {
return Some(cached_result.results.clone());
}
}
None
}
/**
* Stores results in the cache.
*
*
* @param key Cache key
* @param results Results to store
*/
@@ -179,45 +180,56 @@ impl SearchService {
if self.cache_ttl == 0 {
return;
}
if let Ok(mut cache) = self.search_cache.lock() {
// If the cache is full, remove the oldest entry
if cache.len() >= self.max_cache_size
&& let Some((oldest_key, _)) = cache
.iter()
.min_by_key(|(_, result)| result.timestamp) {
let key_to_remove = oldest_key.clone();
cache.remove(&key_to_remove);
}
&& let Some((oldest_key, _)) =
cache.iter().min_by_key(|(_, result)| result.timestamp)
{
let key_to_remove = oldest_key.clone();
cache.remove(&key_to_remove);
}
// Store the new result
cache.insert(key, CachedSearchResult {
results,
timestamp: Instant::now(),
});
cache.insert(
key,
CachedSearchResult {
results,
timestamp: Instant::now(),
},
);
}
}
/**
* Filters files according to the search criteria.
*
*
* @param files List of files to filter
* @param criteria Search criteria
* @return Files that match the criteria
*/
fn filter_files(&self, files: Vec<FileDto>, criteria: &SearchCriteriaDto) -> Vec<FileDto> {
files.into_iter()
files
.into_iter()
.filter(|file| {
// Filter by name
if let Some(name_query) = &criteria.name_contains
&& !file.name.to_lowercase().contains(&name_query.to_lowercase()) {
return false;
}
&& !file
.name
.to_lowercase()
.contains(&name_query.to_lowercase())
{
return false;
}
// Filter by file type (extension)
if let Some(file_types) = &criteria.file_types {
if let Some(extension) = file.name.split('.').next_back() {
if !file_types.iter().any(|ext| ext.eq_ignore_ascii_case(extension)) {
if !file_types
.iter()
.any(|ext| ext.eq_ignore_ascii_case(extension))
{
return false;
}
} else {
@@ -225,91 +237,110 @@ impl SearchService {
return false;
}
}
// Filter by creation date
if let Some(created_after) = criteria.created_after
&& file.created_at < created_after {
return false;
}
&& file.created_at < created_after
{
return false;
}
if let Some(created_before) = criteria.created_before
&& file.created_at > created_before {
return false;
}
&& file.created_at > created_before
{
return false;
}
// Filter by modification date
if let Some(modified_after) = criteria.modified_after
&& file.modified_at < modified_after {
return false;
}
&& file.modified_at < modified_after
{
return false;
}
if let Some(modified_before) = criteria.modified_before
&& file.modified_at > modified_before {
return false;
}
&& file.modified_at > modified_before
{
return false;
}
// Filter by size
if let Some(min_size) = criteria.min_size
&& file.size < min_size {
return false;
}
&& file.size < min_size
{
return false;
}
if let Some(max_size) = criteria.max_size
&& file.size > max_size {
return false;
}
&& file.size > max_size
{
return false;
}
true
})
.collect()
}
/**
* Filters folders according to the search criteria.
*
*
* @param folders List of folders to filter
* @param criteria Search criteria
* @return Folders that match the criteria
*/
fn filter_folders(&self, folders: Vec<FolderDto>, criteria: &SearchCriteriaDto) -> Vec<FolderDto> {
folders.into_iter()
fn filter_folders(
&self,
folders: Vec<FolderDto>,
criteria: &SearchCriteriaDto,
) -> Vec<FolderDto> {
folders
.into_iter()
.filter(|folder| {
// Filter by name
if let Some(name_query) = &criteria.name_contains
&& !folder.name.to_lowercase().contains(&name_query.to_lowercase()) {
return false;
}
&& !folder
.name
.to_lowercase()
.contains(&name_query.to_lowercase())
{
return false;
}
// Filter by creation date
if let Some(created_after) = criteria.created_after
&& folder.created_at < created_after {
return false;
}
&& folder.created_at < created_after
{
return false;
}
if let Some(created_before) = criteria.created_before
&& folder.created_at > created_before {
return false;
}
&& folder.created_at > created_before
{
return false;
}
// Filter by modification date
if let Some(modified_after) = criteria.modified_after
&& folder.modified_at < modified_after {
return false;
}
&& folder.modified_at < modified_after
{
return false;
}
if let Some(modified_before) = criteria.modified_before
&& folder.modified_at > modified_before {
return false;
}
&& folder.modified_at > modified_before
{
return false;
}
true
})
.collect()
}
/**
* Implementation of recursive search through folders.
*
*
* @param current_folder_id ID of the current folder
* @param criteria Search criteria
* @param found_files Files found so far
@@ -323,43 +354,39 @@ impl SearchService {
found_folders: &mut Vec<FolderDto>,
) -> Result<()> {
Box::pin(async move {
// List files in the current folder
let files = self.file_repository.list_files(current_folder_id).await?;
// Filter files according to criteria and add them to the results
let filtered_files = self.filter_files(
files.into_iter().map(FileDto::from).collect(),
criteria
);
found_files.extend(filtered_files);
// If the search is recursive, process subfolders
if criteria.recursive {
// List subfolders
let folders = self.folder_repository.list_folders(current_folder_id).await?;
// Filter folders according to criteria and add them to the results
let filtered_folders: Vec<FolderDto> = self.filter_folders(
folders.into_iter().map(FolderDto::from).collect(),
criteria
);
// Add filtered folders to the results
found_folders.extend(filtered_folders.iter().cloned());
// Search recursively in each subfolder
for folder in filtered_folders {
self.search_recursive(
Some(&folder.id),
criteria,
found_files,
found_folders,
).await?;
// List files in the current folder
let files = self.file_repository.list_files(current_folder_id).await?;
// Filter files according to criteria and add them to the results
let filtered_files =
self.filter_files(files.into_iter().map(FileDto::from).collect(), criteria);
found_files.extend(filtered_files);
// If the search is recursive, process subfolders
if criteria.recursive {
// List subfolders
let folders = self
.folder_repository
.list_folders(current_folder_id)
.await?;
// Filter folders according to criteria and add them to the results
let filtered_folders: Vec<FolderDto> = self
.filter_folders(folders.into_iter().map(FolderDto::from).collect(), criteria);
// Add filtered folders to the results
found_folders.extend(filtered_folders.iter().cloned());
// Search recursively in each subfolder
for folder in filtered_folders {
self.search_recursive(Some(&folder.id), criteria, found_files, found_folders)
.await?;
}
}
}
Ok(())
}).await
Ok(())
})
.await
}
}
@@ -367,7 +394,7 @@ impl SearchService {
impl SearchUseCase for SearchService {
/**
* Performs a search based on the specified criteria.
*
*
* @param criteria Search criteria
* @return Search results
*/
@@ -375,36 +402,37 @@ impl SearchUseCase for SearchService {
// TODO: Get user ID from the authentication context
let user_id = "default-user";
let cache_key = self.create_cache_key(&criteria, user_id);
// Try to get results from the cache
if let Some(cached_results) = self.get_from_cache(&cache_key) {
return Ok(cached_results);
}
// Initialize collections for results
let mut found_files: Vec<FileDto> = Vec::new();
let mut found_folders: Vec<FolderDto> = Vec::new();
// Perform search in the specified folder or at the root
self.search_recursive(
criteria.folder_id.as_deref(),
&criteria,
&mut found_files,
&mut found_folders,
).await?;
)
.await?;
// Apply pagination
let total_count = found_files.len() + found_folders.len();
// Sort by relevance or date according to criteria
// By default, sort by modification date (most recent first)
found_files.sort_by(|a, b| b.modified_at.cmp(&a.modified_at));
found_folders.sort_by(|a, b| b.modified_at.cmp(&a.modified_at));
// Apply limit and offset for pagination
let start_idx = criteria.offset.min(total_count);
let end_idx = (criteria.offset + criteria.limit).min(total_count);
let paginated_items: Vec<(bool, usize)> = (start_idx..end_idx)
.map(|i| {
if i < found_folders.len() {
@@ -414,11 +442,11 @@ impl SearchUseCase for SearchService {
}
})
.collect();
// Extract paginated items
let mut paginated_folders = Vec::new();
let mut paginated_files = Vec::new();
for (is_folder, idx) in paginated_items {
if is_folder {
if idx < found_folders.len() {
@@ -428,7 +456,7 @@ impl SearchUseCase for SearchService {
paginated_files.push(found_files[idx].clone());
}
}
// Create results object
let search_results = SearchResultsDto::new(
paginated_files,
@@ -437,16 +465,16 @@ impl SearchUseCase for SearchService {
criteria.offset,
Some(total_count),
);
// Store in cache
self.store_in_cache(cache_key, search_results.clone());
Ok(search_results)
}
/**
* Clears the search results cache.
*
*
* @return Result indicating success
*/
async fn clear_search_cache(&self) -> Result<()> {
@@ -462,18 +490,18 @@ impl SearchService {
/// Creates a stub version of the service for testing
pub fn new_stub() -> impl SearchUseCase {
struct SearchServiceStub;
#[async_trait]
impl SearchUseCase for SearchServiceStub {
async fn search(&self, _criteria: SearchCriteriaDto) -> Result<SearchResultsDto> {
Ok(SearchResultsDto::empty())
}
async fn clear_search_cache(&self) -> Result<()> {
Ok(())
}
}
SearchServiceStub
}
}
}