Diocrafts
753 lines
21 KiB
Rust
753 lines
21 KiB
Rust
//! Stub/Dummy implementations for dependency injection.
|
|
//!
|
|
//! These no-op implementations are used exclusively by `AppState::default()`
|
|
//! to provide a minimal, valid state for the auth middleware and route
|
|
//! construction before the real services are wired in `main.rs`.
|
|
//!
|
|
//! **None of these stubs should ever handle real user requests.**
|
|
|
|
use std::path::{Path, PathBuf};
|
|
use std::sync::Arc;
|
|
|
|
use async_trait::async_trait;
|
|
use bytes::Bytes;
|
|
use futures::Stream;
|
|
|
|
use crate::application::dtos::file_dto::FileDto;
|
|
use crate::application::dtos::folder_dto::{CreateFolderDto, FolderDto, MoveFolderDto, RenameFolderDto};
|
|
use crate::application::dtos::pagination::{PaginatedResponseDto, PaginationRequestDto};
|
|
use crate::application::dtos::search_dto::{SearchCriteriaDto, SearchResultsDto};
|
|
use crate::application::ports::compression_ports::{CompressionLevel, CompressionPort};
|
|
use crate::application::ports::file_ports::{
|
|
FileManagementUseCase, FileRetrievalUseCase, FileUploadUseCase, FileUseCaseFactory,
|
|
UploadStrategy, OptimizedFileContent,
|
|
};
|
|
use crate::application::ports::inbound::{FolderUseCase, SearchUseCase};
|
|
use crate::application::ports::outbound::IdMappingPort;
|
|
use crate::domain::repositories::folder_repository::FolderRepository;
|
|
use crate::application::ports::storage_ports::{FileReadPort, FileWritePort};
|
|
use crate::application::ports::zip_ports::ZipPort;
|
|
use crate::application::services::storage_mediator::{StorageMediator, StorageMediatorError};
|
|
use crate::common::errors::DomainError;
|
|
use crate::domain::entities::file::File;
|
|
use crate::domain::entities::folder::Folder;
|
|
use crate::domain::services::i18n_service::{I18nResult, I18nService, Locale};
|
|
use crate::domain::services::path_service::StoragePath;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ZipPort
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Placeholder ZipPort that always errors. Replaced after application services
|
|
/// are fully initialised.
|
|
pub struct StubZipPort;
|
|
|
|
#[async_trait]
|
|
impl ZipPort for StubZipPort {
|
|
async fn create_folder_zip(
|
|
&self,
|
|
_folder_id: &str,
|
|
_folder_name: &str,
|
|
) -> Result<Vec<u8>, DomainError> {
|
|
Err(DomainError::internal_error(
|
|
"ZipService",
|
|
"ZipService not initialized",
|
|
))
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// CompressionPort
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct StubCompressionPort;
|
|
|
|
#[async_trait]
|
|
impl CompressionPort for StubCompressionPort {
|
|
async fn compress_data(
|
|
&self,
|
|
_data: &[u8],
|
|
_level: CompressionLevel,
|
|
) -> Result<Vec<u8>, DomainError> {
|
|
Ok(Vec::new())
|
|
}
|
|
|
|
async fn decompress_data(&self, _compressed_data: &[u8]) -> Result<Vec<u8>, DomainError> {
|
|
Ok(Vec::new())
|
|
}
|
|
|
|
fn should_compress(&self, _mime_type: &str, _size: u64) -> bool {
|
|
false
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// IdMappingPort
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct StubIdMappingService;
|
|
|
|
#[async_trait]
|
|
impl IdMappingPort for StubIdMappingService {
|
|
async fn get_or_create_id(
|
|
&self,
|
|
_path: &StoragePath,
|
|
) -> Result<String, DomainError> {
|
|
Ok("dummy-id".to_string())
|
|
}
|
|
|
|
async fn get_path_by_id(&self, _id: &str) -> Result<StoragePath, DomainError> {
|
|
Ok(StoragePath::from_string("/"))
|
|
}
|
|
|
|
async fn update_path(
|
|
&self,
|
|
_id: &str,
|
|
_new_path: &StoragePath,
|
|
) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
|
|
async fn remove_id(&self, _id: &str) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
|
|
async fn save_changes(&self) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// StorageMediator
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct StubStorageMediator;
|
|
|
|
#[async_trait]
|
|
impl StorageMediator for StubStorageMediator {
|
|
async fn get_folder_path(
|
|
&self,
|
|
_folder_id: &str,
|
|
) -> Result<PathBuf, StorageMediatorError> {
|
|
Ok(PathBuf::from("/tmp"))
|
|
}
|
|
|
|
async fn get_folder_storage_path(
|
|
&self,
|
|
_folder_id: &str,
|
|
) -> Result<StoragePath, StorageMediatorError> {
|
|
Ok(StoragePath::root())
|
|
}
|
|
|
|
async fn get_folder(
|
|
&self,
|
|
_folder_id: &str,
|
|
) -> Result<Folder, StorageMediatorError> {
|
|
Err(StorageMediatorError::NotFound(
|
|
"Stub not implemented".to_string(),
|
|
))
|
|
}
|
|
|
|
async fn file_exists_at_path(
|
|
&self,
|
|
_path: &Path,
|
|
) -> Result<bool, StorageMediatorError> {
|
|
Ok(false)
|
|
}
|
|
|
|
async fn file_exists_at_storage_path(
|
|
&self,
|
|
_storage_path: &StoragePath,
|
|
) -> Result<bool, StorageMediatorError> {
|
|
Ok(false)
|
|
}
|
|
|
|
async fn folder_exists_at_path(
|
|
&self,
|
|
_path: &Path,
|
|
) -> Result<bool, StorageMediatorError> {
|
|
Ok(false)
|
|
}
|
|
|
|
async fn folder_exists_at_storage_path(
|
|
&self,
|
|
_storage_path: &StoragePath,
|
|
) -> Result<bool, StorageMediatorError> {
|
|
Ok(false)
|
|
}
|
|
|
|
fn resolve_path(&self, _relative_path: &Path) -> PathBuf {
|
|
PathBuf::from("/tmp")
|
|
}
|
|
|
|
fn resolve_storage_path(&self, _storage_path: &StoragePath) -> PathBuf {
|
|
PathBuf::from("/tmp")
|
|
}
|
|
|
|
async fn ensure_directory(
|
|
&self,
|
|
_path: &Path,
|
|
) -> Result<(), StorageMediatorError> {
|
|
Ok(())
|
|
}
|
|
|
|
async fn ensure_storage_directory(
|
|
&self,
|
|
_storage_path: &StoragePath,
|
|
) -> Result<(), StorageMediatorError> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// IdMappingPort
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct StubIdMappingPort;
|
|
|
|
#[async_trait]
|
|
impl IdMappingPort for StubIdMappingPort {
|
|
async fn get_or_create_id(&self, _path: &StoragePath) -> Result<String, DomainError> {
|
|
Ok("stub-id".to_string())
|
|
}
|
|
async fn get_path_by_id(&self, _id: &str) -> Result<StoragePath, DomainError> {
|
|
Ok(StoragePath::from_string("/"))
|
|
}
|
|
async fn update_path(&self, _id: &str, _new_path: &StoragePath) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
async fn remove_id(&self, _id: &str) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
async fn save_changes(&self) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// FileReadPort
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct StubFileReadPort;
|
|
|
|
#[async_trait]
|
|
impl FileReadPort for StubFileReadPort {
|
|
async fn get_file(&self, _id: &str) -> Result<File, DomainError> {
|
|
Ok(File::default())
|
|
}
|
|
|
|
async fn list_files(
|
|
&self,
|
|
_folder_id: Option<&str>,
|
|
) -> Result<Vec<File>, DomainError> {
|
|
Ok(Vec::new())
|
|
}
|
|
|
|
async fn get_file_content(&self, _id: &str) -> Result<Vec<u8>, DomainError> {
|
|
Ok(Vec::new())
|
|
}
|
|
|
|
async fn get_file_stream(
|
|
&self,
|
|
_id: &str,
|
|
) -> Result<Box<dyn Stream<Item = Result<Bytes, std::io::Error>> + Send>, DomainError> {
|
|
let empty_stream = futures::stream::empty::<Result<Bytes, std::io::Error>>();
|
|
Ok(Box::new(empty_stream))
|
|
}
|
|
|
|
async fn get_file_range_stream(
|
|
&self,
|
|
_id: &str,
|
|
_start: u64,
|
|
_end: Option<u64>,
|
|
) -> Result<Box<dyn Stream<Item = Result<Bytes, std::io::Error>> + Send>, DomainError> {
|
|
let empty_stream = futures::stream::empty::<Result<Bytes, std::io::Error>>();
|
|
Ok(Box::new(empty_stream))
|
|
}
|
|
|
|
async fn get_file_mmap(&self, _id: &str) -> Result<Bytes, DomainError> {
|
|
Ok(Bytes::new())
|
|
}
|
|
|
|
async fn get_file_path(&self, _id: &str) -> Result<StoragePath, DomainError> {
|
|
Ok(StoragePath::from_string("/"))
|
|
}
|
|
|
|
async fn get_parent_folder_id(&self, _path: &str) -> Result<String, DomainError> {
|
|
Ok("root".to_string())
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// FileWritePort
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct StubFileWritePort;
|
|
|
|
#[async_trait]
|
|
impl FileWritePort for StubFileWritePort {
|
|
async fn save_file(
|
|
&self,
|
|
_name: String,
|
|
_folder_id: Option<String>,
|
|
_content_type: String,
|
|
_content: Vec<u8>,
|
|
) -> Result<File, DomainError> {
|
|
Ok(File::default())
|
|
}
|
|
|
|
async fn save_file_from_stream(
|
|
&self,
|
|
_name: String,
|
|
_folder_id: Option<String>,
|
|
_content_type: String,
|
|
_stream: std::pin::Pin<Box<dyn Stream<Item = Result<Bytes, std::io::Error>> + Send>>,
|
|
) -> Result<File, DomainError> {
|
|
Ok(File::default())
|
|
}
|
|
|
|
async fn move_file(
|
|
&self,
|
|
_file_id: &str,
|
|
_target_folder_id: Option<String>,
|
|
) -> Result<File, DomainError> {
|
|
Ok(File::default())
|
|
}
|
|
|
|
async fn delete_file(&self, _id: &str) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
|
|
async fn update_file_content(
|
|
&self,
|
|
_file_id: &str,
|
|
_content: Vec<u8>,
|
|
) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
|
|
async fn register_file_deferred(
|
|
&self,
|
|
_name: String,
|
|
_folder_id: Option<String>,
|
|
_content_type: String,
|
|
_size: u64,
|
|
) -> Result<(File, PathBuf), DomainError> {
|
|
Ok((File::default(), PathBuf::from("/tmp/dummy")))
|
|
}
|
|
|
|
async fn move_to_trash(&self, _file_id: &str) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
|
|
async fn restore_from_trash(&self, _file_id: &str, _original_path: &str) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
|
|
async fn delete_file_permanently(&self, _file_id: &str) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// FolderStoragePort
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct StubFolderStoragePort;
|
|
|
|
#[async_trait]
|
|
impl FolderRepository for StubFolderStoragePort {
|
|
async fn create_folder(
|
|
&self,
|
|
_name: String,
|
|
_parent_id: Option<String>,
|
|
) -> Result<Folder, DomainError> {
|
|
Ok(Folder::default())
|
|
}
|
|
|
|
async fn get_folder(&self, _id: &str) -> Result<Folder, DomainError> {
|
|
Ok(Folder::default())
|
|
}
|
|
|
|
async fn get_folder_by_path(
|
|
&self,
|
|
_storage_path: &StoragePath,
|
|
) -> Result<Folder, DomainError> {
|
|
Ok(Folder::default())
|
|
}
|
|
|
|
async fn list_folders(
|
|
&self,
|
|
_parent_id: Option<&str>,
|
|
) -> Result<Vec<Folder>, DomainError> {
|
|
Ok(Vec::new())
|
|
}
|
|
|
|
async fn list_folders_paginated(
|
|
&self,
|
|
_parent_id: Option<&str>,
|
|
_offset: usize,
|
|
_limit: usize,
|
|
_include_total: bool,
|
|
) -> Result<(Vec<Folder>, Option<usize>), DomainError> {
|
|
Ok((Vec::new(), Some(0)))
|
|
}
|
|
|
|
async fn rename_folder(
|
|
&self,
|
|
_id: &str,
|
|
_new_name: String,
|
|
) -> Result<Folder, DomainError> {
|
|
Ok(Folder::default())
|
|
}
|
|
|
|
async fn move_folder(
|
|
&self,
|
|
_id: &str,
|
|
_new_parent_id: Option<&str>,
|
|
) -> Result<Folder, DomainError> {
|
|
Ok(Folder::default())
|
|
}
|
|
|
|
async fn delete_folder(&self, _id: &str) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
|
|
async fn folder_exists(
|
|
&self,
|
|
_storage_path: &StoragePath,
|
|
) -> Result<bool, DomainError> {
|
|
Ok(false)
|
|
}
|
|
|
|
async fn get_folder_path(
|
|
&self,
|
|
_id: &str,
|
|
) -> Result<StoragePath, DomainError> {
|
|
Ok(StoragePath::from_string("/"))
|
|
}
|
|
|
|
async fn move_to_trash(&self, _folder_id: &str) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
|
|
async fn restore_from_trash(&self, _folder_id: &str, _original_path: &str) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
|
|
async fn delete_folder_permanently(&self, _folder_id: &str) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// I18nService
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct StubI18nService;
|
|
|
|
#[async_trait]
|
|
impl I18nService for StubI18nService {
|
|
async fn translate(&self, _key: &str, _locale: Locale) -> I18nResult<String> {
|
|
Ok(String::new())
|
|
}
|
|
|
|
async fn load_translations(&self, _locale: Locale) -> I18nResult<()> {
|
|
Ok(())
|
|
}
|
|
|
|
async fn available_locales(&self) -> Vec<Locale> {
|
|
vec![Locale::default()]
|
|
}
|
|
|
|
async fn is_supported(&self, _locale: Locale) -> bool {
|
|
true
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// FolderUseCase
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct StubFolderUseCase;
|
|
|
|
#[async_trait]
|
|
impl FolderUseCase for StubFolderUseCase {
|
|
async fn create_folder(
|
|
&self,
|
|
_dto: CreateFolderDto,
|
|
) -> Result<FolderDto, DomainError> {
|
|
Ok(FolderDto::default())
|
|
}
|
|
|
|
async fn get_folder(&self, _id: &str) -> Result<FolderDto, DomainError> {
|
|
Ok(FolderDto::default())
|
|
}
|
|
|
|
async fn get_folder_by_path(
|
|
&self,
|
|
_path: &str,
|
|
) -> Result<FolderDto, DomainError> {
|
|
Ok(FolderDto::default())
|
|
}
|
|
|
|
async fn list_folders(
|
|
&self,
|
|
_parent_id: Option<&str>,
|
|
) -> Result<Vec<FolderDto>, DomainError> {
|
|
Ok(Vec::new())
|
|
}
|
|
|
|
async fn list_folders_paginated(
|
|
&self,
|
|
_parent_id: Option<&str>,
|
|
_pagination: &PaginationRequestDto,
|
|
) -> Result<PaginatedResponseDto<FolderDto>, DomainError> {
|
|
Ok(PaginatedResponseDto::new(Vec::new(), 0, 10, 0))
|
|
}
|
|
|
|
async fn rename_folder(
|
|
&self,
|
|
_id: &str,
|
|
_dto: RenameFolderDto,
|
|
) -> Result<FolderDto, DomainError> {
|
|
Ok(FolderDto::default())
|
|
}
|
|
|
|
async fn move_folder(
|
|
&self,
|
|
_id: &str,
|
|
_dto: MoveFolderDto,
|
|
) -> Result<FolderDto, DomainError> {
|
|
Ok(FolderDto::default())
|
|
}
|
|
|
|
async fn delete_folder(&self, _id: &str) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// FileUploadUseCase
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct StubFileUploadUseCase;
|
|
|
|
#[async_trait]
|
|
impl FileUploadUseCase for StubFileUploadUseCase {
|
|
async fn upload_file(
|
|
&self,
|
|
_name: String,
|
|
_folder_id: Option<String>,
|
|
_content_type: String,
|
|
_content: Vec<u8>,
|
|
) -> Result<FileDto, DomainError> {
|
|
Ok(FileDto::default())
|
|
}
|
|
|
|
async fn smart_upload(
|
|
&self,
|
|
_name: String,
|
|
_folder_id: Option<String>,
|
|
_content_type: String,
|
|
_chunks: Vec<Bytes>,
|
|
_total_size: usize,
|
|
) -> Result<(FileDto, UploadStrategy), DomainError> {
|
|
Ok((FileDto::default(), UploadStrategy::Buffered))
|
|
}
|
|
|
|
async fn create_file(&self, _parent_path: &str, _filename: &str, _content: &[u8], _content_type: &str) -> Result<FileDto, DomainError> {
|
|
Ok(FileDto::default())
|
|
}
|
|
|
|
async fn update_file(&self, _path: &str, _content: &[u8]) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// FileRetrievalUseCase
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct StubFileRetrievalUseCase;
|
|
|
|
#[async_trait]
|
|
impl FileRetrievalUseCase for StubFileRetrievalUseCase {
|
|
async fn get_file(&self, _id: &str) -> Result<FileDto, DomainError> {
|
|
Ok(FileDto::default())
|
|
}
|
|
|
|
async fn list_files(
|
|
&self,
|
|
_folder_id: Option<&str>,
|
|
) -> Result<Vec<FileDto>, DomainError> {
|
|
Ok(Vec::new())
|
|
}
|
|
|
|
async fn get_file_content(&self, _id: &str) -> Result<Vec<u8>, DomainError> {
|
|
Ok(Vec::new())
|
|
}
|
|
|
|
async fn get_file_stream(
|
|
&self,
|
|
_id: &str,
|
|
) -> Result<Box<dyn Stream<Item = Result<Bytes, std::io::Error>> + Send>, DomainError> {
|
|
let empty_stream = futures::stream::empty::<Result<Bytes, std::io::Error>>();
|
|
Ok(Box::new(empty_stream))
|
|
}
|
|
|
|
async fn get_file_optimized(
|
|
&self,
|
|
_id: &str,
|
|
_accept_webp: bool,
|
|
_prefer_original: bool,
|
|
) -> Result<(FileDto, OptimizedFileContent), DomainError> {
|
|
Ok((FileDto::default(), OptimizedFileContent::Bytes {
|
|
data: Bytes::new(),
|
|
mime_type: String::new(),
|
|
was_transcoded: false,
|
|
}))
|
|
}
|
|
|
|
async fn get_file_range_stream(
|
|
&self,
|
|
_id: &str,
|
|
_start: u64,
|
|
_end: Option<u64>,
|
|
) -> Result<Box<dyn Stream<Item = Result<Bytes, std::io::Error>> + Send>, DomainError> {
|
|
let empty_stream = futures::stream::empty::<Result<Bytes, std::io::Error>>();
|
|
Ok(Box::new(empty_stream))
|
|
}
|
|
|
|
async fn get_file_by_path(&self, _path: &str) -> Result<FileDto, DomainError> {
|
|
Err(DomainError::not_found("File", "stub"))
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// FileManagementUseCase
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct StubFileManagementUseCase;
|
|
|
|
#[async_trait]
|
|
impl FileManagementUseCase for StubFileManagementUseCase {
|
|
async fn move_file(
|
|
&self,
|
|
_file_id: &str,
|
|
_folder_id: Option<String>,
|
|
) -> Result<FileDto, DomainError> {
|
|
Ok(FileDto::default())
|
|
}
|
|
|
|
async fn delete_file(&self, _id: &str) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
|
|
async fn delete_with_cleanup(
|
|
&self,
|
|
_id: &str,
|
|
_user_id: &str,
|
|
) -> Result<bool, DomainError> {
|
|
Ok(false)
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// FileUseCaseFactory
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct StubFileUseCaseFactory;
|
|
|
|
impl FileUseCaseFactory for StubFileUseCaseFactory {
|
|
fn create_file_upload_use_case(&self) -> Arc<dyn FileUploadUseCase> {
|
|
Arc::new(StubFileUploadUseCase)
|
|
}
|
|
|
|
fn create_file_retrieval_use_case(&self) -> Arc<dyn FileRetrievalUseCase> {
|
|
Arc::new(StubFileRetrievalUseCase)
|
|
}
|
|
|
|
fn create_file_management_use_case(&self) -> Arc<dyn FileManagementUseCase> {
|
|
Arc::new(StubFileManagementUseCase)
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// SearchUseCase
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct StubSearchUseCase;
|
|
|
|
#[async_trait]
|
|
impl SearchUseCase for StubSearchUseCase {
|
|
async fn search(
|
|
&self,
|
|
_criteria: SearchCriteriaDto,
|
|
) -> Result<SearchResultsDto, DomainError> {
|
|
Ok(SearchResultsDto::empty())
|
|
}
|
|
|
|
async fn clear_search_cache(&self) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// MetadataCachePort
|
|
// ---------------------------------------------------------------------------
|
|
|
|
use crate::application::ports::cache_ports::{MetadataCachePort, CachedMetadataDto, ContentCachePort};
|
|
|
|
pub struct StubMetadataCachePort;
|
|
|
|
#[async_trait]
|
|
impl MetadataCachePort for StubMetadataCachePort {
|
|
async fn get_metadata(&self, _path: &Path) -> Option<CachedMetadataDto> {
|
|
None
|
|
}
|
|
|
|
async fn is_file(&self, _path: &Path) -> Option<bool> {
|
|
None
|
|
}
|
|
|
|
async fn refresh_metadata(&self, path: &Path) -> Result<CachedMetadataDto, DomainError> {
|
|
Ok(CachedMetadataDto {
|
|
path: path.to_path_buf(),
|
|
exists: false,
|
|
is_file: false,
|
|
size: None,
|
|
mime_type: None,
|
|
created_at: None,
|
|
modified_at: None,
|
|
})
|
|
}
|
|
|
|
async fn invalidate(&self, _path: &Path) {}
|
|
|
|
async fn invalidate_directory(&self, _dir_path: &Path) {}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ContentCachePort
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct StubContentCachePort;
|
|
|
|
#[async_trait]
|
|
impl ContentCachePort for StubContentCachePort {
|
|
fn should_cache(&self, _size: usize) -> bool {
|
|
false
|
|
}
|
|
|
|
async fn get(&self, _file_id: &str) -> Option<(Bytes, String, String)> {
|
|
None
|
|
}
|
|
|
|
async fn put(&self, _file_id: String, _content: Bytes, _etag: String, _content_type: String) {}
|
|
|
|
async fn invalidate(&self, _file_id: &str) {}
|
|
|
|
async fn clear(&self) {}
|
|
}
|