feat: Add album management functionality with new data model, repository, service, API, and generation integration.

api/service/album_service.py

@@ -0,0 +1,85 @@
+from typing import List, Optional
+from models.Album import Album
+from models.Generation import Generation
+from repos.dao import DAO
+
+class AlbumService:
+    def __init__(self, dao: DAO):
+        self.dao = dao
+
+    async def create_album(self, name: str, description: Optional[str] = None) -> Album:
+        album = Album(name=name, description=description)
+        album_id = await self.dao.albums.create_album(album)
+        album.id = album_id
+        return album
+
+    async def get_albums(self, limit: int = 10, offset: int = 0) -> List[Album]:
+        return await self.dao.albums.get_albums(limit=limit, offset=offset)
+
+    async def get_album(self, album_id: str) -> Optional[Album]:
+        return await self.dao.albums.get_album(album_id)
+
+    async def update_album(self, album_id: str, name: Optional[str] = None, description: Optional[str] = None) -> Optional[Album]:
+        album = await self.dao.albums.get_album(album_id)
+        if not album:
+            return None
+        
+        if name:
+            album.name = name
+        if description is not None:
+            album.description = description
+            
+        await self.dao.albums.update_album(album_id, album)
+        return album
+
+    async def delete_album(self, album_id: str) -> bool:
+        return await self.dao.albums.delete_album(album_id)
+        
+    async def add_generation_to_album(self, album_id: str, generation_id: str) -> bool:
+        # Verify album exists
+        album = await self.dao.albums.get_album(album_id)
+        if not album:
+            return False
+            
+        # Verify generation exists (optional but good practice)
+        gen = await self.dao.generations.get_generation(generation_id)
+        if not gen:
+            return False
+        if album.cover_asset_id is None and gen.status == 'done':
+            album.cover_asset_id = gen.result_list[0]
+        return await self.dao.albums.add_generation(album_id, generation_id, album.cover_asset_id)
+
+    async def remove_generation_from_album(self, album_id: str, generation_id: str) -> bool:
+        return await self.dao.albums.remove_generation(album_id, generation_id)
+
+    async def get_generations_by_album(self, album_id: str, limit: int = 10, offset: int = 0) -> List[Generation]:
+        album = await self.dao.albums.get_album(album_id)
+        if not album or not album.generation_ids:
+            return []
+            
+        # Slice the generation IDs (simple pagination on ID list)
+        # Note: This pagination is on IDs, then we fetch objects.
+        # Ideally, fetch only slice.
+        
+        # Reverse to show newest first? Or just follow list order?
+        # Assuming list order is insertion order (which usually is what we want for manual sorting or chronological if always appended).
+        # Let's assume user wants same order as in list.
+        
+        sliced_ids = album.generation_ids[offset : offset + limit]
+        if not sliced_ids:
+            return []
+
+        # Fetch generations by IDs
+        # We need a method in GenerationRepo to fetch by IDs.
+        # Currently we only have get_generations with filters.
+        # We can add get_generations_by_ids to GenerationRepo or use loop (inefficient).
+        # Let's add get_generations_by_ids to GenerationRepo.
+        
+        # For now, I will use a loop if I can't modify Repo immediately, 
+        # but I SHOULD modify GenerationRepo.
+        
+        # Or I can use get_generations(filter={"_id": {"$in": [ObjectId(id) for id in sliced_ids]}})
+        # But get_generations doesn't support generic filter passing.
+        
+        # I'll update GenerationRepo to support fetching by IDs.
+        return await self.dao.generations.get_generations_by_ids(sliced_ids)