adding card dav and cald dav

src/application/services/calendar_service.rs

@@ -0,0 +1,329 @@
+use std::sync::Arc;
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use uuid::Uuid;
+
+use crate::application::dtos::calendar_dto::{
+    CalendarDto, CalendarEventDto, CreateCalendarDto, UpdateCalendarDto,
+    CreateEventDto, UpdateEventDto, CreateEventICalDto
+};
+use crate::application::ports::calendar_ports::{CalendarStoragePort, CalendarUseCase};
+use crate::interfaces::middleware::auth::CurrentUser;
+use crate::common::errors::{DomainError, ErrorKind};
+
+pub struct CalendarService {
+    calendar_storage: Arc<dyn CalendarStoragePort>,
+}
+
+impl CalendarService {
+    pub fn new(calendar_storage: Arc<dyn CalendarStoragePort>) -> Self {
+        Self {
+            calendar_storage,
+        }
+    }
+}
+
+#[async_trait]
+impl CalendarUseCase for CalendarService {
+    async fn create_calendar(&self, calendar: CreateCalendarDto) -> Result<CalendarDto, DomainError> {
+        // This function requires the current user context which will come from middleware
+        // For now, we'll use a dummy implementation that needs to be completed
+        
+        // In a real implementation, get user_id from current user context
+        let user_id = "current_user_id";  // This should come from middleware
+        
+        self.calendar_storage.create_calendar(calendar, user_id).await
+    }
+    
+    async fn update_calendar(&self, calendar_id: &str, update: UpdateCalendarDto) -> Result<CalendarDto, DomainError> {
+        // In a real implementation, we would:
+        // 1. Get the current user ID from middleware
+        // 2. Verify that the user has access to this calendar
+        // 3. Update the calendar if they have permission
+        
+        let user_id = "current_user_id";  // This should come from middleware
+        
+        // Check if user has access
+        let has_access = self.calendar_storage.check_calendar_access(calendar_id, user_id).await?;
+        
+        if !has_access {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Calendar",
+                "You don't have permission to update this calendar"
+            ));
+        }
+        
+        self.calendar_storage.update_calendar(calendar_id, update).await
+    }
+    
+    async fn delete_calendar(&self, calendar_id: &str) -> Result<(), DomainError> {
+        let user_id = "current_user_id";  // This should come from middleware
+        
+        // Check if user has access
+        let has_access = self.calendar_storage.check_calendar_access(calendar_id, user_id).await?;
+        
+        if !has_access {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Calendar",
+                "You don't have permission to delete this calendar"
+            ));
+        }
+        
+        self.calendar_storage.delete_calendar(calendar_id).await
+    }
+    
+    async fn get_calendar(&self, calendar_id: &str) -> Result<CalendarDto, DomainError> {
+        let user_id = "current_user_id";  // This should come from middleware
+        
+        // Get the calendar
+        let calendar = self.calendar_storage.get_calendar(calendar_id).await?;
+        
+        // Check if user has access or if calendar is public
+        let has_access = self.calendar_storage.check_calendar_access(calendar_id, user_id).await?;
+        
+        if !has_access && !calendar.is_public {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Calendar",
+                "You don't have permission to view this calendar"
+            ));
+        }
+        
+        Ok(calendar)
+    }
+    
+    async fn list_my_calendars(&self) -> Result<Vec<CalendarDto>, DomainError> {
+        let user_id = "current_user_id";  // This should come from middleware
+        
+        self.calendar_storage.list_calendars_by_owner(user_id).await
+    }
+    
+    async fn list_shared_calendars(&self) -> Result<Vec<CalendarDto>, DomainError> {
+        let user_id = "current_user_id";  // This should come from middleware
+        
+        self.calendar_storage.list_calendars_shared_with_user(user_id).await
+    }
+    
+    async fn list_public_calendars(&self, limit: Option<i64>, offset: Option<i64>) -> Result<Vec<CalendarDto>, DomainError> {
+        let limit = limit.unwrap_or(100);
+        let offset = offset.unwrap_or(0);
+        
+        self.calendar_storage.list_public_calendars(limit, offset).await
+    }
+    
+    async fn share_calendar(&self, calendar_id: &str, user_id: &str, access_level: &str) -> Result<(), DomainError> {
+        let current_user_id = "current_user_id";  // This should come from middleware
+        
+        // Check if current user has access
+        let calendar = self.calendar_storage.get_calendar(calendar_id).await?;
+        
+        // Only the owner can share the calendar
+        if calendar.owner_id != current_user_id {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Calendar",
+                "Only the calendar owner can change sharing settings"
+            ));
+        }
+        
+        // Validate access_level
+        match access_level {
+            "read" | "write" | "owner" => {},
+            _ => return Err(DomainError::new(
+                ErrorKind::InvalidInput,
+                "Calendar",
+                format!("Invalid access level: {}. Valid values are: read, write, owner", access_level)
+            )),
+        }
+        
+        self.calendar_storage.share_calendar(calendar_id, user_id, access_level).await
+    }
+    
+    async fn remove_calendar_sharing(&self, calendar_id: &str, user_id: &str) -> Result<(), DomainError> {
+        let current_user_id = "current_user_id";  // This should come from middleware
+        
+        // Check if current user has access
+        let calendar = self.calendar_storage.get_calendar(calendar_id).await?;
+        
+        // Only the owner can change sharing settings
+        if calendar.owner_id != current_user_id {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Calendar",
+                "Only the calendar owner can change sharing settings"
+            ));
+        }
+        
+        self.calendar_storage.remove_calendar_sharing(calendar_id, user_id).await
+    }
+    
+    async fn get_calendar_shares(&self, calendar_id: &str) -> Result<Vec<(String, String)>, DomainError> {
+        let current_user_id = "current_user_id";  // This should come from middleware
+        
+        // Check if current user has access
+        let calendar = self.calendar_storage.get_calendar(calendar_id).await?;
+        
+        // Only the owner can view sharing settings
+        if calendar.owner_id != current_user_id {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Calendar",
+                "Only the calendar owner can view sharing settings"
+            ));
+        }
+        
+        self.calendar_storage.get_calendar_shares(calendar_id).await
+    }
+    
+    async fn create_event(&self, event: CreateEventDto) -> Result<CalendarEventDto, DomainError> {
+        let user_id = "current_user_id";  // This should come from middleware
+        
+        // Check if user has access to the calendar
+        let has_access = self.calendar_storage.check_calendar_access(&event.calendar_id, user_id).await?;
+        
+        if !has_access {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Calendar",
+                "You don't have permission to add events to this calendar"
+            ));
+        }
+        
+        self.calendar_storage.create_event(event).await
+    }
+    
+    async fn create_event_from_ical(&self, event: CreateEventICalDto) -> Result<CalendarEventDto, DomainError> {
+        let user_id = "current_user_id";  // This should come from middleware
+        
+        // Check if user has access to the calendar
+        let has_access = self.calendar_storage.check_calendar_access(&event.calendar_id, user_id).await?;
+        
+        if !has_access {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Calendar",
+                "You don't have permission to add events to this calendar"
+            ));
+        }
+        
+        self.calendar_storage.create_event_from_ical(event).await
+    }
+    
+    async fn update_event(&self, event_id: &str, update: UpdateEventDto) -> Result<CalendarEventDto, DomainError> {
+        let user_id = "current_user_id";  // This should come from middleware
+        
+        // Get the event to find its calendar
+        let event = self.calendar_storage.get_event(event_id).await?;
+        
+        // Check if user has access to the calendar
+        let has_access = self.calendar_storage.check_calendar_access(&event.calendar_id, user_id).await?;
+        
+        if !has_access {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Calendar",
+                "You don't have permission to update events in this calendar"
+            ));
+        }
+        
+        self.calendar_storage.update_event(event_id, update).await
+    }
+    
+    async fn delete_event(&self, event_id: &str) -> Result<(), DomainError> {
+        let user_id = "current_user_id";  // This should come from middleware
+        
+        // Get the event to find its calendar
+        let event = self.calendar_storage.get_event(event_id).await?;
+        
+        // Check if user has access to the calendar
+        let has_access = self.calendar_storage.check_calendar_access(&event.calendar_id, user_id).await?;
+        
+        if !has_access {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Calendar",
+                "You don't have permission to delete events in this calendar"
+            ));
+        }
+        
+        self.calendar_storage.delete_event(event_id).await
+    }
+    
+    async fn get_event(&self, event_id: &str) -> Result<CalendarEventDto, DomainError> {
+        let user_id = "current_user_id";  // This should come from middleware
+        
+        // Get the event
+        let event = self.calendar_storage.get_event(event_id).await?;
+        
+        // Check if user has access to the calendar
+        let has_access = self.calendar_storage.check_calendar_access(&event.calendar_id, user_id).await?;
+        
+        // Check if calendar is public
+        let calendar = self.calendar_storage.get_calendar(&event.calendar_id).await?;
+        
+        if !has_access && !calendar.is_public {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Calendar",
+                "You don't have permission to view events in this calendar"
+            ));
+        }
+        
+        Ok(event)
+    }
+    
+    async fn list_events(&self, calendar_id: &str, limit: Option<i64>, offset: Option<i64>) -> Result<Vec<CalendarEventDto>, DomainError> {
+        let user_id = "current_user_id";  // This should come from middleware
+        
+        // Check if user has access to the calendar
+        let has_access = self.calendar_storage.check_calendar_access(calendar_id, user_id).await?;
+        
+        // Check if calendar is public
+        let calendar = self.calendar_storage.get_calendar(calendar_id).await?;
+        
+        if !has_access && !calendar.is_public {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Calendar",
+                "You don't have permission to view events in this calendar"
+            ));
+        }
+        
+        // Use pagination if provided
+        if limit.is_some() || offset.is_some() {
+            let limit = limit.unwrap_or(100);
+            let offset = offset.unwrap_or(0);
+            
+            self.calendar_storage.list_events_by_calendar_paginated(calendar_id, limit, offset).await
+        } else {
+            self.calendar_storage.list_events_by_calendar(calendar_id).await
+        }
+    }
+    
+    async fn get_events_in_range(
+        &self, 
+        calendar_id: &str, 
+        start: DateTime<Utc>, 
+        end: DateTime<Utc>
+    ) -> Result<Vec<CalendarEventDto>, DomainError> {
+        let user_id = "current_user_id";  // This should come from middleware
+        
+        // Check if user has access to the calendar
+        let has_access = self.calendar_storage.check_calendar_access(calendar_id, user_id).await?;
+        
+        // Check if calendar is public
+        let calendar = self.calendar_storage.get_calendar(calendar_id).await?;
+        
+        if !has_access && !calendar.is_public {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Calendar",
+                "You don't have permission to view events in this calendar"
+            ));
+        }
+        
+        self.calendar_storage.get_events_in_time_range(calendar_id, &start, &end).await
+    }
+}

src/application/services/file_service.rs

@@ -87,7 +87,7 @@ impl From<FileServiceError> for DomainError {
         match err {
             FileServiceError::NotFound(id) => DomainError::not_found("File", id),
             FileServiceError::Conflict(path) => DomainError::already_exists("File", path),
-            FileServiceError::InvalidPath(path) => DomainError::validation_error("File", format!("Invalid path: {}", path)),
+            FileServiceError::InvalidPath(path) => DomainError::validation_error(format!("Invalid path: {}", path)),
             FileServiceError::AccessError(msg) => DomainError::access_denied("File", msg),
             FileServiceError::InternalError(msg) => DomainError::internal_error("File", msg),
         }

src/application/services/mod.rs

@@ -1,21 +1,21 @@
+pub mod auth_application_service;
 pub mod batch_operations;
+pub mod calendar_service;
+pub mod contact_service;
+pub mod favorites_service;
+pub mod file_management_service;
+pub mod file_retrieval_service;
 pub mod file_service;
+pub mod file_upload_service;
+pub mod file_use_case_factory;
 pub mod folder_service;
 pub mod i18n_application_service;
-pub mod storage_mediator;
-
-// Nuevos servicios refactorizados
-pub mod file_upload_service;
-pub mod file_retrieval_service;
-pub mod file_management_service;
-pub mod file_use_case_factory;
-pub mod auth_application_service;
-pub mod trash_service;
+pub mod recent_service;
 pub mod search_service;
 pub mod share_service;
-pub mod favorites_service;
-pub mod recent_service;
+pub mod storage_mediator;
 pub mod storage_usage_service;
+pub mod trash_service;
 
 #[cfg(test)]
 mod trash_service_test;

src/application/services/share_service.rs

@@ -47,8 +47,8 @@ impl From<ShareServiceError> for DomainError {
             ShareServiceError::InvalidPassword(s) => DomainError::access_denied("Share", s),
             ShareServiceError::Expired => DomainError::access_denied("Share", "Share has expired".to_string()),
             ShareServiceError::Repository(s) => DomainError::internal_error("Share", s),
-            ShareServiceError::InvalidItemType(s) => DomainError::validation_error("Share", s),
-            ShareServiceError::Validation(s) => DomainError::validation_error("Share", s),
+            ShareServiceError::InvalidItemType(s) => DomainError::validation_error(s),
+            ShareServiceError::Validation(s) => DomainError::validation_error(s),
         }
     }
 }

src/application/services/trash_service.rs

@@ -89,7 +89,7 @@ impl TrashUseCase for TrashService {
         debug!("Getting trash items for user: {}", user_id);
         
         let user_uuid = Uuid::parse_str(user_id)
-            .map_err(|e| DomainError::validation_error("User", format!("Invalid user ID: {}", e)))?;
+            .map_err(|e| DomainError::validation_error(format!("Invalid user ID: {}", e)))?;
             
         let items = self.trash_repository.get_trash_items(&user_uuid).await?;
         
@@ -119,7 +119,7 @@ impl TrashUseCase for TrashService {
             },
             Err(e) => {
                 error!("Invalid item UUID: {} - Error: {}", item_id, e);
-                return Err(DomainError::validation_error("Item", format!("Invalid item ID: {}", e)));
+                return Err(DomainError::validation_error(format!("Invalid item ID: {}", e)));
             }
         };
         
@@ -131,7 +131,7 @@ impl TrashUseCase for TrashService {
             },
             Err(e) => {
                 error!("Invalid user UUID: {} - Error: {}", user_id, e);
-                return Err(DomainError::validation_error("User", format!("Invalid user ID: {}", e)));
+                return Err(DomainError::validation_error(format!("Invalid user ID: {}", e)));
             }
         };
         
@@ -244,7 +244,7 @@ impl TrashUseCase for TrashService {
                 debug!("Folder moved to trash: {}", item_id);
                 Ok(())
             },
-            _ => Err(DomainError::validation_error("Item", format!("Invalid item type: {}", item_type))),
+            _ => Err(DomainError::validation_error(format!("Invalid item type: {}", item_type))),
         }
     }
 
@@ -259,7 +259,7 @@ impl TrashUseCase for TrashService {
             },
             Err(e) => {
                 error!("Invalid trash ID format: {} - {}", trash_id, e);
-                return Err(DomainError::validation_error("Trash", format!("Invalid trash ID: {}", e)));
+                return Err(DomainError::validation_error(format!("Invalid trash ID: {}", e)));
             }
         };
             
@@ -270,7 +270,7 @@ impl TrashUseCase for TrashService {
             },
             Err(e) => {
                 error!("Invalid user ID format: {} - {}", user_id, e);
-                return Err(DomainError::validation_error("User", format!("Invalid user ID: {}", e)));
+                return Err(DomainError::validation_error(format!("Invalid user ID: {}", e)));
             }
         };
         
@@ -384,7 +384,7 @@ impl TrashUseCase for TrashService {
             },
             Err(e) => {
                 error!("Invalid trash ID format: {} - {}", trash_id, e);
-                return Err(DomainError::validation_error("Trash", format!("Invalid trash ID: {}", e)));
+                return Err(DomainError::validation_error(format!("Invalid trash ID: {}", e)));
             }
         };
             
@@ -395,7 +395,7 @@ impl TrashUseCase for TrashService {
             },
             Err(e) => {
                 error!("Invalid user ID format: {} - {}", user_id, e);
-                return Err(DomainError::validation_error("User", format!("Invalid user ID: {}", e)));
+                return Err(DomainError::validation_error(format!("Invalid user ID: {}", e)));
             }
         };
         
@@ -500,7 +500,7 @@ impl TrashUseCase for TrashService {
         info!("Emptying trash for user {}", user_id);
         
         let user_uuid = Uuid::parse_str(user_id)
-            .map_err(|e| DomainError::validation_error("User", format!("Invalid user ID: {}", e)))?;
+            .map_err(|e| DomainError::validation_error(format!("Invalid user ID: {}", e)))?;
         
         // Get all items in the user's trash
         let items = self.trash_repository.get_trash_items(&user_uuid).await?;