playlists

src/route/mod.rs

@@ -7,9 +7,9 @@ use serde_json::json;
 
 pub mod album;
 pub mod artist;
+pub mod playlist;
 pub mod track;
 pub mod user;
-pub mod playlist;
 
 // todo : rework api
 

src/route/playlist.rs

@@ -1,27 +1,34 @@
-use super::api_error;
-use super::FallibleApiResponse;
-use super::ToAPI;
+use crate::library::track::Track;
+use crate::library::user::User;
+use mongod::reference_of;
 use mongod::Model;
 use mongod::Referencable;
 use mongodb::bson::doc;
-use rocket::*;
+use rocket::get;
+use rocket::post;
+use rocket::serde::json::Json;
 use serde_json::json;
 
 use crate::library::playlist::Playlist;
 use crate::library::playlist::Visibility;
-use crate::library::user::User;
+use crate::route::FallibleApiResponse;
 
+use super::api_error;
+use super::ToAPI;
 
 #[get("/playlists")]
 pub async fn playlists_route(u: User) -> FallibleApiResponse {
-    let mut playlists = vec![
-        "recent".to_string()
-    ];
+    let mut playlists = vec![json!({"id": "recent", "name": "Recently Played"})];
 
-    let own_playlists = Playlist::find(doc! { "owner": u.reference()}, None).await.unwrap();
+    let own_playlists = Playlist::find(doc! { "owner": u.reference()}, None)
+        .await
+        .unwrap();
 
     for playlist in own_playlists {
-        playlists.push(playlist._id);
+        playlists.push(json!({
+            "id": playlist._id,
+            "name": playlist.title
+        }));
     }
 
     Ok(json!(playlists))
@@ -33,11 +40,70 @@ pub async fn playlist_route(id: &str, u: User) -> FallibleApiResponse {
         // todo : recently played
     }
 
-    let playlist = Playlist::get(id).await.ok_or_else(|| api_error("No playlist with that ID found"))?;
+    let playlist = Playlist::get(id)
+        .await
+        .ok_or_else(|| api_error("No playlist with that ID found"))?;
 
-    if matches!(playlist.visibility, Visibility::Private) && u.username != playlist.owner.get::<User>().await.username {
+    if matches!(playlist.visibility, Visibility::Private)
+        && u.username != playlist.owner.get::<User>().await.username
+    {
         return Err(api_error("Forbidden"));
     }
 
     Ok(playlist.api().await)
-}
+}
+
+#[derive(rocket::serde::Deserialize)]
+pub struct PlaylistData {
+    pub title: String,
+    pub visibility: Visibility,
+    pub tracks: Vec<String>,
+}
+
+#[post("/playlist", data = "<playlist>")]
+pub async fn playlist_add_route(playlist: Json<PlaylistData>, u: User) -> FallibleApiResponse {
+    let playlist = Playlist::create(
+        u,
+        &playlist.title,
+        playlist.visibility.clone(),
+        &playlist.tracks,
+    )
+    .await
+    .ok_or_else(|| api_error("Failed to create playlist"))?;
+    playlist.insert().await.unwrap();
+
+    Ok(json!({"created": playlist._id}))
+}
+
+#[post("/playlist/<id>", data = "<edit>")]
+pub async fn playlist_edit_route(
+    id: &str,
+    edit: Json<PlaylistData>,
+    u: User,
+) -> FallibleApiResponse {
+    let mut playlist = Playlist::get(id)
+        .await
+        .ok_or_else(|| api_error("No playlist with that ID found"))?;
+
+    if playlist.owner.id() != u._id {
+        return Err(api_error("Forbidden"));
+    }
+
+    let mut tracks_ref = vec![];
+
+    for track in &edit.tracks {
+        tracks_ref
+            .push(reference_of!(Track, track).ok_or_else(|| api_error("Invalid tracks found"))?);
+    }
+
+    playlist
+        .update(&json!({
+            "title": edit.title,
+            "visibility": edit.visibility,
+            "tracks": tracks_ref
+        }))
+        .await
+        .unwrap();
+
+    Ok(json!({"edited": playlist._id}))
+}