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

style: apply cargo fmt formatting to existing codebase

Browse Source 
Run `cargo fmt` across all Rust source files to enforce consistent
formatting (import ordering, line wrapping, match arm braces).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Jan Wiebe
2026-02-21 13:33:18 +01:00
parent d325d2317d
commit 807370e194
23 changed files with 902 additions and 731 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/application/services/auth_application_service.rs
+6 -3
View File
@@ -317,7 +317,8 @@ impl AuthApplicationService {
let created_user = self.user_storage.create_user(user).await?;
// Create personal folder for the user
self.create_personal_folder(&dto.username, created_user.id()).await;
self.create_personal_folder(&dto.username, created_user.id())
.await;
tracing::info!("User registered: {}", created_user.id());
Ok(UserDto::from(created_user))
@@ -659,7 +660,8 @@ impl AuthApplicationService {
let created_user = self.user_storage.create_user(user).await?;
// 5. Create personal folder for the new admin
self.create_personal_folder(&dto.username, created_user.id()).await;
self.create_personal_folder(&dto.username, created_user.id())
.await;
tracing::info!("Custom admin created: {}", created_user.id());
Ok(UserDto::from(created_user))
@@ -765,7 +767,8 @@ impl AuthApplicationService {
}
// Create personal folder
self.create_personal_folder(&dto.username, created.id()).await;
self.create_personal_folder(&dto.username, created.id())
.await;
tracing::info!("Admin created user: {} ({})", dto.username, created.id());
Ok(UserDto::from(created))
src/application/services/batch_operations.rs
+11 -13
View File
@@ -702,22 +702,20 @@ impl BatchOperationService {
// Add individual files at the root of the ZIP
for file_id in &file_ids {
match self.file_retrieval.get_file(file_id).await {
Ok(file_dto) => {
match self.file_retrieval.get_file_content(file_id).await {
Ok(content) => {
if let Err(e) = zip.start_file(&file_dto.name, options) {
info!("Could not start zip entry for {}: {}", file_dto.name, e);
continue;
}
if let Err(e) = zip.write_all(&content) {
info!("Could not write zip entry for {}: {}", file_dto.name, e);
}
Ok(file_dto) => match self.file_retrieval.get_file_content(file_id).await {
Ok(content) => {
if let Err(e) = zip.start_file(&file_dto.name, options) {
info!("Could not start zip entry for {}: {}", file_dto.name, e);
continue;
}
Err(e) => {
info!("Could not read file content {}: {}", file_id, e);
if let Err(e) = zip.write_all(&content) {
info!("Could not write zip entry for {}: {}", file_dto.name, e);
}
}
}
Err(e) => {
info!("Could not read file content {}: {}", file_id, e);
}
},
Err(e) => {
info!("Could not get file metadata {}: {}", file_id, e);
}
src/application/services/favorites_service.rs
+3 -1
View File
@@ -1,4 +1,6 @@
use crate::application::dtos::favorites_dto::{BatchFavoritesResult, BatchFavoritesStats, FavoriteItemDto};
use crate::application::dtos::favorites_dto::{
BatchFavoritesResult, BatchFavoritesStats, FavoriteItemDto,
};
use crate::application::ports::favorites_ports::{FavoritesRepositoryPort, FavoritesUseCase};
use crate::common::errors::{DomainError, ErrorKind, Result};
use async_trait::async_trait;
src/application/services/folder_service.rs
+26 -12
View File
@@ -112,7 +112,11 @@ impl FolderService {
Ok(())
}
async fn create_home_folder(&self, _user_id: &str, _name: String) -> Result<FolderDto, DomainError> {
async fn create_home_folder(
&self,
_user_id: &str,
_name: String,
) -> Result<FolderDto, DomainError> {
Ok(FolderDto::empty())
}
}
@@ -159,7 +163,11 @@ impl FolderUseCase for FolderService {
}
/// Creates a root-level home folder for a user during registration.
async fn create_home_folder(&self, user_id: &str, name: String) -> Result<FolderDto, DomainError> {
async fn create_home_folder(
&self,
user_id: &str,
name: String,
) -> Result<FolderDto, DomainError> {
let folder = self
.folder_storage
.create_home_folder(user_id, name)
@@ -256,12 +264,7 @@ impl FolderUseCase for FolderService {
let (folders, total_items) = self
.folder_storage
.list_folders_paginated(
parent_id,
pagination.offset(),
pagination.limit(),
true,
)
.list_folders_paginated(parent_id, pagination.offset(), pagination.limit(), true)
.await
.map_err(|e| {
DomainError::internal_error(
@@ -354,7 +357,9 @@ impl FolderUseCase for FolderService {
if existing_folder.owner_id() != Some(caller_id) {
tracing::warn!(
"rename_folder: user '{}' attempted to rename folder '{}' owned by '{:?}'",
caller_id, id, existing_folder.owner_id()
caller_id,
id,
existing_folder.owner_id()
);
return Err(DomainError::not_found("Folder", id));
}
@@ -412,7 +417,12 @@ impl FolderUseCase for FolderService {
}
/// Moves a folder to a new parent after verifying ownership.
async fn move_folder(&self, id: &str, dto: MoveFolderDto, caller_id: &str) -> Result<FolderDto, DomainError> {
async fn move_folder(
&self,
id: &str,
dto: MoveFolderDto,
caller_id: &str,
) -> Result<FolderDto, DomainError> {
// Verify the source folder exists and belongs to the caller
let source_folder = self.folder_storage.get_folder(id).await.map_err(|e| {
DomainError::internal_error(
@@ -424,7 +434,9 @@ impl FolderUseCase for FolderService {
if source_folder.owner_id() != Some(caller_id) {
tracing::warn!(
"move_folder: user '{}' attempted to move folder '{}' owned by '{:?}'",
caller_id, id, source_folder.owner_id()
caller_id,
id,
source_folder.owner_id()
);
return Err(DomainError::not_found("Folder", id));
}
@@ -517,7 +529,9 @@ impl FolderUseCase for FolderService {
if folder.owner_id() != Some(caller_id) {
tracing::warn!(
"delete_folder: user '{}' attempted to delete folder '{}' owned by '{:?}'",
caller_id, id, folder.owner_id()
caller_id,
id,
folder.owner_id()
);
return Err(DomainError::not_found("Folder", id));
}
src/application/services/search_service.rs
+54 -54
View File
@@ -5,9 +5,11 @@ use std::sync::Mutex;
use std::time::{Duration, Instant};
use tokio::time;
use crate::application::dtos::display_helpers::{
category_for, icon_class_for, icon_special_class_for,
};
use crate::application::dtos::file_dto::FileDto;
use crate::application::dtos::folder_dto::FolderDto;
use crate::application::dtos::display_helpers::{icon_class_for, icon_special_class_for, category_for};
use crate::application::dtos::search_dto::{
SearchCriteriaDto, SearchFileResultDto, SearchFolderResultDto, SearchResultsDto,
SearchSuggestionItem, SearchSuggestionsDto,
@@ -287,67 +289,67 @@ impl SearchService {
folder_repo: Arc<dyn FolderStoragePort>,
current_folder_id: Option<String>,
criteria: Arc<SearchCriteriaDto>,
) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<(Vec<FileDto>, Vec<FolderDto>)>> + Send>> {
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = Result<(Vec<FileDto>, Vec<FolderDto>)>> + Send>,
> {
Box::pin(async move {
// List files in the current folder
let files = file_repo
.list_files(current_folder_id.as_deref())
.await?;
// List files in the current folder
let files = file_repo.list_files(current_folder_id.as_deref()).await?;
let filtered_files: Vec<FileDto> = files
.into_iter()
.map(FileDto::from)
.filter(|file| passes_file_filter(file, &criteria))
.collect();
let mut all_files = filtered_files;
let mut all_folders: Vec<FolderDto> = Vec::new();
// If recursive, process subfolders in parallel
if criteria.recursive {
let folders = folder_repo
.list_folders(current_folder_id.as_deref())
.await?;
let folder_dtos: Vec<FolderDto> = folders
let filtered_files: Vec<FileDto> = files
.into_iter()
.map(FolderDto::from)
.filter(|f| passes_folder_filter(f, &criteria))
.map(FileDto::from)
.filter(|file| passes_file_filter(file, &criteria))
.collect();
all_folders.extend(folder_dtos.iter().cloned());
let mut all_files = filtered_files;
let mut all_folders: Vec<FolderDto> = Vec::new();
// Spawn parallel tasks for each subfolder
let mut handles = Vec::with_capacity(folder_dtos.len());
for subfolder in &folder_dtos {
let fr = file_repo.clone();
let fdr = folder_repo.clone();
let crit = criteria.clone();
let folder_id = subfolder.id.clone();
// If recursive, process subfolders in parallel
if criteria.recursive {
let folders = folder_repo
.list_folders(current_folder_id.as_deref())
.await?;
handles.push(tokio::spawn(async move {
Self::search_parallel(fr, fdr, Some(folder_id), crit).await
}));
}
let folder_dtos: Vec<FolderDto> = folders
.into_iter()
.map(FolderDto::from)
.filter(|f| passes_folder_filter(f, &criteria))
.collect();
// Collect results from all parallel tasks
for handle in handles {
match handle.await {
Ok(Ok((sub_files, sub_folders))) => {
all_files.extend(sub_files);
all_folders.extend(sub_folders);
}
Ok(Err(e)) => {
tracing::warn!("Parallel search subtask error: {}", e);
}
Err(e) => {
tracing::warn!("Parallel search task join error: {}", e);
all_folders.extend(folder_dtos.iter().cloned());
// Spawn parallel tasks for each subfolder
let mut handles = Vec::with_capacity(folder_dtos.len());
for subfolder in &folder_dtos {
let fr = file_repo.clone();
let fdr = folder_repo.clone();
let crit = criteria.clone();
let folder_id = subfolder.id.clone();
handles.push(tokio::spawn(async move {
Self::search_parallel(fr, fdr, Some(folder_id), crit).await
}));
}
// Collect results from all parallel tasks
for handle in handles {
match handle.await {
Ok(Ok((sub_files, sub_folders))) => {
all_files.extend(sub_files);
all_folders.extend(sub_folders);
}
Ok(Err(e)) => {
tracing::warn!("Parallel search subtask error: {}", e);
}
Err(e) => {
tracing::warn!("Parallel search task join error: {}", e);
}
}
}
}
}
Ok((all_files, all_folders))
Ok((all_files, all_folders))
}) // end Box::pin
}
@@ -560,13 +562,11 @@ impl SearchUseCase for SearchService {
match criteria.sort_by.as_str() {
"name" => {
enriched_files.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
enriched_folders
.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
enriched_folders.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
}
"name_desc" => {
enriched_files.sort_by(|a, b| b.name.to_lowercase().cmp(&a.name.to_lowercase()));
enriched_folders
.sort_by(|a, b| b.name.to_lowercase().cmp(&a.name.to_lowercase()));
enriched_folders.sort_by(|a, b| b.name.to_lowercase().cmp(&a.name.to_lowercase()));
}
"date" => {
enriched_files.sort_by(|a, b| a.modified_at.cmp(&b.modified_at));