feat: Implement face clustering and media retrieval for persons

libertas_infra/src/repositories/face_embedding_repository.rs

@@ -58,4 +58,23 @@ impl FaceEmbeddingRepository for PostgresFaceEmbeddingRepository {
 
         Ok(pg_embedding.map(FaceEmbedding::from))
     }
+
+    async fn list_unassigned_by_user(&self, user_id: Uuid) -> CoreResult<Vec<FaceEmbedding>> {
+        let pg_embeddings = sqlx::query_as!(
+            PostgresFaceEmbedding,
+            r#"
+            SELECT fe.id, fe.face_region_id, fe.model_id, fe.embedding
+            FROM face_embeddings fe
+            JOIN face_regions fr ON fe.face_region_id = fr.id
+            JOIN media m ON fr.media_id = m.id
+            WHERE fr.person_id IS NULL AND m.owner_id = $1
+            "#,
+            user_id
+        )
+        .fetch_all(&self.pool)
+        .await
+        .map_err(|e| CoreError::Database(e.to_string()))?;
+
+        Ok(pg_embeddings.into_iter().map(FaceEmbedding::from).collect())
+    }
 }

libertas_infra/src/repositories/media_repository.rs

@@ -162,6 +162,64 @@ impl MediaRepository for PostgresMediaRepository {
         Ok((media_list, total_items_result))
     }
 
+    async fn list_by_person_id(
+        &self,
+        person_id: Uuid,
+        options: &ListMediaOptions,
+    ) -> CoreResult<(Vec<Media>, i64)> {
+        let count_base_sql = "
+            SELECT COUNT(DISTINCT media.id) as total
+            FROM media
+            JOIN face_regions fr ON media.id = fr.media_id
+        ";
+        let mut count_query = sqlx::QueryBuilder::new(count_base_sql);
+        count_query.push(" WHERE fr.person_id = ");
+        count_query.push_bind(person_id);
+
+        let (mut count_query, _metadata_filter_count) = self
+            .query_builder
+            .apply_filters_to_query(count_query, options)?;
+
+        let total_items_result = count_query
+            .build_query_scalar()
+            .fetch_one(&self.pool)
+            .await
+            .map_err(|e| CoreError::Database(e.to_string()))?;
+
+        let data_base_sql = "
+            SELECT media.id, media.owner_id, media.storage_path,
+                   media.original_filename, media.mime_type,
+                   media.hash, media.created_at, media.thumbnail_path
+            FROM media
+            JOIN face_regions fr ON media.id = fr.media_id
+        ";
+        let mut data_query = sqlx::QueryBuilder::new(data_base_sql);
+        data_query.push(" WHERE fr.person_id = ");
+        data_query.push_bind(person_id);
+
+        let (mut data_query, _metadata_filter_count) = self
+            .query_builder
+            .apply_filters_to_query(data_query, options)?;
+
+        data_query.push(" GROUP BY media.id ");
+
+        let data_query = self
+            .query_builder
+            .apply_sorting_to_query(data_query, options)?;
+        let mut data_query = self
+            .query_builder
+            .apply_pagination_to_query(data_query, options)?;
+
+        let pg_media = data_query
+            .build_query_as::<PostgresMedia>()
+            .fetch_all(&self.pool)
+            .await
+            .map_err(|e| CoreError::Database(e.to_string()))?;
+
+        let media_list = pg_media.into_iter().map(|m| m.into()).collect();
+        Ok((media_list, total_items_result))
+    }
+
     async fn update_thumbnail_path(&self, id: Uuid, thumbnail_path: String) -> CoreResult<()> {
         sqlx::query!(
             r#"