feat: implement media listing with sorting and filtering options

libertas_api/src/config.rs

@@ -15,5 +15,10 @@ pub fn load_config() -> CoreResult<Config> {
         broker_url: "nats://localhost:4222".to_string(),
         max_upload_size_mb: Some(100),
         default_storage_quota_gb: Some(10),
+        allowed_sort_columns: Some(vec![
+            "date_taken".to_string(),
+            "created_at".to_string(),
+            "original_filename".to_string(),
+        ]),
     })
 }

libertas_api/src/extractors/mod.rs

@@ -0,0 +1 @@
+pub mod query_options;

libertas_api/src/extractors/query_options.rs

@@ -0,0 +1,42 @@
+use axum::{extract::{FromRequestParts, Query}, http::request::Parts};
+use libertas_core::{error::CoreError, schema::{FilterParams, ListMediaOptions, SortOrder, SortParams}};
+
+use crate::{error::ApiError, schema::ListMediaParams, state::AppState};
+
+pub struct ApiListMediaOptions(pub ListMediaOptions);
+
+impl From<ListMediaParams> for ListMediaOptions {
+    fn from(params: ListMediaParams) -> Self {
+        let sort = params.sort_by.map(|field| {
+            let order = match params.order.as_deref() {
+                Some("asc") => SortOrder::Asc,
+                _ => SortOrder::Desc,
+            };
+            SortParams {
+                sort_by: field,
+                sort_order: order,
+            }
+        });
+
+        let filter = Some(FilterParams {
+            // e.g., mime_type: params.mime_type
+        });
+
+        ListMediaOptions { sort, filter }
+    }
+}
+
+impl FromRequestParts<AppState> for ApiListMediaOptions {
+    type Rejection = ApiError;
+
+    async fn from_request_parts(
+        parts: &mut Parts,
+        state: &AppState,
+    ) -> Result<Self, Self::Rejection> {
+        let Query(params) = Query::<ListMediaParams>::from_request_parts(parts, state)
+            .await
+            .map_err(|e| ApiError::from(CoreError::Validation(e.to_string())))?;
+
+        Ok(ApiListMediaOptions(params.into()))
+    }
+}

libertas_api/src/factory.rs

@@ -27,7 +27,7 @@ pub async fn build_app_state(config: Config) -> CoreResult<AppState> {
     let db_pool = build_database_pool(&config.database).await?;
 
     let user_repo = build_user_repository(&config.database, db_pool.clone()).await?;
-    let media_repo = build_media_repository(&config.database, db_pool.clone()).await?;
+    let media_repo = build_media_repository(&config, db_pool.clone()).await?;
     let album_repo = build_album_repository(&config.database, db_pool.clone()).await?;
     let album_share_repo = build_album_share_repository(&config.database, db_pool.clone()).await?;
 

libertas_api/src/handlers/media_handlers.rs

@@ -7,23 +7,14 @@ use axum::{
 };
 use futures::TryStreamExt;
 use libertas_core::{error::CoreError, models::Media, schema::UploadMediaData};
-use serde::Serialize;
 use std::{io, path::PathBuf};
 
 use tower::ServiceExt;
 use tower_http::services::ServeFile;
 use uuid::Uuid;
 
-use crate::{error::ApiError, middleware::auth::UserId, state::AppState};
+use crate::{error::ApiError, extractors::query_options::ApiListMediaOptions, middleware::auth::UserId, schema::MediaResponse, state::AppState};
 
-#[derive(Serialize)]
-pub struct MediaResponse {
-    id: uuid::Uuid,
-    storage_path: String,
-    original_filename: String,
-    mime_type: String,
-    hash: String,
-}
 
 impl From<Media> for MediaResponse {
     fn from(media: Media) -> Self {
@@ -39,7 +30,7 @@ impl From<Media> for MediaResponse {
 
 pub fn media_routes(max_upload_size: usize) -> Router<AppState> {
     Router::new()
-        .route("/", post(upload_media))
+        .route("/", post(upload_media).get(list_user_media))
         .route("/{id}", get(get_media_details).delete(delete_media))
         .route("/{id}/file", get(get_media_file))
         .layer(DefaultBodyLimit::max(max_upload_size))
@@ -123,3 +114,17 @@ async fn delete_media(
     state.media_service.delete_media(id, user_id).await?;
     Ok(StatusCode::NO_CONTENT)
 }
+
+async fn list_user_media(
+    State(state): State<AppState>,
+    UserId(user_id): UserId,
+    ApiListMediaOptions(options): ApiListMediaOptions,
+) -> Result<Json<Vec<MediaResponse>>, ApiError> {    
+    let media_list = state
+        .media_service
+        .list_user_media(user_id, options)
+        .await?;
+
+    let response = media_list.into_iter().map(MediaResponse::from).collect();
+    Ok(Json(response))
+}

libertas_api/src/main.rs

@@ -11,6 +11,8 @@ pub mod routes;
 pub mod security;
 pub mod services;
 pub mod state;
+pub mod extractors;
+pub mod schema;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {

libertas_api/src/schema.rs

@@ -0,0 +1,18 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize)]
+pub struct MediaResponse {
+    pub id: uuid::Uuid,
+    pub storage_path: String,
+    pub original_filename: String,
+    pub mime_type: String,
+    pub hash: String,
+}
+
+#[derive(Deserialize)]
+pub struct ListMediaParams {
+    pub sort_by: Option<String>,
+    pub order: Option<String>,
+    // You can add future filters here, e.g.:
+    // pub mime_type: Option<String>,
+}

libertas_api/src/services/media_service.rs

@@ -9,7 +9,7 @@ use libertas_core::{
     error::{CoreError, CoreResult},
     models::Media,
     repositories::{AlbumShareRepository, MediaRepository, UserRepository},
-    schema::UploadMediaData,
+    schema::{ListMediaOptions, UploadMediaData},
     services::MediaService,
 };
 use serde_json::json;
@@ -95,8 +95,8 @@ impl MediaService for MediaServiceImpl {
         Err(CoreError::Auth("Access denied".to_string()))
     }
 
-    async fn list_user_media(&self, user_id: Uuid) -> CoreResult<Vec<Media>> {
-        self.repo.list_by_user(user_id).await
+    async fn list_user_media(&self, user_id: Uuid, options: ListMediaOptions) -> CoreResult<Vec<Media>> {
+        self.repo.list_by_user(user_id, &options).await
     }
 
     async fn get_media_filepath(&self, id: Uuid, user_id: Uuid) -> CoreResult<String> {