From 6a7a49fb3804d0d27bbaee08b6feb26b4973b4bc Mon Sep 17 00:00:00 2001 From: niliara-edu Date: Wed, 22 Jan 2025 14:10:08 +0100 Subject: prepare for api --- src/api.rs | 23 +++++++++++ src/api/album.rs | 94 +++++++++++++++++++++++++++++++++++++++++++ src/api/artist.rs | 90 +++++++++++++++++++++++++++++++++++++++++ src/api/search_results.rs | 55 +++++++++++++++++++++++++ src/api/song.rs | 96 ++++++++++++++++++++++++++++++++++++++++++++ src/auth.rs | 53 ++++++++++++++++++++++++ src/main.rs | 24 +++++------ src/routes.rs | 4 -- src/routes/album.rs | 94 ------------------------------------------- src/routes/artist.rs | 90 ----------------------------------------- src/routes/search_results.rs | 55 ------------------------- src/routes/song.rs | 96 -------------------------------------------- 12 files changed, 420 insertions(+), 354 deletions(-) create mode 100644 src/api.rs create mode 100644 src/api/album.rs create mode 100644 src/api/artist.rs create mode 100644 src/api/search_results.rs create mode 100644 src/api/song.rs create mode 100644 src/auth.rs delete mode 100644 src/routes.rs delete mode 100644 src/routes/album.rs delete mode 100644 src/routes/artist.rs delete mode 100644 src/routes/search_results.rs delete mode 100644 src/routes/song.rs (limited to 'src') diff --git a/src/api.rs b/src/api.rs new file mode 100644 index 0000000..1810f24 --- /dev/null +++ b/src/api.rs @@ -0,0 +1,23 @@ +use actix_web::{web, Scope}; + +pub mod song; +pub mod album; +pub mod artist; +pub mod search_results; + +pub fn api_scope() -> Scope { + web::scope("/api") + .service(song::get_song) + .service(song::post_song) + .service(song::put_song) + .service(song::delete_song) + .service(album::get_album) + .service(album::post_album) + .service(album::put_album) + .service(album::delete_album) + .service(artist::get_artist) + .service(artist::post_artist) + .service(artist::put_artist) + .service(artist::delete_artist) + .service(search_results::search_results) +} diff --git a/src/api/album.rs b/src/api/album.rs new file mode 100644 index 0000000..d9d0d52 --- /dev/null +++ b/src/api/album.rs @@ -0,0 +1,94 @@ +use crate::database::{Album, AlbumPost, AlbumPut, Delete}; +use crate::AppState; +use actix_web::{delete, get, post, put, web, HttpResponse}; +use serde::Deserialize; + +#[derive(Deserialize)] +struct AlbumQueryOptions { + id: Option, + name: Option, + artist: Option, +} + +#[get("/album")] +pub async fn get_album( + app_state: web::Data, + get_args: web::Query, +) -> HttpResponse { + let default = String::from(""); + + if get_args.id.is_some() { + let id: &str = get_args.id.as_ref().unwrap_or(&default); + let search_attempt: sqlx::Result> = + app_state.database.select_album_by_id(id).await; + + return match search_attempt { + Ok(song_list) => HttpResponse::Ok().json(song_list), + Err(e) => HttpResponse::Ok().body(format!("{}", e)), + }; + } + let search_attempt: sqlx::Result, sqlx::Error> = match true { + _ if get_args.name.is_some() => { + let name: &str = &get_args.name.as_ref().unwrap_or(&default); + app_state.database.select_albums_by_name(name).await + } + _ if get_args.artist.is_some() => { + let artist: &str = &get_args.artist.as_ref().unwrap_or(&default); + app_state.database.select_albums_by_artist(artist).await + } + _ => app_state.database.select_albums().await, + }; + + match search_attempt { + Ok(album_list) => HttpResponse::Ok().json(album_list), + Err(e) => HttpResponse::Ok().body(format!("{}", e)), + } +} + +#[post("/album")] +pub async fn post_album( + app_state: web::Data, + post_data: web::Json, +) -> HttpResponse { + match app_state + .database + .create_album(post_data.into_inner()) + .await + { + Ok(_) => HttpResponse::Ok().body("Post succeeded\n"), + Err(e) => HttpResponse::Ok().body(format!("{}", e)), + } +} + +#[put("/album")] +pub async fn put_album( + app_state: web::Data, + post_data: web::Json, +) -> HttpResponse { + match app_state.database.edit_album(post_data.into_inner()).await { + Ok(_) => HttpResponse::Ok().body("Put succeeded\n"), + Err(e) => HttpResponse::Ok().body(format!("{}", e)), + } +} + +#[delete("/album")] +pub async fn delete_album( + app_state: web::Data, + post_data: web::Json, +) -> HttpResponse { + let id: i32 = post_data + .into_inner() + .id + .unwrap_or(String::default()) + .parse::() + .unwrap_or(-1); + + if id == -1 { + return HttpResponse::Ok().body("Invalid id value, code not executed\n"); + } + + match app_state.database.delete_album(id).await { + Ok(_) => HttpResponse::Ok().body("Deletion succeeded\n".to_owned()), + Err(e) => HttpResponse::Ok().body(format!("There was an issue in the request:\n{}", e)), + } +} diff --git a/src/api/artist.rs b/src/api/artist.rs new file mode 100644 index 0000000..81ae773 --- /dev/null +++ b/src/api/artist.rs @@ -0,0 +1,90 @@ +use crate::database::{Artist, ArtistPost, ArtistPut, Delete}; +use crate::AppState; +use actix_web::{delete, get, post, put, web, HttpResponse}; +use serde::Deserialize; + +#[derive(Deserialize)] +struct ArtistQueryOptions { + id: Option, + name: Option, +} + +#[get("/artist")] +pub async fn get_artist( + app_state: web::Data, + get_args: web::Query, +) -> HttpResponse { + let default = String::from(""); + + if get_args.id.is_some() { + let id: &str = get_args.id.as_ref().unwrap_or(&default); + let search_attempt: sqlx::Result> = + app_state.database.select_artist_by_id(id).await; + + return match search_attempt { + Ok(song_list) => HttpResponse::Ok().json(song_list), + Err(e) => HttpResponse::Ok().body(format!("{}", e)), + }; + } + + let search_attempt: sqlx::Result, sqlx::Error> = match true { + _ if get_args.name.is_some() => { + let name: &str = &get_args.name.as_ref().unwrap_or(&default); + app_state.database.select_artists_by_name(name).await + } + _ => app_state.database.select_artists().await, + }; + + match search_attempt { + Ok(artist_list) => HttpResponse::Ok().json(artist_list), + Err(e) => HttpResponse::Ok().body(format!("{}", e)), + } +} + +#[post("/artist")] +pub async fn post_artist( + app_state: web::Data, + post_data: web::Json, +) -> HttpResponse { + match app_state + .database + .create_artist(post_data.into_inner()) + .await + { + Ok(_) => HttpResponse::Ok().body("Post succeeded\n"), + Err(e) => HttpResponse::Ok().body(format!("{}", e)), + } +} + +#[put("/artist")] +pub async fn put_artist( + app_state: web::Data, + post_data: web::Json, +) -> HttpResponse { + match app_state.database.edit_artist(post_data.into_inner()).await { + Ok(_) => HttpResponse::Ok().body("Put succeeded\n"), + Err(e) => HttpResponse::Ok().body(format!("{}", e)), + } +} + +#[delete("/artist")] +pub async fn delete_artist( + app_state: web::Data, + post_data: web::Json, +) -> HttpResponse { + let id: i32 = post_data + .into_inner() + .id + .unwrap_or(String::default()) + .parse::() + .unwrap_or(-1); + + if id == -1 { + return HttpResponse::Ok().body("Invalid id value, code not executed\n"); + } + + match app_state.database.delete_artist(id).await { + Ok(_) => HttpResponse::Ok().body("Deletion succeeded\n\n"), + Err(e) => HttpResponse::Ok().body(format!("There was an issue in the request:\n{}", e)), + } +} diff --git a/src/api/search_results.rs b/src/api/search_results.rs new file mode 100644 index 0000000..6456ff9 --- /dev/null +++ b/src/api/search_results.rs @@ -0,0 +1,55 @@ +use crate::database::{Album, Artist, Song}; +use crate::AppState; +use actix_web::{get, web, HttpResponse}; +use serde::Deserialize; + +#[derive(Deserialize)] +struct SearchQueryOptions { + id: Option, + name: Option, +} + +#[get("/search-results")] +pub async fn search_results( + app_state: web::Data, + get_args: web::Query, +) -> HttpResponse { + let default: String = String::from(""); + + if get_args.id.is_some() { + let id: &str = get_args.id.as_ref().unwrap_or(&default); + let search_attempt: ( + sqlx::Result, sqlx::Error>, + sqlx::Result, sqlx::Error>, + sqlx::Result, sqlx::Error>, + ) = { app_state.database.search_results_by_id(id).await }; + + return HttpResponse::Ok().json(( + search_attempt.0.unwrap_or(None), + search_attempt.1.unwrap_or(None), + search_attempt.2.unwrap_or(None), + )); + }; + + let search_attempt: ( + sqlx::Result, sqlx::Error>, + sqlx::Result, sqlx::Error>, + sqlx::Result, sqlx::Error>, + ) = match true { + _ if get_args.name.is_some() => { + app_state + .database + .search_results_by_name(&get_args.name.clone().unwrap()) + .await + } + _ => app_state.database.search_results().await, // Err(sqlx::Error::RowNotFound), + // Err(sqlx::Error::RowNotFound), + // Err(sqlx::Error::RowNotFound), + }; + + return HttpResponse::Ok().json(( + search_attempt.0.unwrap_or(Vec::new()), + search_attempt.1.unwrap_or(Vec::new()), + search_attempt.2.unwrap_or(Vec::new()), + )); +} diff --git a/src/api/song.rs b/src/api/song.rs new file mode 100644 index 0000000..850c759 --- /dev/null +++ b/src/api/song.rs @@ -0,0 +1,96 @@ +use crate::database::{Delete, Song, SongPost, SongPut}; +use crate::AppState; +use actix_web::{delete, get, post, put, web, HttpResponse}; +use serde::Deserialize; + +#[derive(Deserialize)] +struct SongQueryOptions { + id: Option, + name: Option, + artist: Option, + album: Option, +} + +#[get("/song")] +pub async fn get_song( + app_state: web::Data, + get_args: web::Query, +) -> HttpResponse { + let default = String::from(""); + + if get_args.id.is_some() { + let id: &str = get_args.id.as_ref().unwrap_or(&default); + let search_attempt: sqlx::Result> = + app_state.database.select_song_by_id(id).await; + + return match search_attempt { + Ok(song_list) => HttpResponse::Ok().json(song_list), + Err(e) => HttpResponse::Ok().body(format!("{}", e)), + }; + } + + let search_attempt: sqlx::Result> = match true { + _ if get_args.name.is_some() => { + let name: &str = get_args.name.as_ref().unwrap_or(&default); + app_state.database.select_songs_by_name(name).await + } + _ if get_args.album.is_some() => { + let album: &str = get_args.album.as_ref().unwrap_or(&default); + app_state.database.select_songs_by_album(album).await + } + _ if get_args.artist.is_some() => { + let artist: &str = get_args.artist.as_ref().unwrap_or(&default); + app_state.database.select_songs_by_artist(artist).await + } + _ => app_state.database.select_songs().await, + }; + + match search_attempt { + Ok(song_list) => HttpResponse::Ok().json(song_list), + Err(e) => HttpResponse::Ok().body(format!("{}", e)), + } +} + +#[post("/song")] +pub async fn post_song( + app_state: web::Data, + post_data: web::Json, +) -> HttpResponse { + match app_state.database.create_song(post_data.into_inner()).await { + Ok(_) => HttpResponse::Ok().body("Post succeeded\n"), + Err(e) => HttpResponse::Ok().body(format!("{}", e)), + } +} + +#[put("/song")] +pub async fn put_song( + app_state: web::Data, + post_data: web::Json, +) -> HttpResponse { + match app_state.database.edit_song(post_data.into_inner()).await { + Ok(_) => HttpResponse::Ok().body("Put succeeded\n"), + Err(e) => HttpResponse::Ok().body(format!("{}", e)), + } +} + +#[delete("/song")] +pub async fn delete_song( + app_state: web::Data, + post_data: web::Json, +) -> HttpResponse { + let id: i32 = post_data + .into_inner() + .id + .unwrap_or(String::default()) + .parse::() + .unwrap_or(-1); + + if id == -1 { + return HttpResponse::Ok().body("Invalid id value, code not executed\n"); + } + + match app_state.database.delete_song(id).await { + Ok(_) => HttpResponse::Ok().body("Deletion succeeded\n"), + Err(e) => HttpResponse::Ok().body(format!("There was an issue in the request:\n{}", e)), + } +} diff --git a/src/auth.rs b/src/auth.rs new file mode 100644 index 0000000..8bf29f7 --- /dev/null +++ b/src/auth.rs @@ -0,0 +1,53 @@ +use actix_web::{web, Scope, HttpResponse}; +use serde::{Serialize, Deserialize}; +use chrono::{Utc, Duration}; +use jsonwebtoken::{encode, EncodingKey, Header}; + +use crate::AppState; + +pub fn auth_scope() -> Scope { + web::scope("/auth") + .route("/encode-token/{id}", web::get().to(encode_token)) + .route("/decode-token", web::post().to(decode_token)) + .route("/protected", web::get().to(protected)) +} + +#[derive(Serialize, Deserialize)] +struct Claims{ + id: usize, + exp: usize, +} + +#[derive(Serialize, Deserialize)] +struct Response{ + message: String, +} + +#[derive(Serialize, Deserialize)] +struct EncodeResponse{ + message: String, + token: String, +} + +async fn encode_token(path: web::Path, data: web::Data) -> HttpResponse { + let id: usize = path.into_inner(); + let exp: usize = (Utc::now() + Duration::days(365)).timestamp() as usize; + let claims: Claims = Claims {id, exp}; + let token: String = encode( + &Header::default(), + &claims, + &EncodingKey::from_secret(data.secret.as_str().as_ref()), + ).unwrap(); + HttpResponse::Ok().json(EncodeResponse { + message: "success".to_owned(), + token: token.to_owned(), + }) +} + +async fn decode_token() -> HttpResponse { + HttpResponse::Ok().body("decode_token\n".to_owned()) +} + +async fn protected() -> HttpResponse { + HttpResponse::Ok().body("protected\n".to_owned()) +} diff --git a/src/main.rs b/src/main.rs index 0bd3087..8a64e0d 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,5 +1,6 @@ +mod api; +mod auth; mod database; -mod routes; mod structs; use actix_web::{web, App, HttpServer}; @@ -9,6 +10,7 @@ use std::sync::Arc; #[derive(Clone)] struct AppState { database: Arc, + secret: String, } #[actix_web::main] @@ -25,25 +27,17 @@ async fn main() -> std::io::Result<()> { }; let db = Arc::new(db_raw); - let app_state = AppState { database: db }; + let app_state = AppState { + database: db, + secret: "secret".to_owned(), + }; HttpServer::new(move || { App::new() .app_data(web::Data::new(app_state.clone())) .route("/", web::get().to(root)) - .service(routes::song::get_song) - .service(routes::song::post_song) - .service(routes::song::put_song) - .service(routes::song::delete_song) - .service(routes::album::get_album) - .service(routes::album::post_album) - .service(routes::album::put_album) - .service(routes::album::delete_album) - .service(routes::artist::get_artist) - .service(routes::artist::post_artist) - .service(routes::artist::put_artist) - .service(routes::artist::delete_artist) - .service(routes::search_results::search_results) + .service(api::api_scope()) + .service(auth::auth_scope()) }) .bind(("127.0.0.1", 8000))? .run() diff --git a/src/routes.rs b/src/routes.rs deleted file mode 100644 index 0cefd1b..0000000 --- a/src/routes.rs +++ /dev/null @@ -1,4 +0,0 @@ -pub mod song; -pub mod album; -pub mod artist; -pub mod search_results; diff --git a/src/routes/album.rs b/src/routes/album.rs deleted file mode 100644 index ab82e2e..0000000 --- a/src/routes/album.rs +++ /dev/null @@ -1,94 +0,0 @@ -use crate::database::{Album, AlbumPost, AlbumPut, Delete}; -use crate::AppState; -use actix_web::{delete, get, post, put, web, HttpResponse}; -use serde::Deserialize; - -#[derive(Deserialize)] -struct AlbumQueryOptions { - id: Option, - name: Option, - artist: Option, -} - -#[get("/album")] -pub async fn get_album( - app_state: web::Data, - get_args: web::Query, -) -> HttpResponse { - let default = String::from(""); - - if get_args.id.is_some() { - let id: &str = get_args.id.as_ref().unwrap_or(&default); - let search_attempt: sqlx::Result> = - app_state.database.select_album_by_id(id).await; - - return match search_attempt { - Ok(song_list) => HttpResponse::Ok().json(song_list), - Err(e) => HttpResponse::Ok().body(format!("{}", e)), - }; - } - let search_attempt: sqlx::Result, sqlx::Error> = match true { - _ if get_args.name.is_some() => { - let name: &str = &get_args.name.as_ref().unwrap_or(&default); - app_state.database.select_albums_by_name(name).await - } - _ if get_args.artist.is_some() => { - let artist: &str = &get_args.artist.as_ref().unwrap_or(&default); - app_state.database.select_albums_by_artist(artist).await - } - _ => app_state.database.select_albums().await, - }; - - match search_attempt { - Ok(album_list) => HttpResponse::Ok().json(album_list), - Err(e) => HttpResponse::Ok().body(format!("{}", e)), - } -} - -#[post("/album")] -pub async fn post_album( - app_state: web::Data, - post_data: web::Json, -) -> HttpResponse { - match app_state - .database - .create_album(post_data.into_inner()) - .await - { - Ok(_) => HttpResponse::Ok().body("Post succeeded\n"), - Err(e) => HttpResponse::Ok().body(format!("{}", e)), - } -} - -#[put("/album")] -pub async fn put_album( - app_state: web::Data, - post_data: web::Json, -) -> HttpResponse { - match app_state.database.edit_album(post_data.into_inner()).await { - Ok(_) => HttpResponse::Ok().body("Put succeeded\n"), - Err(e) => HttpResponse::Ok().body(format!("{}", e)), - } -} - -#[delete("/album")] -pub async fn delete_album( - app_state: web::Data, - post_data: web::Json, -) -> HttpResponse { - let id: i32 = post_data - .into_inner() - .id - .unwrap_or(String::default()) - .parse::() - .unwrap_or(-1); - - if id == -1 { - return HttpResponse::Ok().body("Invalid id value, code not executed\n"); - } - - match app_state.database.delete_album(id).await { - Ok(_) => HttpResponse::Ok().body("Deletion succeeded\n"), - Err(e) => HttpResponse::Ok().body(format!("There was an issue in the request:\n{}", e)), - } -} diff --git a/src/routes/artist.rs b/src/routes/artist.rs deleted file mode 100644 index 81ae773..0000000 --- a/src/routes/artist.rs +++ /dev/null @@ -1,90 +0,0 @@ -use crate::database::{Artist, ArtistPost, ArtistPut, Delete}; -use crate::AppState; -use actix_web::{delete, get, post, put, web, HttpResponse}; -use serde::Deserialize; - -#[derive(Deserialize)] -struct ArtistQueryOptions { - id: Option, - name: Option, -} - -#[get("/artist")] -pub async fn get_artist( - app_state: web::Data, - get_args: web::Query, -) -> HttpResponse { - let default = String::from(""); - - if get_args.id.is_some() { - let id: &str = get_args.id.as_ref().unwrap_or(&default); - let search_attempt: sqlx::Result> = - app_state.database.select_artist_by_id(id).await; - - return match search_attempt { - Ok(song_list) => HttpResponse::Ok().json(song_list), - Err(e) => HttpResponse::Ok().body(format!("{}", e)), - }; - } - - let search_attempt: sqlx::Result, sqlx::Error> = match true { - _ if get_args.name.is_some() => { - let name: &str = &get_args.name.as_ref().unwrap_or(&default); - app_state.database.select_artists_by_name(name).await - } - _ => app_state.database.select_artists().await, - }; - - match search_attempt { - Ok(artist_list) => HttpResponse::Ok().json(artist_list), - Err(e) => HttpResponse::Ok().body(format!("{}", e)), - } -} - -#[post("/artist")] -pub async fn post_artist( - app_state: web::Data, - post_data: web::Json, -) -> HttpResponse { - match app_state - .database - .create_artist(post_data.into_inner()) - .await - { - Ok(_) => HttpResponse::Ok().body("Post succeeded\n"), - Err(e) => HttpResponse::Ok().body(format!("{}", e)), - } -} - -#[put("/artist")] -pub async fn put_artist( - app_state: web::Data, - post_data: web::Json, -) -> HttpResponse { - match app_state.database.edit_artist(post_data.into_inner()).await { - Ok(_) => HttpResponse::Ok().body("Put succeeded\n"), - Err(e) => HttpResponse::Ok().body(format!("{}", e)), - } -} - -#[delete("/artist")] -pub async fn delete_artist( - app_state: web::Data, - post_data: web::Json, -) -> HttpResponse { - let id: i32 = post_data - .into_inner() - .id - .unwrap_or(String::default()) - .parse::() - .unwrap_or(-1); - - if id == -1 { - return HttpResponse::Ok().body("Invalid id value, code not executed\n"); - } - - match app_state.database.delete_artist(id).await { - Ok(_) => HttpResponse::Ok().body("Deletion succeeded\n\n"), - Err(e) => HttpResponse::Ok().body(format!("There was an issue in the request:\n{}", e)), - } -} diff --git a/src/routes/search_results.rs b/src/routes/search_results.rs deleted file mode 100644 index 3056aef..0000000 --- a/src/routes/search_results.rs +++ /dev/null @@ -1,55 +0,0 @@ -use crate::database::{Album, Artist, Song}; -use crate::AppState; -use actix_web::{get, web, HttpResponse}; -use serde::Deserialize; - -#[derive(Deserialize)] -struct SearchQueryOptions { - id: Option, - name: Option, -} - -#[get("/searchResults")] -pub async fn search_results( - app_state: web::Data, - get_args: web::Query, -) -> HttpResponse { - let default: String = String::from(""); - - if get_args.id.is_some() { - let id: &str = get_args.id.as_ref().unwrap_or(&default); - let search_attempt: ( - sqlx::Result, sqlx::Error>, - sqlx::Result, sqlx::Error>, - sqlx::Result, sqlx::Error>, - ) = { app_state.database.search_results_by_id(id).await }; - - return HttpResponse::Ok().json(( - search_attempt.0.unwrap_or(None), - search_attempt.1.unwrap_or(None), - search_attempt.2.unwrap_or(None), - )); - }; - - let search_attempt: ( - sqlx::Result, sqlx::Error>, - sqlx::Result, sqlx::Error>, - sqlx::Result, sqlx::Error>, - ) = match true { - _ if get_args.name.is_some() => { - app_state - .database - .search_results_by_name(&get_args.name.clone().unwrap()) - .await - } - _ => app_state.database.search_results().await, // Err(sqlx::Error::RowNotFound), - // Err(sqlx::Error::RowNotFound), - // Err(sqlx::Error::RowNotFound), - }; - - return HttpResponse::Ok().json(( - search_attempt.0.unwrap_or(Vec::new()), - search_attempt.1.unwrap_or(Vec::new()), - search_attempt.2.unwrap_or(Vec::new()), - )); -} diff --git a/src/routes/song.rs b/src/routes/song.rs deleted file mode 100644 index 850c759..0000000 --- a/src/routes/song.rs +++ /dev/null @@ -1,96 +0,0 @@ -use crate::database::{Delete, Song, SongPost, SongPut}; -use crate::AppState; -use actix_web::{delete, get, post, put, web, HttpResponse}; -use serde::Deserialize; - -#[derive(Deserialize)] -struct SongQueryOptions { - id: Option, - name: Option, - artist: Option, - album: Option, -} - -#[get("/song")] -pub async fn get_song( - app_state: web::Data, - get_args: web::Query, -) -> HttpResponse { - let default = String::from(""); - - if get_args.id.is_some() { - let id: &str = get_args.id.as_ref().unwrap_or(&default); - let search_attempt: sqlx::Result> = - app_state.database.select_song_by_id(id).await; - - return match search_attempt { - Ok(song_list) => HttpResponse::Ok().json(song_list), - Err(e) => HttpResponse::Ok().body(format!("{}", e)), - }; - } - - let search_attempt: sqlx::Result> = match true { - _ if get_args.name.is_some() => { - let name: &str = get_args.name.as_ref().unwrap_or(&default); - app_state.database.select_songs_by_name(name).await - } - _ if get_args.album.is_some() => { - let album: &str = get_args.album.as_ref().unwrap_or(&default); - app_state.database.select_songs_by_album(album).await - } - _ if get_args.artist.is_some() => { - let artist: &str = get_args.artist.as_ref().unwrap_or(&default); - app_state.database.select_songs_by_artist(artist).await - } - _ => app_state.database.select_songs().await, - }; - - match search_attempt { - Ok(song_list) => HttpResponse::Ok().json(song_list), - Err(e) => HttpResponse::Ok().body(format!("{}", e)), - } -} - -#[post("/song")] -pub async fn post_song( - app_state: web::Data, - post_data: web::Json, -) -> HttpResponse { - match app_state.database.create_song(post_data.into_inner()).await { - Ok(_) => HttpResponse::Ok().body("Post succeeded\n"), - Err(e) => HttpResponse::Ok().body(format!("{}", e)), - } -} - -#[put("/song")] -pub async fn put_song( - app_state: web::Data, - post_data: web::Json, -) -> HttpResponse { - match app_state.database.edit_song(post_data.into_inner()).await { - Ok(_) => HttpResponse::Ok().body("Put succeeded\n"), - Err(e) => HttpResponse::Ok().body(format!("{}", e)), - } -} - -#[delete("/song")] -pub async fn delete_song( - app_state: web::Data, - post_data: web::Json, -) -> HttpResponse { - let id: i32 = post_data - .into_inner() - .id - .unwrap_or(String::default()) - .parse::() - .unwrap_or(-1); - - if id == -1 { - return HttpResponse::Ok().body("Invalid id value, code not executed\n"); - } - - match app_state.database.delete_song(id).await { - Ok(_) => HttpResponse::Ok().body("Deletion succeeded\n"), - Err(e) => HttpResponse::Ok().body(format!("There was an issue in the request:\n{}", e)), - } -} -- cgit v1.2.3