init

libertas_api/src/services/album_service.rs

@@ -0,0 +1,113 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use chrono::Utc;
+use libertas_core::{
+    error::{CoreError, CoreResult},
+    models::Album,
+    repositories::{AlbumRepository, MediaRepository},
+    schema::{AddMediaToAlbumData, CreateAlbumData, ShareAlbumData},
+    services::AlbumService,
+};
+use uuid::Uuid;
+
+pub struct AlbumServiceImpl {
+    album_repo: Arc<dyn AlbumRepository>,
+    media_repo: Arc<dyn MediaRepository>,
+}
+
+impl AlbumServiceImpl {
+    pub fn new(album_repo: Arc<dyn AlbumRepository>, media_repo: Arc<dyn MediaRepository>) -> Self {
+        Self {
+            album_repo,
+            media_repo,
+        }
+    }
+
+    async fn is_album_owner(&self, user_id: Uuid, album_id: Uuid) -> CoreResult<bool> {
+        let album = self
+            .album_repo
+            .find_by_id(album_id)
+            .await?
+            .ok_or(CoreError::NotFound("Album".to_string(), album_id))?;
+
+        Ok(album.owner_id == user_id)
+    }
+}
+
+#[async_trait]
+impl AlbumService for AlbumServiceImpl {
+    async fn create_album(&self, data: CreateAlbumData<'_>) -> CoreResult<()> {
+        if data.name.is_empty() {
+            return Err(CoreError::Validation(
+                "Album name cannot be empty".to_string(),
+            ));
+        }
+
+        let now = Utc::now();
+        let album = Album {
+            id: Uuid::new_v4(),
+            owner_id: data.owner_id,
+            name: data.name.to_string(),
+            description: data.description.map(String::from),
+            is_public: data.is_public,
+            created_at: now,
+            updated_at: now,
+        };
+
+        self.album_repo.create(album).await
+    }
+
+    async fn get_album_details(&self, album_id: Uuid, user_id: Uuid) -> CoreResult<Album> {
+        let album = self
+            .album_repo
+            .find_by_id(album_id)
+            .await?
+            .ok_or(CoreError::NotFound("Album".to_string(), album_id))?;
+
+        // Security check: Only owner (for now) can see album details
+        if album.owner_id != user_id {
+            // Later, this would also check share permissions
+            return Err(CoreError::Auth("Access denied to album".to_string()));
+        }
+
+        Ok(album)
+    }
+
+    async fn add_media_to_album(&self, data: AddMediaToAlbumData, user_id: Uuid) -> CoreResult<()> {
+        // 1. Verify the user owns the album
+        if !self.is_album_owner(user_id, data.album_id).await? {
+            return Err(CoreError::Auth("User does not own this album".to_string()));
+        }
+
+        // 2. Bonus: Verify the user owns all media items
+        for media_id in &data.media_ids {
+            let media = self
+                .media_repo
+                .find_by_id(*media_id)
+                .await?
+                .ok_or(CoreError::NotFound("Media".to_string(), *media_id))?;
+
+            if media.owner_id != user_id {
+                return Err(CoreError::Auth(format!(
+                    "Access denied to media item {}",
+                    media_id
+                )));
+            }
+        }
+
+        // 3. Call the repository to add them
+        self.album_repo
+            .add_media_to_album(data.album_id, &data.media_ids)
+            .await
+    }
+
+    async fn list_user_albums(&self, user_id: Uuid) -> CoreResult<Vec<Album>> {
+        self.album_repo.list_by_user(user_id).await
+    }
+
+    async fn share_album(&self, _data: ShareAlbumData, _owner_id: Uuid) -> CoreResult<()> {
+        // This is not part of the MVP, but part of the trait
+        unimplemented!("Sharing will be implemented in a future phase")
+    }
+}