initial commit

src/errors/db.rs

@@ -0,0 +1,8 @@
+#[derive(Debug)]
+pub struct DBError {}
+
+impl From<diesel::result::Error> for DBError {
+    fn from(err: diesel::result::Error) {
+        DBError {}
+    }
+}

src/errors/mod.rs

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

src/helpers/db.rs

@@ -0,0 +1,26 @@
+use diesel::r2d2::ConnectionManager;
+use diesel::result::Error;
+use diesel::{pg::PgConnection, r2d2};
+use lazy_static::lazy_static;
+
+type Pool = r2d2::Pool<ConnectionManager<PgConnection>>;
+pub type DbConnection = r2d2::PooledConnection<ConnectionManager<PgConnection>>;
+
+const DATABASE_URL: &str = "postgres://postgres:root@127.0.0.1/vybr";
+
+lazy_static! {
+    static ref POOL: Pool = {
+        let manager = ConnectionManager::<PgConnection>::new(DATABASE_URL);
+        Pool::new(manager).expect("Failed to create db pool.")
+    };
+}
+
+pub fn init() {
+    lazy_static::initialize(&POOL);
+    let _conn = connection().expect("Failed to get db connection.");
+}
+
+pub fn connection() -> Result<DbConnection, Error> {
+    POOL.get()
+        .map_err(|e| panic!("Database connection error: {}", e))
+}

src/helpers/jwt.rs

@@ -0,0 +1,13 @@
+use crate::utils::get_jwt_secret;
+use jwt::VerifyWithKey;
+use std::collections::BTreeMap;
+
+pub fn get_token(token: &str) -> Result<BTreeMap<String, String>, &str> {
+    let secret = get_jwt_secret().unwrap();
+    let claims = token.verify_with_key(&secret);
+
+    match claims {
+        Ok(claims) => Ok(claims),
+        Err(_e) => return Err("Error parsing token"),
+    }
+}

src/helpers/mod.rs

@@ -0,0 +1,2 @@
+pub mod db;
+pub mod jwt;

src/main.rs

@@ -0,0 +1,28 @@
+mod helpers;
+mod middlewares;
+mod models;
+mod routes;
+mod schema;
+mod utils;
+
+use crate::helpers::db;
+use actix_web::{web, App, HttpServer};
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    dotenvy::dotenv().expect("No .env file found");
+    std::env::set_var("RUST_LOG", "debug");
+
+    db::init();
+
+    HttpServer::new(move || {
+        App::new()
+            .service(web::scope("/playlists").service(routes::playlists::get_playlist))
+            .service(routes::auth::login)
+            .service(routes::me::routes())
+            .service(web::scope("/users").service(routes::users::get_user))
+    })
+    .bind(("127.0.0.1", 9000))?
+    .run()
+    .await
+}

src/middlewares/error.rs

@@ -0,0 +1,68 @@
+use actix_web::{http::StatusCode, HttpResponse, ResponseError};
+use diesel::result::Error;
+use serde::Serialize;
+use std::fmt::{Debug, Display, Formatter, Result};
+
+#[derive(Debug)]
+pub struct ErrorResponse {
+    pub message: String,
+    pub status: StatusCode,
+}
+
+impl Display for ErrorResponse {
+    fn fmt(&self, f: &mut Formatter) -> Result {
+        write!(f, "{}: {}", self.status, self.message)
+    }
+}
+
+impl From<actix_web::Error> for ErrorResponse {
+    fn from(err: actix_web::Error) -> Self {
+        ErrorResponse {
+            status: err.error_response().status(),
+            message: err.to_string(),
+        }
+    }
+}
+
+impl From<Error> for ErrorResponse {
+    fn from(err: Error) -> Self {
+        match err {
+            Error::NotFound => ErrorResponse {
+                status: StatusCode::NOT_FOUND,
+                message: err.to_string(),
+            },
+            _ => ErrorResponse {
+                status: StatusCode::INTERNAL_SERVER_ERROR,
+                message: err.to_string(),
+            },
+        }
+    }
+}
+
+impl ResponseError for ErrorResponse {
+    fn status_code(&self) -> StatusCode {
+        self.status
+    }
+
+    fn error_response(&self) -> HttpResponse {
+        #[derive(Serialize)]
+        struct Response {
+            error: ErrorResponse,
+        }
+
+        #[derive(Serialize)]
+        struct ErrorResponse {
+            message: String,
+            status: u16,
+        }
+
+        HttpResponse::build(self.status_code())
+            .content_type("application/json")
+            .json(Response {
+                error: ErrorResponse {
+                    message: self.message.to_string(),
+                    status: self.status_code().as_u16(),
+                },
+            })
+    }
+}

src/middlewares/mod.rs

@@ -0,0 +1,2 @@
+pub mod error;
+pub mod user;

src/middlewares/user.rs

@@ -0,0 +1,35 @@
+use crate::helpers::jwt::get_token;
+use crate::middlewares::error::ErrorResponse;
+use crate::models::user::Users;
+use actix_web::http::{header, StatusCode};
+use actix_web::HttpRequest;
+
+pub fn get_user(req: HttpRequest) -> Result<Users, ErrorResponse> {
+    let authorization = req.headers().get(header::AUTHORIZATION);
+
+    match authorization {
+        Some(header) => {
+            let claims = get_token(header.to_str().unwrap());
+
+            match claims {
+                Ok(claims) => {
+                    let user = Users::find(claims["user_id"].as_str())?;
+
+                    Ok(user)
+                }
+                Err(e) => {
+                    return Err(ErrorResponse {
+                        message: e.to_string(),
+                        status: StatusCode::INTERNAL_SERVER_ERROR,
+                    })
+                }
+            }
+        }
+        None => {
+            return Err(ErrorResponse {
+                message: "Not Authorized".to_string(),
+                status: StatusCode::UNAUTHORIZED,
+            });
+        }
+    }
+}

src/models/mod.rs

@@ -0,0 +1,3 @@
+pub mod playlist;
+pub mod tracks;
+pub mod user;

src/models/playlist.rs

@@ -0,0 +1,86 @@
+use crate::helpers::db;
+use crate::models::tracks::Tracks;
+use crate::models::user::Users;
+use crate::schema::playlists;
+use chrono::NaiveDateTime;
+use diesel::result::Error;
+use diesel::{
+    AsChangeset, EqAll, ExpressionMethods, Insertable, QueryDsl, Queryable, RunQueryDsl, Selectable,
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+pub struct PlaylistCreator {
+    pub id: String,
+    pub name: String,
+}
+
+#[derive(AsChangeset, Insertable, Queryable, Selectable, Deserialize, Serialize)]
+#[diesel(table_name = crate::schema::playlists)]
+#[diesel(belongs_to(Users))]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct Playlist {
+    pub id: String,
+    pub name: String,
+    pub creator_id: String,
+
+    pub created_at: NaiveDateTime,
+    pub updated_at: Option<NaiveDateTime>,
+}
+
+#[derive(Debug, Deserialize, Queryable, Serialize)]
+pub struct Playlists {
+    pub id: String,
+    pub name: String,
+    pub creator_id: String,
+
+    pub created_at: NaiveDateTime,
+    pub updated_at: Option<NaiveDateTime>,
+}
+
+impl Playlists {
+    pub fn find(id: &str) -> Result<Self, Error> {
+        let conn = &mut db::connection()?;
+        let playlist = playlists::table.filter(playlists::id.eq(id)).first(conn)?;
+        Ok(playlist)
+    }
+
+    pub fn create(playlist: Playlist) -> Result<Self, Error> {
+        let conn = &mut db::connection()?;
+        let playlist = diesel::insert_into(playlists::table)
+            .values(Playlist::from(playlist))
+            .get_result(conn)?;
+        Ok(playlist)
+    }
+
+    pub fn find_for_user(user_id: &str) -> Result<Vec<Playlists>, Error> {
+        let conn = &mut db::connection()?;
+        let playlists = playlists::table
+            .filter(playlists::creator_id.eq(user_id))
+            .get_results(conn)?;
+        Ok(playlists)
+    }
+
+    pub fn get_tracks(&self) -> Result<Vec<Tracks>, Error> {
+        let tracks = Tracks::find_by_playlist(&self.id)?;
+        Ok(tracks)
+    }
+
+    pub fn get_creator(&self) -> Result<Users, Error> {
+        let creator = Users::find(&self.creator_id)?;
+        Ok(creator)
+    }
+}
+
+impl Playlist {
+    fn from(playlist: Playlist) -> Playlist {
+        Playlist {
+            id: playlist.id,
+            name: playlist.name,
+            creator_id: playlist.creator_id,
+
+            created_at: playlist.created_at,
+            updated_at: playlist.updated_at,
+        }
+    }
+}

src/models/tracks.rs

@@ -0,0 +1,93 @@
+use crate::helpers::db;
+use crate::schema::tracks;
+use chrono::NaiveDateTime;
+use diesel::result::Error;
+use diesel::{
+    AsChangeset, ExpressionMethods, Insertable, QueryDsl, Queryable, RunQueryDsl, Selectable,
+};
+use serde::{Deserialize, Serialize};
+
+use crate::schema::playlists_tracks;
+
+#[derive(AsChangeset, Insertable, Queryable, Selectable, Deserialize, Serialize)]
+#[diesel(table_name = crate::schema::tracks)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct Track {
+    pub id: String,
+    pub title: String,
+    pub duration_ms: i32,
+
+    pub created_at: NaiveDateTime,
+    pub updated_at: Option<NaiveDateTime>,
+
+    pub spotify_id: Option<String>,
+    pub tidal_id: Option<String>,
+}
+
+#[derive(Debug, Deserialize, Queryable, Serialize)]
+pub struct Tracks {
+    pub id: String,
+    pub title: String,
+    pub duration_ms: i32,
+
+    pub created_at: NaiveDateTime,
+    pub updated_at: Option<NaiveDateTime>,
+
+    pub spotify_id: Option<String>,
+    pub tidal_id: Option<String>,
+}
+
+impl Tracks {
+    pub fn find(id: String) -> Result<Self, Error> {
+        let conn = &mut db::connection()?;
+        let playlist = tracks::table.filter(tracks::id.eq(id)).first(conn)?;
+        Ok(playlist)
+    }
+
+    pub fn create(track: Track) -> Result<Self, Error> {
+        let conn = &mut db::connection()?;
+        let playlist = diesel::insert_into(tracks::table)
+            .values(Track::from(track))
+            .get_result(conn)?;
+        Ok(playlist)
+    }
+
+    pub fn find_by_playlist(playlist_id: &str) -> Result<Vec<Tracks>, Error> {
+        let conn = &mut db::connection()?;
+        let tracks: Vec<(String, String)> = playlists_tracks::table
+            .filter(playlists_tracks::playlist_id.eq(playlist_id))
+            .get_results::<(String, String)>(conn)?;
+
+        let tracks = tracks
+            .into_iter()
+            .map(|(playlist_id, track_id)| {
+                println!("{}: {}", playlist_id, track_id);
+                Tracks::find(track_id).unwrap()
+            })
+            .collect::<Vec<Tracks>>();
+
+        Ok(tracks)
+    }
+
+    // pub fn get_artist(&self) -> Result<Artist, Error> {
+    //     let conn = &mut db::connection();
+    //     let artist = ;
+    //     Ok(artist)
+    // }
+}
+
+impl Track {
+    fn from(track: Track) -> Track {
+        Track {
+            id: track.id,
+            title: track.title,
+            duration_ms: track.duration_ms,
+
+            created_at: track.created_at,
+            updated_at: track.updated_at,
+
+            spotify_id: track.spotify_id,
+            tidal_id: track.tidal_id,
+        }
+    }
+}

src/models/user.rs

@@ -0,0 +1,73 @@
+use crate::helpers::db;
+use crate::schema::users;
+use chrono::NaiveDateTime;
+use diesel::result::Error;
+use diesel::{
+    AsChangeset, ExpressionMethods, Insertable, QueryDsl, Queryable, RunQueryDsl, Selectable,
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(AsChangeset, Insertable, Queryable, Selectable, Deserialize, Serialize)]
+#[diesel(table_name = crate::schema::users)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct User {
+    pub id: String,
+    pub name: String,
+    pub email: String,
+
+    pub password: String,
+
+    pub updated_at: Option<NaiveDateTime>,
+    pub created_at: NaiveDateTime,
+}
+
+#[derive(Debug, Deserialize, Queryable, Serialize)]
+pub struct Users {
+    pub id: String,
+    pub name: String,
+    pub email: String,
+
+    pub password: String,
+
+    pub updated_at: Option<NaiveDateTime>,
+    pub created_at: NaiveDateTime,
+}
+
+impl Users {
+    pub fn find(id: &str) -> Result<Self, Error> {
+        let conn = &mut db::connection()?;
+        let user = users::table.filter(users::id.eq(id)).first(conn)?;
+        Ok(user)
+    }
+
+    pub fn create(user: User) -> Result<Self, Error> {
+        let conn = &mut db::connection()?;
+        let user = diesel::insert_into(users::table)
+            .values(User::from(user))
+            .get_result(conn)?;
+        Ok(user)
+    }
+
+    pub fn find_by_email(email: &str) -> Result<Self, Error> {
+        let conn = &mut db::connection()?;
+        let user = users::table.filter(users::email.eq(email)).first(conn)?;
+        Ok(user)
+    }
+
+    pub fn verify_password(password: &str, user: &Users) -> bool {
+        bcrypt::verify(password, &user.password).unwrap()
+    }
+}
+
+impl User {
+    fn from(user: User) -> User {
+        User {
+            id: user.id,
+            name: user.name,
+            email: user.email,
+            password: user.password,
+            created_at: user.created_at,
+            updated_at: user.updated_at,
+        }
+    }
+}

src/routes/auth.rs

@@ -0,0 +1,51 @@
+use crate::middlewares::error::ErrorResponse;
+use crate::models::user::Users;
+use crate::utils::get_jwt_secret;
+use actix_web::http::StatusCode;
+use actix_web::{post, web, HttpResponse};
+use jwt::SignWithKey;
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+#[post("/auth/login")]
+async fn login(body: web::Json<LoginBody>) -> Result<HttpResponse, ErrorResponse> {
+    #[derive(Deserialize, Serialize)]
+    struct Response {
+        access_token: String,
+    }
+
+    let user = Users::find_by_email(&body.email);
+    match user {
+        Ok(user) => {
+            let password = Users::verify_password(&body.password, &user);
+
+            if password == false {
+                return Err(ErrorResponse {
+                    message: "Invalid credentials.".to_string(),
+                    status: StatusCode::BAD_REQUEST,
+                });
+            }
+
+            let key = get_jwt_secret().unwrap();
+            let mut claims = BTreeMap::new();
+            claims.insert("user_id", &user.id);
+            let token_str = claims.sign_with_key(&key).unwrap();
+
+            Ok(HttpResponse::Ok().json(Response {
+                access_token: token_str,
+            }))
+        }
+        Err(_err) => {
+            return Err(ErrorResponse {
+                message: "Invalid credentials.".to_string(),
+                status: StatusCode::BAD_REQUEST,
+            })
+        }
+    }
+}
+
+#[derive(Deserialize)]
+struct LoginBody {
+    email: String,
+    password: String,
+}

src/routes/me.rs

@@ -0,0 +1,41 @@
+use crate::middlewares::error::ErrorResponse;
+use crate::middlewares::user::get_user;
+use crate::models::playlist::Playlists;
+use actix_web::{get, web, HttpRequest, HttpResponse, Scope};
+use serde::Serialize;
+
+pub fn routes() -> Scope {
+    web::scope("/me").service(me).service(me_playlists)
+}
+
+#[derive(Serialize)]
+struct Response {
+    id: String,
+    name: String,
+    email: String,
+}
+
+#[get("")]
+async fn me(req: HttpRequest) -> Result<HttpResponse, ErrorResponse> {
+    let user = get_user(req)?;
+
+    Ok(HttpResponse::Ok().json(Response {
+        id: user.id,
+        name: user.name,
+        email: user.email,
+    }))
+}
+
+#[get("/playlists")]
+async fn me_playlists(req: HttpRequest) -> Result<HttpResponse, ErrorResponse> {
+    let user = get_user(req)?;
+
+    #[derive(Serialize)]
+    struct Response {
+        playlists: Vec<Playlists>,
+    }
+
+    Ok(HttpResponse::Ok().json(Response {
+        playlists: Playlists::find_for_user(&user.id)?,
+    }))
+}

src/routes/mod.rs

@@ -0,0 +1,4 @@
+pub mod auth;
+pub mod me;
+pub mod playlists;
+pub mod users;

src/routes/playlists.rs

@@ -0,0 +1,31 @@
+use crate::middlewares::error::ErrorResponse;
+use crate::models::playlist::{PlaylistCreator, Playlists};
+use crate::models::tracks::Tracks;
+use actix_web::{get, web, HttpResponse};
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize, Serialize)]
+struct GetPlaylistResponse {
+    pub id: String,
+    pub name: String,
+    pub creator: PlaylistCreator,
+    pub tracks: Vec<Tracks>,
+}
+
+#[get("/{playlist_id}")]
+pub async fn get_playlist(path: web::Path<String>) -> Result<HttpResponse, ErrorResponse> {
+    let playlist_id = path.into_inner();
+    let playlist = Playlists::find(playlist_id.as_str())?;
+
+    let creator = playlist.get_creator()?;
+
+    Ok(HttpResponse::Ok().json(GetPlaylistResponse {
+        id: playlist.id.to_string(),
+        name: playlist.name.to_string(),
+        creator: PlaylistCreator {
+            id: creator.id,
+            name: creator.name,
+        },
+        tracks: playlist.get_tracks()?,
+    }))
+}

src/routes/users.rs

@@ -0,0 +1,38 @@
+use crate::middlewares::error::ErrorResponse;
+use crate::models::user::Users;
+use actix_web::http::StatusCode;
+use actix_web::{get, web, HttpResponse, Result};
+use diesel::result::Error as DBError;
+use serde::Serialize;
+
+#[derive(Serialize)]
+struct GetUserResponse {
+    id: String,
+    name: String,
+}
+
+#[get("/{user_id}")]
+async fn get_user(path: web::Path<String>) -> Result<HttpResponse, ErrorResponse> {
+    let user_id = path.into_inner();
+
+    let user = Users::find(user_id.as_str());
+
+    match user {
+        Ok(user) => Ok(HttpResponse::Ok().json(GetUserResponse {
+            id: user.id,
+            name: user.name,
+        })),
+        Err(DBError::NotFound) => {
+            return Err(ErrorResponse {
+                message: "User not found".to_string(),
+                status: StatusCode::NOT_FOUND,
+            })
+        }
+        _ => {
+            return Err(ErrorResponse {
+                message: "Unknown error".to_string(),
+                status: StatusCode::INTERNAL_SERVER_ERROR,
+            })
+        }
+    }
+}

src/schema.rs

@@ -0,0 +1,64 @@
+// @generated automatically by Diesel CLI.
+
+diesel::table! {
+    playlists (id) {
+        #[max_length = 24]
+        id -> Varchar,
+        #[max_length = 255]
+        name -> Varchar,
+        #[max_length = 24]
+        creator_id -> Varchar,
+        created_at -> Timestamp,
+        updated_at -> Nullable<Timestamp>,
+    }
+}
+
+diesel::table! {
+    playlists_tracks (playlist_id, track_id) {
+        #[max_length = 24]
+        playlist_id -> Varchar,
+        #[max_length = 24]
+        track_id -> Varchar,
+    }
+}
+
+diesel::table! {
+    tracks (id) {
+        #[max_length = 24]
+        id -> Varchar,
+        #[max_length = 255]
+        title -> Varchar,
+        duration_ms -> Int4,
+        created_at -> Timestamp,
+        updated_at -> Nullable<Timestamp>,
+        #[max_length = 21]
+        spotify_id -> Nullable<Varchar>,
+        #[max_length = 10]
+        tidal_id -> Nullable<Varchar>,
+    }
+}
+
+diesel::table! {
+    users (id) {
+        #[max_length = 24]
+        id -> Varchar,
+        #[max_length = 255]
+        name -> Varchar,
+        #[max_length = 255]
+        email -> Varchar,
+        password -> Text,
+        updated_at -> Nullable<Timestamp>,
+        created_at -> Timestamp,
+    }
+}
+
+diesel::joinable!(playlists -> users (creator_id));
+diesel::joinable!(playlists_tracks -> playlists (playlist_id));
+diesel::joinable!(playlists_tracks -> tracks (track_id));
+
+diesel::allow_tables_to_appear_in_same_query!(
+    playlists,
+    playlists_tracks,
+    tracks,
+    users,
+);

src/utils.rs

@@ -0,0 +1,8 @@
+use hmac::{Hmac, Mac};
+use sha2::Sha256;
+use std::error::Error;
+
+pub fn get_jwt_secret() -> Result<Hmac<Sha256>, Box<dyn Error>> {
+    let key: Hmac<Sha256> = Hmac::new_from_slice(b"secret")?;
+    Ok(key)
+}