Merge branch '29-implement-admin-user-permission-flag' into 'main'

Implement admin user permission flag Closes #29 See merge request libretunes/libretunes!28
Add auth functions for checking admin status
2024-05-19 12:43:51 -04:00 · 2024-05-19 12:20:50 -04:00 · 2024-05-19 10:45:50 -04:00 · 2024-05-19 10:45:45 -04:00 · 2024-05-18 20:29:27 -04:00 · 2024-05-18 18:51:59 -04:00
37 changed files with 1180 additions and 1075 deletions
--- a/.dockerignore
+++ b/.dockerignore
@ -8,3 +8,4 @@
 !/style
 !/Cargo.lock
 !/Cargo.toml
 !/ascii_art.txt
--- a/Cargo.lock
+++ b/Cargo.lock
@ -44,6 +44,21 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5"
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
 dependencies = [
 "libc",
 ]
 [[package]]
 name = "anyhow"
 version = "1.0.81"
@ -56,6 +71,12 @@ version = "1.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457"
 [[package]]
 name = "arrayvec"
 version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
 [[package]]
 name = "async-recursion"
 version = "1.1.0"
@ -138,15 +159,11 @@ dependencies = [
 "pin-project-lite",
 "rustversion",
 "serde",
 "serde_json",
 "serde_path_to_error",
 "serde_urlencoded",
 "sync_wrapper 1.0.0",
 "tokio",
 "tower",
 "tower-layer",
 "tower-service",
 "tracing",
 ]
 [[package]]
@ -167,7 +184,6 @@ dependencies = [
 "sync_wrapper 0.1.2",
 "tower-layer",
 "tower-service",
 "tracing",
 ]
 [[package]]
@ -244,6 +260,12 @@ version = "3.15.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ff69b9dd49fd426c69a0db9fc04dd934cdb6645ff000864d98f7e2af8830eaa"
 [[package]]
 name = "bytemuck"
 version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d6d68c57235a3a081186990eca2867354726650f42f7516ca50c28d6281fd15"
 [[package]]
 name = "byteorder"
 version = "1.5.0"
@ -316,6 +338,18 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 [[package]]
 name = "chrono"
 version = "0.4.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e"
 dependencies = [
 "android-tzdata",
 "iana-time-zone",
 "num-traits",
 "windows-targets 0.52.4",
 ]
 [[package]]
 name = "ciborium"
 version = "0.2.2"
@ -422,6 +456,12 @@ dependencies = [
 "futures",
 ]
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
 [[package]]
 name = "cpufeatures"
 version = "0.2.12"
@ -613,6 +653,18 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 [[package]]
 name = "flexi_logger"
 version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f248c29a6d4bc5d065c9e9068d858761a0dcd796759f7801cc14db35db23abd8"
 dependencies = [
 "chrono",
 "glob",
 "log",
 "thiserror",
 ]
 [[package]]
 name = "float-cmp"
 version = "0.9.0"
@ -796,6 +848,12 @@ version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
 [[package]]
 name = "glob"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
 [[package]]
 name = "gloo-net"
 version = "0.5.0"
@ -965,6 +1023,29 @@ dependencies = [
 "tokio",
 ]
 [[package]]
 name = "iana-time-zone"
 version = "0.1.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
 dependencies = [
 "android_system_properties",
 "core-foundation-sys",
 "iana-time-zone-haiku",
 "js-sys",
 "wasm-bindgen",
 "windows-core",
 ]
 [[package]]
 name = "iana-time-zone-haiku"
 version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
 dependencies = [
 "cc",
 ]
 [[package]]
 name = "icondata"
 version = "0.3.0"
@ -1501,7 +1582,7 @@ dependencies = [
 "diesel",
 "diesel_migrations",
 "dotenv",
- "futures",
+ "flexi_logger",
 "http",
 "icondata",
 "lazy_static",
@ -1510,17 +1591,21 @@ dependencies = [
 "leptos_icons",
 "leptos_meta",
 "leptos_router",
 "log",
 "multer",
 "openssl",
 "pbkdf2",
 "serde",
 "server_fn",
 "symphonia",
 "thiserror",
 "time",
 "tokio",
 "tower",
 "tower-http",
 "tower-sessions",
 "tower-sessions-redis-store",
 "wasm-bindgen",
 "web-sys",
 ]
 [[package]]
@ -2245,16 +2330,6 @@ dependencies = [
 "serde",
 ]
 [[package]]
 name = "serde_path_to_error"
 version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af99884400da37c88f5e9146b7f1fd0fbcae8f6eec4e9da38b67d05486f814a6"
 dependencies = [
 "itoa",
 "serde",
 ]
 [[package]]
 name = "serde_qs"
 version = "0.12.0"
@ -2284,23 +2359,11 @@ dependencies = [
 "serde",
 ]
 [[package]]
 name = "serde_urlencoded"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
 dependencies = [
 "form_urlencoded",
 "itoa",
 "ryu",
 "serde",
 ]
 [[package]]
 name = "server_fn"
-version = "0.6.10"
+version = "0.6.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15a46a2ffdecb81430ecfb995989218a18b6e94c1ead50cb806b5927c986a8ce"
+checksum = "536a5b959673643ee01e59ae41bf01425482c8070dee95d7061ee2d45296b59c"
 dependencies = [
 "axum",
 "bytes",
@ -2314,6 +2377,7 @@ dependencies = [
 "hyper",
 "inventory",
 "js-sys",
 "multer",
 "once_cell",
 "send_wrapper",
 "serde",
@ -2419,6 +2483,55 @@ version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
 [[package]]
 name = "symphonia"
 version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "815c942ae7ee74737bb00f965fa5b5a2ac2ce7b6c01c0cc169bbeaf7abd5f5a9"
 dependencies = [
 "lazy_static",
 "symphonia-bundle-mp3",
 "symphonia-core",
 "symphonia-metadata",
 ]
 [[package]]
 name = "symphonia-bundle-mp3"
 version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c01c2aae70f0f1fb096b6f0ff112a930b1fb3626178fba3ae68b09dce71706d4"
 dependencies = [
 "lazy_static",
 "log",
 "symphonia-core",
 "symphonia-metadata",
 ]
 [[package]]
 name = "symphonia-core"
 version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "798306779e3dc7d5231bd5691f5a813496dc79d3f56bf82e25789f2094e022c3"
 dependencies = [
 "arrayvec",
 "bitflags 1.3.2",
 "bytemuck",
 "lazy_static",
 "log",
 ]
 [[package]]
 name = "symphonia-metadata"
 version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bc622b9841a10089c5b18e99eb904f4341615d5aa55bbf4eedde1be721a4023c"
 dependencies = [
 "encoding_rs",
 "lazy_static",
 "log",
 "symphonia-core",
 ]
 [[package]]
 name = "syn"
 version = "1.0.109"
@ -3066,6 +3179,15 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 [[package]]
 name = "windows-core"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
 dependencies = [
 "windows-targets 0.52.4",
 ]
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
--- a/Cargo.toml
+++ b/Cargo.toml
@ -8,41 +8,50 @@ build = "src/build.rs"
 crate-type = ["cdylib", "rlib"]
 [dependencies]
-console_error_panic_hook = "0.1"
+console_error_panic_hook = { version = "0.1", optional = true }
 cfg-if = "1"
-http = "1.0"
+http = { version = "1.0", default-features = false }
-leptos = { version = "0.6", features = ["nightly"] }
+leptos = { version = "0.6", default-features = false, features = ["nightly"] }
 leptos_meta = { version = "0.6", features = ["nightly"] }
 leptos_axum = { version = "0.6", optional = true }
 leptos_router = { version = "0.6", features = ["nightly"] }
-wasm-bindgen = "=0.2.92"
+wasm-bindgen = { version = "=0.2.92", default-features = false, optional = true }
 leptos_icons = { version = "0.3.0" }
 icondata = { version = "0.3.0" }
 dotenv = { version = "0.15.0", optional = true }
-diesel = { version = "2.1.4", features = ["postgres", "r2d2", "time"], optional = true }
+diesel = { version = "2.1.4", features = ["postgres", "r2d2", "time"], default-features = false, optional = true }
 lazy_static = { version = "1.4.0", optional = true }
-serde = { versions = "1.0.195", features = ["derive"] }
+serde = { version = "1.0.195", features = ["derive"], default-features = false }
 openssl = { version = "0.10.63", optional = true }
-time = { version = "0.3.34", features = ["serde"] }
+time = { version = "0.3.34", features = ["serde"], default-features = false }
 diesel_migrations = { version = "2.1.0", optional = true }
 pbkdf2 = { version = "0.12.2", features = ["simple"], optional = true }
 futures = { version = "0.3.30", default-features = false, optional = true }
 tokio = { version = "1", optional = true, features = ["rt-multi-thread"] }
-axum = { version = "0.7.5", optional = true }
+axum = { version = "0.7.5", features = ["tokio", "http1"], default-features = false, optional = true }
-tower = { veresion = "0.4.13", optional = true }
+tower = { version = "0.4.13", optional = true }
 tower-http = { version = "0.5", optional = true, features = ["fs"] }
 thiserror = "1.0.57"
 tower-sessions = { version = "0.11", default-features = false }
 tower-sessions-redis-store = { version = "0.11", optional = true }
-async-trait = "0.1.79"
+async-trait = { version = "0.1.79", optional = true }
 axum-login = { version = "0.14.0", optional = true }
 server_fn = { version = "0.6.11", features = ["multipart"] }
 symphonia = { version = "0.5.4", default-features = false, features = ["mp3"], optional = true }
 multer = { version = "3.0.0", optional = true }
 log = { version = "0.4.21", optional = true }
 flexi_logger = { version = "0.28.0", optional = true, default-features = false }
 web-sys = "0.3.69"
 [patch.crates-io]
 gloo-net = { git = "https://github.com/rustwasm/gloo.git", rev = "a823fab7ecc4068e9a28bd669da5eaf3f0a56380" }
 [features]
-csr = ["leptos/csr", "leptos_meta/csr", "leptos_router/csr"]
+hydrate = [
-hydrate = ["leptos/hydrate", "leptos_meta/hydrate", "leptos_router/hydrate"]
+  "leptos/hydrate",
  "leptos_meta/hydrate",
  "leptos_router/hydrate",
  "console_error_panic_hook",
  "wasm-bindgen",
 ]
 ssr = [
  "dep:leptos_axum",
  "leptos/ssr",
@ -54,13 +63,17 @@ ssr = [
  "openssl",
  "diesel_migrations",
  "pbkdf2",
  "futures",
  "tokio",
  "axum",
  "tower",
  "tower-http",
  "tower-sessions-redis-store",
  "async-trait",
  "axum-login",
  "symphonia",
  "multer",
  "log",
  "flexi_logger",
 ]
 # Defines a size-optimized profile for the WASM bundle in release mode
--- a/1
+++ b/1
@ -32,6 +32,7 @@ COPY style /app/style
 # Minify CSS
 RUN npx tailwindcss -i /app/style/main.scss -o /app/style/main.scss --minify
 COPY ascii_art.txt /app/ascii_art.txt
 COPY assets /app/assets
 COPY src /app/src
 COPY migrations /app/migrations
--- a/ascii_art.txt
+++ b/ascii_art.txt
@ -0,0 +1,10 @@
                                                         .-=.  =+==-.    
                                                       .=++++. =+++++=.  
  _      _ _           _______                        =++++++= :*++++++= 
 | |    (_) |         |__   __|                      -++++**+.  -+**++++-
 | |     _| |__  _ __ ___| |_   _ _ __   ___  ___    *+++**+      +**+++*
 | |    | | '_ \| '__/ _ \ | | | | '_ \ / _ \/ __|   *+++**+      +**+++*
 | |____| | |_) | | |  __/ | |_| | | | |  __/\__ \   -++++**+-:  +**++++-
 |______|_|_.__/|_|  \___|_|\__,_|_| |_|\___||___/    =++++++**+ -+++++= 
                                                       .=+++++++=.+++=.  
                                                         .-==++++---.    
--- a/migrations/2024-04-13-024749_create_playlists_table/down.sql
+++ b/migrations/2024-04-13-024749_create_playlists_table/down.sql
@ -1,2 +0,0 @@
 -- This file should undo anything in `up.sql`
 DROP TABLE playlists;
--- a/migrations/2024-04-13-024749_create_playlists_table/up.sql
+++ b/migrations/2024-04-13-024749_create_playlists_table/up.sql
@ -1,13 +0,0 @@
 -- Your SQL goes here
 CREATE TABLE playlists (
    id SERIAL PRIMARY KEY UNIQUE NOT NULL,
    name VARCHAR NOT NULL,
    user_id INTEGER REFERENCES users(id) ON DELETE CASCADE NOT NULL
 );
 CREATE TABLE playlist_songs (
    playlist_id INTEGER REFERENCES playlists(id) ON DELETE CASCADE NOT NULL,
    song_id INTEGER REFERENCES songs(id) ON DELETE CASCADE NOT NULL,
    position INTEGER NOT NULL,
    PRIMARY KEY (playlist_id, song_id)
 );
--- a/migrations/2024-05-16-220659_add_album_images/down.sql
+++ b/migrations/2024-05-16-220659_add_album_images/down.sql
@ -0,0 +1 @@
 ALTER TABLE albums DROP COLUMN image_path;
--- a/migrations/2024-05-16-220659_add_album_images/up.sql
+++ b/migrations/2024-05-16-220659_add_album_images/up.sql
@ -0,0 +1 @@
 ALTER TABLE albums ADD COLUMN image_path VARCHAR;
--- a/migrations/2024-05-18-231505_add_user_admin/down.sql
+++ b/migrations/2024-05-18-231505_add_user_admin/down.sql
@ -0,0 +1 @@
 ALTER TABLE users DROP COLUMN admin;
--- a/migrations/2024-05-18-231505_add_user_admin/up.sql
+++ b/migrations/2024-05-18-231505_add_user_admin/up.sql
@ -0,0 +1 @@
 ALTER TABLE users ADD COLUMN admin BOOLEAN DEFAULT FALSE NOT NULL;
--- a/src/api/mod.rs
+++ b/src/api/mod.rs
@ -1,2 +0,0 @@
 pub mod playlists;
 pub mod songs;
--- a/src/api/playlists.rs
+++ b/src/api/playlists.rs
@ -1,157 +0,0 @@
 use leptos::*;
 use crate::models::Playlist;
 use cfg_if::cfg_if;
 cfg_if! {
    if #[cfg(feature = "ssr")] {
        use crate::database::get_db_conn;
        use diesel::prelude::*;
        use leptos_axum::extract;
        use axum_login::AuthSession;
        use crate::auth_backend::AuthBackend;
    }
 }
 /// Create a new, empty playlist in the database
 /// 
 /// # Arguments
 /// 
 /// * `new_playlist` - The new playlist
 /// * `conn` - A mutable reference to a database connection
 /// 	
 /// # Returns
 /// 
 /// * `Result<(), Box<dyn Error>>` - A empty result if successful, or an error
 /// 
 #[server(endpoint = "playlists/create-playlist")]
 pub async fn create_playlist(playlist_name: String)->Result<(), ServerFnError> {
    use crate::schema::playlists::dsl::*;
    use leptos::server_fn::error::NoCustomError;
    let auth_session = extract::<AuthSession<AuthBackend>>().await
 		.map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error getting auth session: {}", e)))?;
    //Ensure the playlist has no id
    let new_playlist = Playlist {
        id: None,
        name: playlist_name,
        user_id: auth_session.user.unwrap().id.expect("User has no id"),
    };
    let db_con = &mut get_db_conn();
    diesel::insert_into(playlists)
        .values(&new_playlist)
        .execute(db_con)
        .map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error creating playlist: {}", e)))?;
    Ok(())
 }
 /// Get all playlists for the current user
 /// 
 /// # Returns
 /// 
 /// * `Result<Vec<Playlist>, ServerFnError>` - A vector of playlists if successful, or an error
 /// 
 #[server(endpoint = "playlists/get-playlists")]
 pub async fn get_playlists() -> Result<Vec<Playlist>, ServerFnError> {
    use crate::schema::playlists::dsl::*;
    use leptos::server_fn::error::NoCustomError;
    let auth_session = extract::<AuthSession<AuthBackend>>().await
 		.map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error getting auth session: {}", e)))?;
    let other_user_id = auth_session.user.unwrap().id.expect("User has no id");
    let db_con = &mut get_db_conn();
    let results = playlists
        .filter(user_id.eq(other_user_id))
        .load::<Playlist>(db_con)
        .map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error getting playlists: {}", e)))?;
    Ok(results)
 }
 /// Add a song to a playlist
 /// 
 /// # Arguments
 /// 
 /// * `playlist_id` - The id of the playlist
 /// * `song_id` - The id of the song
 /// 
 /// # Returns
 /// 
 /// * `Result<(), ServerFnError>` - An empty result if successful, or an error
 /// 
 #[server(endpoint = "playlists/add-song")]
 pub async fn add_song(new_playlist_id: Option<i32>, new_song_id: Option<i32>) -> Result<(), ServerFnError> {
    use crate::schema::playlist_songs::dsl::*;
    use leptos::server_fn::error::NoCustomError;
    let other_playlist_id = new_playlist_id.ok_or(ServerFnError::<NoCustomError>::ServerError("Playlist id must be present (Some) to add song".to_string()))?;
    let other_song_id = new_song_id.ok_or(ServerFnError::<NoCustomError>::ServerError("Song id must be present (Some) to add song".to_string()))?;
    let db_con = &mut get_db_conn();
    diesel::insert_into(playlist_songs)
        .values((playlist_id.eq(other_playlist_id), song_id.eq(other_song_id)))
        .execute(db_con)
        .map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error adding song to playlist: {}", e)))?;
    Ok(())
 }
 /// Get songs from a playlist
 /// 
 /// # Arguments
 /// 
 /// * `playlist_id` - The id of the playlist
 /// 
 /// # Returns
 /// 
 /// * `Result<Vec<Song>, ServerFnError>` - A vector of songs if successful, or an error
 /// 
 #[server(endpoint = "playlists/get-songs")]
 pub async fn get_songs(new_playlist_id: Option<i32>) -> Result<Vec<crate::models::Song>, ServerFnError> {
    use crate::schema::playlist_songs::dsl::*;
    use crate::schema::songs::dsl::*;
    use leptos::server_fn::error::NoCustomError;
    let other_playlist_id = new_playlist_id.ok_or(ServerFnError::<NoCustomError>::ServerError("Playlist id must be present (Some) to get songs".to_string()))?;
    let db_con = &mut get_db_conn();
    let results = playlist_songs
        .inner_join(songs)
        .filter(playlist_id.eq(other_playlist_id))
        .select(songs::all_columns())
        .order_by(position)
        .load(db_con)
        .map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error getting songs from playlist: {}", e)))?;
    Ok(results)
 }
 /// Remove a song from a playlist
 /// 
 /// # Arguments
 /// 
 /// * `playlist_id` - The id of the playlist
 /// * `song_id` - The id of the song
 /// 
 /// # Returns
 ///    
 /// * `Result<(), ServerFnError>` - An empty result if successful, or an error
 ///
 #[server(endpoint = "playlists/remove-song")]
 pub async fn remove_song(new_playlist_id: Option<i32>, new_song_id: Option<i32>) -> Result<(), ServerFnError> {
    use crate::schema::playlist_songs::dsl::*;
    use leptos::server_fn::error::NoCustomError;
    let other_playlist_id = new_playlist_id.ok_or(ServerFnError::<NoCustomError>::ServerError("Playlist id must be present (Some) to remove song".to_string()))?;
    let other_song_id = new_song_id.ok_or(ServerFnError::<NoCustomError>::ServerError("Song id must be present (Some) to remove song".to_string()))?;
    let db_con = &mut get_db_conn();
    diesel::delete(playlist_songs.filter(playlist_id.eq(other_playlist_id).and(song_id.eq(other_song_id))))
        .execute(db_con)
        .map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error removing song from playlist: {}", e)))?;
    Ok(())
 } 
--- a/src/api/songs.rs
+++ b/src/api/songs.rs
@ -1,37 +0,0 @@
 use leptos::*;
 use crate::models::Artist;
 use cfg_if::cfg_if;
 cfg_if! {
 if #[cfg(feature = "ssr")] {
 	use crate::database::get_db_conn;
 	use diesel::prelude::*;
 }
 }
 /// Gets a Vector of Artists associated with a Song
 /// 
 /// # Arguments
 /// `song_id_arg` - The id of the Song to get the Artists for
 /// 
 /// # Returns
 /// A Result containing a Vector of Artists if the operation was successful, or an error if the operation failed
 #[server(endpoint = "songs/get-artists")]
 pub async fn get_artists(song_id_arg: Option<i32>) -> Result<Vec<Artist>, ServerFnError> {
 	use crate::schema::artists::dsl::*;
 	use crate::schema::song_artists::dsl::*;
    use leptos::server_fn::error::NoCustomError;
 	let other_song_id = song_id_arg.ok_or(ServerFnError::<NoCustomError>::ServerError("Song id must be present (Some) to get artists".to_string()))?;
 	let my_artists = artists
 		.inner_join(song_artists)
 		.filter(song_id.eq(other_song_id))
 		.select(artists::all_columns())
 		.load(&mut get_db_conn())?;
 	Ok(my_artists)
 }
--- a/src/app.rs
+++ b/src/app.rs
@ -1,19 +1,23 @@
 use crate::error_template::{AppError, ErrorTemplate};
 use crate::pages::login::*;
 use crate::pages::signup::*;
 use crate::playbar::PlayBar;
 use crate::playstatus::PlayStatus;
 use crate::queue::Queue;
 use leptos::*;
 use leptos_meta::*;
 use leptos_router::*;
-use leptos::leptos_dom::*;
+use crate::pages::login::*;
 use crate::pages::signup::*;
 use crate::error_template::{AppError, ErrorTemplate};
 #[component]
 pub fn App() -> impl IntoView {
    // Provides context that manages stylesheets, titles, meta tags, etc.
    provide_meta_context();
    let play_status = PlayStatus::default();
    let play_status = create_rw_signal(play_status);
    let upload_open = create_rw_signal(false);
    view! {
        // injects a stylesheet into the document <head>
        // id=leptos means cargo-leptos will hot-reload this stylesheet
@ -33,7 +37,11 @@ pub fn App() -> impl IntoView {
        }>
            <main>
                <Routes>
-                    <Route path="" view=HomePage/>
+                    <Route path="" view=move || view! { <HomePage play_status=play_status upload_open=upload_open/> }>
                        <Route path="" view=Dashboard />
                        <Route path="dashboard" view=Dashboard />
                        <Route path="search" view=Search />
                    </Route>
                    <Route path="/login" view=Login />
                    <Route path="/signup" view=Signup />
                </Routes>
@ -42,49 +50,22 @@ pub fn App() -> impl IntoView {
    }
 }
 use crate::components::dashboard::*;
 use crate::components::personal::*;
 use crate::components::search::*;
 use crate::components::sidebar::*;
 use crate::components::dashboard::*;
 use crate::components::search::*;
 use crate::components::personal::*;
 use crate::components::upload::*;
 /// Renders the home page of your application.
 #[component]
-fn HomePage() -> impl IntoView {
+fn HomePage(play_status: RwSignal<PlayStatus>, upload_open: RwSignal<bool>) -> impl IntoView {
    use crate::auth::check_auth;
    let play_status = PlayStatus::default();
    let play_status = create_rw_signal(play_status);
    let (logged_in, set_logged_in) = create_signal(false);
    let (dashboard_open, set_dashboard_open) = create_signal(true);
    create_effect(move |_| {
        spawn_local(async move {
            let auth_result = check_auth().await;
            if let Err(err) = auth_result {
                log!("Error checking auth: {:?}", err);
            } else if let Ok(true) = auth_result {
                log!("User is logged in");
                set_logged_in.update(|value| *value = true);
            } else if let Ok(false) = auth_result {
                log!("User is not logged in");
                set_logged_in.update(|value| *value = false);
            }
        });
    });
    view! {
        <div class="home-container">
-            <Sidebar setter=set_dashboard_open active=dashboard_open logged_in=logged_in/>
+            <Upload open=upload_open/>
-            <Show
+            <Sidebar upload_open=upload_open/>
-                when=move || {dashboard_open() == true}
+            // This <Outlet /> will render the child route components
-                fallback=move || view! { <Search /> }
+            <Outlet />
-            >
+            <Personal />
                <Dashboard />
            </Show>
            <Personal logged_in=logged_in/>
            <PlayBar status=play_status/>
            <Queue status=play_status/>
        </div>
--- a/src/auth.rs
+++ b/src/auth.rs
@ -21,9 +21,10 @@ use crate::users::UserCredentials;
 pub async fn signup(new_user: User) -> Result<(), ServerFnError> {
 	use crate::users::create_user;
-	// Ensure the user has no id
+	// Ensure the user has no id, and is not a self-proclaimed admin
 	let new_user = User {
 		id: None,
 		admin: false,
 		..new_user
 	};
@ -120,3 +121,37 @@ pub async fn require_auth() -> Result<(), ServerFnError> {
 		}
 	})
 }
 /// Check if a user is an admin
 /// Returns a Result with a boolean indicating if the user is logged in and an admin
 #[server(endpoint = "check_admin")]
 pub async fn check_admin() -> Result<bool, ServerFnError> {
 	let auth_session = extract::<AuthSession<AuthBackend>>().await
 		.map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error getting auth session: {}", e)))?;
 	Ok(auth_session.user.as_ref().map(|u| u.admin).unwrap_or(false))
 }
 /// Require that a user is logged in and an admin
 /// Returns a Result with the error message if the user is not logged in or is not an admin
 /// Intended to be used at the start of a protected route, to ensure the user is logged in and an admin:
 /// ```rust
 /// use leptos::*;
 /// use libretunes::auth::require_admin;
 /// #[server(endpoint = "protected_admin_route")]
 /// pub async fn protected_admin_route() -> Result<(), ServerFnError> {
 /// 	require_admin().await?;
 /// 	// Continue with protected route
 /// 	Ok(())
 /// }
 /// ```
 #[cfg(feature = "ssr")]
 pub async fn require_admin() -> Result<(), ServerFnError> {
 	check_admin().await.and_then(|is_admin| {
 		if is_admin {
 			Ok(())
 		} else {
 			Err(ServerFnError::<NoCustomError>::ServerError(format!("Unauthorized")))
 		}
 	})
 }
--- a/src/auth_backend.rs
+++ b/src/auth_backend.rs
@ -1,10 +1,17 @@
 use async_trait::async_trait;
 use axum_login::{AuthnBackend, AuthUser, UserId};
 use crate::users::UserCredentials;
 use leptos::server_fn::error::ServerFnErrorErr;
 use crate::models::User;
 use cfg_if::cfg_if;
 cfg_if! {
 	if #[cfg(feature = "ssr")] {
 		use async_trait::async_trait;
 	}
 }
 impl AuthUser for User {
 	type Id = i32;
--- a/src/components.rs
+++ b/src/components.rs
@ -2,6 +2,4 @@ pub mod sidebar;
 pub mod dashboard;
 pub mod search;
 pub mod personal;
-pub mod playlist;
+pub mod upload;
 pub mod create_playlist;
 pub mod playlists;
--- a/src/components/create_playlist.rs
+++ b/src/components/create_playlist.rs
@ -1,53 +0,0 @@
 use leptos::*;
 use leptos_icons::*;
 use leptos::leptos_dom::*;
 use crate::api::playlists::create_playlist;
 use crate::api::playlists::get_playlists;
 use crate::models::Playlist;
 #[component]
 pub fn CreatePlayList(closer: WriteSignal<bool>, set_playlists: WriteSignal<Vec<Playlist>>) -> impl IntoView {
    let (playlist_name, set_playlist_name) = create_signal("".to_string());
    let on_submit = move |ev: leptos::ev::SubmitEvent| {
        ev.prevent_default();
        let new_playlist_name = playlist_name.get();
        spawn_local(async move {
            let create_result = create_playlist(new_playlist_name).await;
            if let Err(err) = create_result {
                // Handle the error here, e.g., log it or display to the user
                log!("Error creating playlist: {:?}", err);
            } else {
                log!("Playlist created successfully!");
                closer.update(|value| *value = false);
            }
            let playlists = get_playlists().await;
            if let Err(err) = playlists {
                // Handle the error here, e.g., log it or display to the user
                log!("Error getting playlists: {:?}", err);
            } else {
                set_playlists.update(|value| *value = playlists.unwrap());
            }
        })
    }; 
    view! {
        <div class="create-playlist-popup-container">
            <div class="close-button" on:click=move |_| closer.update(|value| *value = false)>
                <Icon icon=icondata::IoCloseSharp />
            </div>
            <h1 class="header">Create Playlist</h1>    
            <form class="create-playlist-form" action="POST" on:submit=on_submit>
                <input class="name-input"  type="text" placeholder="Playlist Name" 
                    on:input=move |ev| {
                        set_playlist_name(event_target_value(&ev));
                        log!("playlist name changed to: {}", playlist_name.get());
                    }
                    prop:value=playlist_name
                />
                <button class="create-button" type="submit">Create</button>
            </form>
        </div>
    }
 }
--- a/src/components/personal.rs
+++ b/src/components/personal.rs
@ -3,17 +3,16 @@ use leptos::*;
 use leptos_icons::*;
 #[component]
-pub fn Personal(logged_in: ReadSignal<bool>) -> impl IntoView {
+pub fn Personal() -> impl IntoView {
    view! {
        <div class=" personal-container">
-            <Profile logged_in=logged_in/>
+            <Profile />
        </div>
    }
 }
 #[component]
-pub fn Profile(logged_in: ReadSignal<bool>) -> impl IntoView {
+pub fn Profile() -> impl IntoView {
    let (dropdown_open, set_dropdown_open) = create_signal(false);
    let open_dropdown = move |_| {
@ -26,13 +25,7 @@ pub fn Profile(logged_in: ReadSignal<bool>) -> impl IntoView {
                <Icon icon=icondata::CgProfile />
            </div>
            <div class="dropdown-container" style={move || if dropdown_open() {"display: flex"} else {"display: none"}}>
-            <Show 
+                <DropDownNotLoggedIn />
                when=move || {logged_in() == true}
                fallback=move || view!{<DropDownNotLoggedIn />}
            >
                <DropDownLoggedIn/>
            </Show>
            </div>
        </div>
    }
@ -47,26 +40,3 @@ pub fn DropDownNotLoggedIn() -> impl IntoView {
        </div>
    }
 }
 #[component]
 pub fn DropDownLoggedIn() -> impl IntoView {
    use crate::auth::logout;
    let logout = move |_ev: leptos::ev::MouseEvent| {
        spawn_local(async move {
            let _logout_result = logout().await;
            if let Err(err) = _logout_result {
                log!("Error logging out: {:?}", err);
            } else {
                log!("Logged out Successfully!");
                leptos_router::use_navigate()("/login", Default::default());
            }
        });
    };
    view! {
        <div class="dropdown-logged-in">
            <h1>Logged in!</h1>
            <button on:click=logout class="auth-button">Log Out</button>
        </div>
    }
 }
--- a/src/components/playlist.rs
+++ b/src/components/playlist.rs
@ -1,162 +0,0 @@
 use leptos::*;
 use leptos_icons::*;
 use leptos::leptos_dom::*;
 use crate::models::Playlist;
 use crate::models::Song;
 use crate::api::playlists::get_songs;
 use crate::api::songs::get_artists;
 use crate::api::playlists::remove_song;
 fn total_duration(songs: ReadSignal<Vec<Song>>) -> i32 {
    let mut total_duration = 0;
    for song in songs.get() {
        total_duration += song.duration;
    }
    total_duration
 }
 fn convert_seconds(seconds: i32) -> String {
    let minutes = seconds / 60;
    let seconds = seconds % 60;
    let seconds_string = if seconds < 10 {
        format!("0{}", seconds)
    } else {
        format!("{}", seconds)
    };
    format!("{}:{}", minutes, seconds_string)
 }
 fn convert_to_text_time(seconds: i32) -> String {
    let hours = seconds / 3600;
    let minutes = (seconds % 3600) / 60;
    format!("{} hour{}, {} minute{}", hours, if hours > 1 { "s" } else { "" }, minutes, if minutes > 1 { "s" } else { "" })
 }
 #[component]
 pub fn Playlist(playlist: Playlist) -> impl IntoView {
    let (show_playlist, set_show_playlist) = create_signal(false);
    view! {
        <div class="playlist" on:click=move|_| set_show_playlist.update(|value| *value=true) >
            <h1 class="name">{playlist.name.clone()}</h1>
            <Show
                when=move || show_playlist()
                fallback=move || view! {<div></div>}
            >
                <div class="screen-darkener"></div>
            </Show>
            <Show
                when=move || show_playlist()
                fallback=move || view! {<div></div>}
            >
                <PlayListPopUp playlist=playlist.clone() set_show_playlist=set_show_playlist />
            </Show>
        </div>
    }
 }
 #[component]
 pub fn PlayListPopUp(playlist: Playlist, set_show_playlist: WriteSignal<bool>) -> impl IntoView {
    let (songs, set_songs) = create_signal(vec![]);
    create_effect(move |_| {
        spawn_local(async move {
            let playlist_songs = get_songs(playlist.id.clone()).await;
            if let Err(err) = playlist_songs {
                // Handle the error here, e.g., log it or display to the user
                log!("Error getting songs: {:?}", err);
            } else {
                log!("Songs: {:?}", playlist_songs);
                log!("number of songs: {:?}", playlist_songs.clone().expect("REASON").len());
                set_songs.update(|value| *value = playlist_songs.unwrap());
            }
        })
    });
    view! {
        <div class="playlist-container">
            <div class="close-button" on:click=move |_| set_show_playlist.update(|value| *value = false)>
                <Icon icon=icondata::IoCloseSharp />
            </div>
            <div class="info">
                <h1>{playlist.name.clone()}</h1>
                <p>{move || songs.get().len()} songs {move || convert_to_text_time(total_duration(songs))}</p>
            </div>
            <div class="options">
                <button><Icon class="button-icons" icon=icondata::BsPlayFill />Play</button>
                <button><Icon class="button-icons" icon=icondata::IoShuffle />Shuffle</button>
            </div>
            <ul class="songs">
                {
                    move || songs.get().iter().enumerate().map(|(_index,song)| view! {
                        <PlaylistSong song=song.clone()  playlist_id=playlist.id.clone() set_songs=set_songs />
                    }).collect::<Vec<_>>()
                }
            </ul>
        </div>
    }
 }
 #[component]
 pub fn PlaylistSong(song: Song, playlist_id: Option<i32>, set_songs: WriteSignal<Vec<Song>>) -> impl IntoView {
    let (artists, set_artists) = create_signal("".to_string());
    let (is_hovered, set_is_hovered) = create_signal(false);
    let delete_song = move |_| {
        spawn_local(async move {
            let delete_result = remove_song(playlist_id,song.id.clone()).await;
            if let Err(err) = delete_result {
                // Handle the error here, e.g., log it or display to the user
                log!("Error deleting song: {:?}", err);
            } else {
                log!("Song deleted successfully!");
                set_songs.update(|value| *value = value.iter().filter(|s| s.id != song.id).cloned().collect());
            }
        })
    };
    create_effect(move |_| {
        spawn_local(async move {
            let song_artists = get_artists(song.id.clone()).await;
            if let Err(err) = song_artists {
                // Handle the error here, e.g., log it or display to the user
                log!("Error getting artist: {:?}", err);
            } else {
                log!("Artist: {:?}", song_artists);
                let mut artist_string = "".to_string();
                let song_artists = song_artists.unwrap();
                for i in 0..song_artists.len() {
                    if i == song_artists.len() - 1 {
                        artist_string.push_str(&song_artists[i].name);
                    } else {
                        artist_string.push_str(&song_artists[i].name);
                        artist_string.push_str(" & ");
                    }
                }
                set_artists.update(|value| *value = artist_string);
            }
        })
    });
    view! {
        <div class="song" on:mouseenter=move |_| set_is_hovered.update(|value| *value=true) on:mouseleave=move |_| set_is_hovered.update(|value| *value=false)>
            <img src={song.image_path.clone()} alt={song.title.clone()} />
            <div class="song-info">
 				<h3>{song.title.clone()}</h3>
 				<p>{move || artists.get()}</p>
 			</div>
            <div class="right">
                <Show
                    when=move || is_hovered()
                    fallback=move || view! {<p class="duration">{convert_seconds(song.duration)}</p>}            
                >
                <div class="delete-song" on:click=delete_song>
                    <Icon icon=icondata::FaTrashCanRegular />
                </div>
                </Show>
            </div>
        </div>
    }
 }
--- a/src/components/playlists.rs
+++ b/src/components/playlists.rs
@ -1,56 +0,0 @@
 use leptos::*;
 use leptos::leptos_dom::*;
 use leptos_icons::*;
 use crate::components::create_playlist::CreatePlayList;
 use crate::components::playlist::Playlist;
 use crate::api::playlists::get_playlists;
 #[component]
 pub fn Playlists() -> impl IntoView {
    let (create_playlist_open, set_create_playlist_open) = create_signal(false);
    let (playlists, set_playlists) = create_signal(vec![]);
    create_effect(move |_| {
        spawn_local(async move {
            let playlists2 = get_playlists().await;
            if let Err(err) = playlists2 {
                // Handle the error here, e.g., log it or display to the user
                log!("Error getting playlists: {:?}", err);
            } else {
                set_playlists.update(|value| *value = playlists2.unwrap());
            }
        });
    });
    view! {
        <div class="sidebar-playlists-container">
            <div class="heading">
                <h1 class="header">Playlists</h1>
                <button on:click=move|_| set_create_playlist_open.update(|value|*value = true) class="add-playlist">
                    <div class="add-sign">
                        <Icon icon=icondata::IoAddSharp />
                    </div>
                    New Playlist
                </button>
            </div>
            <Show
                when=move || create_playlist_open()
                fallback=move || view! {<div></div>}
            >
                <CreatePlayList closer=set_create_playlist_open set_playlists=set_playlists/>
            </Show>
            <ul class="playlists">
                {
                    move || playlists.get().iter().enumerate().map(|(_index,playlist)| view! {
                       <Playlist playlist=playlist.clone() />
                    }).collect::<Vec<_>>()
                }
            </ul>
        </div>
    }
 }
--- a/src/components/sidebar.rs
+++ b/src/components/sidebar.rs
@ -1,42 +1,54 @@
 use leptos::leptos_dom::*;
 use leptos::*;
 use leptos_icons::*;
-use crate::components::playlists::Playlists;
+use crate::components::upload::*;
 #[component]
-pub fn Sidebar(setter: WriteSignal<bool>, active: ReadSignal<bool>, logged_in:ReadSignal<bool>) -> impl IntoView {
+pub fn Sidebar(upload_open: RwSignal<bool>) -> impl IntoView {
-    let open_dashboard = move |_| {
+    use leptos_router::use_location;
-        setter.update(|value| *value = true);
+    let location = use_location();
-        log!("open dashboard");
+
-    };
+    let on_dashboard = Signal::derive(
-    let open_search = move |_| {
+        move || location.pathname.get().starts_with("/dashboard") || location.pathname.get() == "/",
-        setter.update(|value| *value = false);
+    );
-        log!("open search");
+
-    };
+    let on_search = Signal::derive(
        move || location.pathname.get().starts_with("/search"),
    );
    view! {
        <div class="sidebar-container">
            <div class="sidebar-top-container">
                <h2 class="header">LibreTunes</h2>
-                <div class="buttons" on:click=open_dashboard style={move || if active() {"color: #e1e3e1"} else {""}} >
+                <UploadBtn dialog_open=upload_open />
                <a class="buttons" href="/dashboard" style={move || if on_dashboard() {"color: #e1e3e1"} else {""}} >
                    <Icon icon=icondata::OcHomeFillLg />
                    <h1>Dashboard</h1>
-                </div>
+                </a>
-                <div class="buttons" on:click=open_search style={move || if !active() {"color: #e1e3e1"} else {""}}>
+                <a class="buttons" href="/search" style={move || if on_search() {"color: #e1e3e1"} else {""}}>
                    <Icon icon=icondata::BiSearchRegular />
                    <h1>Search</h1>
-                </div>
+                </a>
            </div>
            <div class="sidebar-bottom-container">
                <Show 
                    when=move || {logged_in() == true}
                    fallback=move|| view!{<h1>LOG IN PLEASE</h1>}
                >
                    <Playlists />
                </Show>
            </div>
            <Bottom />
        </div>
    }
 }
 #[component]
 pub fn Bottom() -> impl IntoView {
    view! {
        <div class="sidebar-bottom-container">
            <div class="heading">
                <h1 class="header">Playlists</h1>
                <button class="add-playlist">
                    <div class="add-sign">
                        <Icon icon=icondata::IoAddSharp />
                    </div>
                    New Playlist
                </button>
            </div>
        </div>
    }
 }
--- a/src/components/upload.rs
+++ b/src/components/upload.rs
@ -0,0 +1,245 @@
 use std::rc::Rc;
 use leptos::leptos_dom::*;
 use leptos::*;
 use leptos_icons::*;
 use leptos_router::Form;
 use web_sys::Response;
 use crate::search::search_artists;
 use crate::search::search_albums;
 use crate::models::Artist;
 use crate::models::Album;
 #[component]
 pub fn UploadBtn(dialog_open: RwSignal<bool>) -> impl IntoView {
 	let open_dialog = move |_| {
 		dialog_open.set(true);
 	};
 	view! {
 		<button class="upload-btn" on:click=open_dialog>
 			<div class="add-sign">
 				<Icon icon=icondata::IoAddSharp />
 			</div>
 			Upload
 		</button>
 	}
 }
 #[component]
 pub fn Upload(open: RwSignal<bool>) -> impl IntoView {
 	// Create signals for the artist input and the filtered artists
 	let (artists, set_artists) = create_signal("".to_string());
 	let (filtered_artists, set_filtered_artists)  = create_signal(vec![]);
 	let (albums, set_albums) = create_signal("".to_string());
 	let (filtered_albums, set_filtered_albums) = create_signal(vec![]);
 	let (error_msg, set_error_msg) = create_signal::<Option<String>>(None);
 	let close_dialog = move |ev: leptos::ev::MouseEvent| {
 		ev.prevent_default();
 		open.set(false);
 	};
 	// Create a filter function to handle filtering artists
 	// Allow users to search for artists by name, converts the artist name to artist id to be handed off to backend
 	let handle_filter_artists = move |ev: leptos::ev::Event| {
 		ev.prevent_default();
 		let artist_input: String = event_target_value(&ev);
 		//Get the artist that we are currently searching for
 		let mut all_artists: Vec<&str> = artist_input.split(",").collect();
 		let search = all_artists.pop().unwrap().to_string();
 		//Update the artist signal with the input
 		set_artists.update(|value: &mut String| *value = artist_input);
 		spawn_local(async move {
 			let filter_results = search_artists(search, 3).await;
 			if let Err(err) = filter_results {
 				log!("Error filtering artists: {:?}", err);
 			} else if let Ok(artists) = filter_results {
 				log!("Filtered artists: {:?}", artists);
 				set_filtered_artists.update(|value| *value = artists);
 			}
 		})
 	};
 	// Create a filter function to handle filtering albums
 	// Allow users to search for albums by title, converts the album title to album id to be handed off to backend
 	let handle_filter_albums = move |ev: leptos::ev::Event| {
 		ev.prevent_default();
 		let album_input: String = event_target_value(&ev);
 		//Update the album signal with the input
 		set_albums.update(|value: &mut String| *value = album_input);
 		spawn_local(async move {
 			let filter_results = search_albums(albums.get_untracked(), 3).await;
 			if let Err(err) = filter_results {
 				log!("Error filtering albums: {:?}", err);
 			} else if let Ok(albums) = filter_results {
 				log!("Filtered albums: {:?}", albums);
 				set_filtered_albums.update(|value| *value = albums);
 			}
 		})
 	};
 	let handle_response = Rc::new(move |response: &Response| {
 		if response.ok() {
 			set_error_msg.update(|value| *value = None);
 			set_filtered_artists.update(|value| *value = vec![]);
 			set_filtered_albums.update(|value| *value = vec![]);
 			set_artists.update(|value| *value = "".to_string());
 			set_albums.update(|value| *value = "".to_string());
 			open.set(false);
 		} else {
 			// TODO: Extract error message from response
 			set_error_msg.update(|value| *value = Some("Error uploading song".to_string()));
 		}
 	});
 	view! {
 		<Show when=open fallback=move || view! {}>
 			<div class="upload-container" open=open>
 				<div class="close-button" on:click=close_dialog><Icon icon=icondata::IoClose /></div>
 				<div class="upload-header">
 					<h1>Upload Song</h1>
 				</div>
 				<Form action="/api/upload" method="POST" enctype=String::from("multipart/form-data")
 					class="upload-form" on_response=handle_response.clone()>
 					<div class="input-bx">
 						<input type="text" name="title" required class="text-input" required/>
 						<span>Title</span>
 					</div>
 					<div class="artists has-search">
 						<div class="input-bx">
 							<input type="text" name="artist_ids" class="text-input" prop:value=artists on:input=handle_filter_artists/>
 							<span>Artists</span>
 						</div>
 						<Show
 							when=move || {filtered_artists.get().len() > 0}
 							fallback=move || view! {}						
 						>
 							<ul class="artist_results search-results">
 								{
 									move || filtered_artists.get().iter().enumerate().map(|(_index,filtered_artist)| view! {
 										<Artist artist=filtered_artist.clone() artists=artists set_artists=set_artists set_filtered=set_filtered_artists/>
 									}).collect::<Vec<_>>()
 								}
 							</ul>
 						</Show>
 					</div>
 					<div class="albums has-search">
 						<div class="input-bx">
 							<input type="text" name="album_id" class="text-input" prop:value=albums on:input=handle_filter_albums/>
 							<span>Album ID</span>
 						</div>
 						<Show
 							when=move || {filtered_albums.get().len() > 0}
 							fallback=move || view! {}						
 						>
 							<ul class="album_results search-results">
 								{
 									move || filtered_albums.get().iter().enumerate().map(|(_index,filtered_album)| view! {
 										<Album album=filtered_album.clone() _albums=albums set_albums=set_albums set_filtered=set_filtered_albums/>
 									}).collect::<Vec<_>>()
 								}
 							</ul>
 						</Show>
 					</div>
 					<div class="input-bx">
 						<input type="number" name="track_number" class="text-input"/>
 						<span>Track Number</span>
 					</div>
 					<div class="release-date">
 						<div class="left">
 							<span>Release</span>
 							<span>Date</span>
 						</div>
 						<input class="info" type="date" name="release_date"/>
 					</div>
 					<div class="file">
 						<span>File</span>
 						<input class="info" type="file" accept=".mp3" name="file" required/>
 					</div>
 					<button type="submit" class="upload-button">Upload</button>
 				</Form>
 				<Show
 					when=move || {error_msg.get().is_some()}
 					fallback=move || view! {}
 				>
 					<div class="error-msg">
 						<Icon icon=icondata::IoAlertCircleSharp />
 						{error_msg.get().as_ref().unwrap()}
 					</div>
 				</Show>
 			</div>
 		</Show>
 	}
 }
 #[component]
 pub fn Artist(artist: Artist, artists: ReadSignal<String>, set_artists: WriteSignal<String>, set_filtered: WriteSignal<Vec<Artist>>) -> impl IntoView {
 	// Converts artist name to artist id and adds it to the artist input
 	let add_artist = move |_| {
 		//Create an empty string to hold previous artist ids
 		let mut s: String = String::from("");
 		//Get the current artist input
 		let all_artirts: String = artists.get();
 		//Split the input into a vector of artists separated by commas
 		let mut ids: Vec<&str> = all_artirts.split(",").collect();
 		//If there is only one artist in the input, get their id equivalent and add it to the string
 		if ids.len() == 1 {
 			let value_str = match artist.id.clone() {
 				Some(v) => v.to_string(),
 				None => String::from("None"),
 			};
 			s.push_str(&value_str);
 			s.push_str(",");
 			set_artists.update(|value| *value = s);
 		//If there are multiple artists in the input, pop the last artist by string off the vector, 
 		//get their id equivalent, and add it to the string
 		} else {
 			ids.pop();
 			for id in ids {
 				s.push_str(id);
 				s.push_str(",");
 			}
 			let value_str = match artist.id.clone() {
 				Some(v) => v.to_string(),
 				None => String::from("None"),
 			};
 			s.push_str(&value_str);
 			s.push_str(",");
 			set_artists.update(|value| *value = s);
 		}
 		//Clear the search results
 		set_filtered.update(|value| *value = vec![]);
 	};
 	view! {
 		<div class="artist result" on:click=add_artist>
 			{artist.name.clone()}
 		</div>
 	}
 }
 #[component]
 pub fn Album(album: Album, _albums: ReadSignal<String>, set_albums: WriteSignal<String>, set_filtered: WriteSignal<Vec<Album>>) -> impl IntoView {
 	//Converts album title to album id to upload a song
 	let add_album = move |_| {
 		let value_str = match album.id.clone() {
 			Some(v) => v.to_string(),
 			None => String::from("None"),
 		};
 		set_albums.update(|value| *value = value_str);
 		set_filtered.update(|value| *value = vec![]);
 	};
 	view! {
 		<div class="album result" on:click=add_album>
 			{album.title.clone()}
 		</div>
 	}
 }
--- a/src/lib.rs
+++ b/src/lib.rs
@ -13,7 +13,9 @@ pub mod users;
 pub mod search;
 pub mod fileserv;
 pub mod error_template;
-pub mod api;
+pub mod upload;
 pub mod util;
 use cfg_if::cfg_if;
 cfg_if! {
--- a/src/main.rs
+++ b/src/main.rs
@ -19,17 +19,27 @@ async fn main() {
    use leptos_axum::{generate_route_list, LeptosRoutes};
    use libretunes::app::*;
    use libretunes::fileserv::{file_and_error_handler, get_static_file};
-    use tower_sessions::SessionManagerLayer;
+    use axum_login::tower_sessions::SessionManagerLayer;
    use tower_sessions_redis_store::{fred::prelude::*, RedisStore};
    use axum_login::AuthManagerLayerBuilder;
    use libretunes::auth_backend::AuthBackend;
    use log::*;
    flexi_logger::Logger::try_with_env_or_str("debug").unwrap().format(flexi_logger::opt_format).start().unwrap();
    info!("\n{}", include_str!("../ascii_art.txt"));
    info!("Starting Leptos server...");
    use dotenv::dotenv;
    dotenv().ok();
    debug!("Running database migrations...");
    // Bring the database up to date
    libretunes::database::migrate();
    debug!("Connecting to Redis...");
    let redis_url = std::env::var("REDIS_URL").expect("REDIS_URL must be set");
    let redis_config = RedisConfig::from_url(&redis_url).expect(&format!("Unable to parse Redis URL: {}", redis_url));
    let redis_pool = RedisPool::new(redis_config, None, None, None, 1).expect("Unable to create Redis pool");
@ -55,30 +65,16 @@ async fn main() {
        .fallback(file_and_error_handler)
        .with_state(leptos_options);
    println!("listening on http://{}", &addr);
    let listener = tokio::net::TcpListener::bind(&addr).await.expect(&format!("Could not bind to {}", &addr));
    info!("Listening on http://{}", &addr);
    axum::serve(listener, app.into_make_service()).await.expect("Server failed");
 }
-#[cfg(not(any(feature = "ssr", feature = "csr")))]
+#[cfg(not(feature = "ssr"))]
 pub fn main() {
    // no client-side main function
    // unless we want this to work with e.g., Trunk for pure client-side testing
    // see lib.rs for hydration function instead
    // see optional feature `csr` instead
 }
 #[cfg(all(not(feature = "ssr"), feature = "csr"))]
 pub fn main() {
    // a client-side main function is required for using `trunk serve`
    // prefer using `cargo leptos serve` instead
    // to run: `trunk serve --open --features csr`
    use leptos::*;
    use libretunes::app::*;
    use wasm_bindgen::prelude::wasm_bindgen;
    console_error_panic_hook::set_once();
    leptos::mount_to_body(App);
 }
--- a/src/models.rs
+++ b/src/models.rs
@ -41,13 +41,15 @@ pub struct User {
 	/// The time the user was created
 	#[cfg_attr(feature = "ssr", diesel(deserialize_as = SystemTime))]
 	pub created_at: Option<SystemTime>,
 	/// Whether the user is an admin
 	pub admin: bool,
 }
 /// Model for an artist
-#[cfg_attr(feature = "ssr", derive(Queryable, Selectable, Insertable))]
+#[cfg_attr(feature = "ssr", derive(Queryable, Selectable, Insertable, Identifiable))]
 #[cfg_attr(feature = "ssr", diesel(table_name = crate::schema::artists))]
 #[cfg_attr(feature = "ssr", diesel(check_for_backend(diesel::pg::Pg)))]
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct Artist {
 	/// A unique id for the artist
 	#[cfg_attr(feature = "ssr", diesel(deserialize_as = i32))]
@ -165,10 +167,10 @@ impl Artist {
 }
 /// Model for an album
-#[cfg_attr(feature = "ssr", derive(Queryable, Selectable, Insertable))]
+#[cfg_attr(feature = "ssr", derive(Queryable, Selectable, Insertable, Identifiable))]
 #[cfg_attr(feature = "ssr", diesel(table_name = crate::schema::albums))]
 #[cfg_attr(feature = "ssr", diesel(check_for_backend(diesel::pg::Pg)))]
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct Album {
 	/// A unique id for the album
 	#[cfg_attr(feature = "ssr", diesel(deserialize_as = i32))]
@ -177,6 +179,8 @@ pub struct Album {
 	pub title: String,
 	/// The album's release date
 	pub release_date: Option<Date>,
 	/// The path to the album's image file
 	pub image_path: Option<String>,
 }
 impl Album {
@ -239,7 +243,7 @@ impl Album {
 #[cfg_attr(feature = "ssr", derive(Queryable, Selectable, Insertable))]
 #[cfg_attr(feature = "ssr", diesel(table_name = crate::schema::songs))]
 #[cfg_attr(feature = "ssr", diesel(check_for_backend(diesel::pg::Pg)))]
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize)]
 pub struct Song {
 	/// A unique id for the song
 	#[cfg_attr(feature = "ssr", diesel(deserialize_as = i32))]
@ -290,101 +294,3 @@ impl Song {
 		Ok(my_artists)
 	}
 }
 /// Model for an playlist
 #[cfg_attr(feature = "ssr", derive(Queryable, Selectable, Insertable))]
 #[cfg_attr(feature = "ssr", diesel(table_name = crate::schema::playlists))]
 #[cfg_attr(feature = "ssr", diesel(check_for_backend(diesel::pg::Pg)))]
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Playlist {
 	/// A unique id for the playlist
 	#[cfg_attr(feature = "ssr", diesel(deserialize_as = i32))]
 	pub id: Option<i32>,
 	/// The playlist's name
 	pub name: String,
 	/// The user who created the playlist
 	pub user_id: i32,
 }
 impl Playlist {
 	/// Create a new, empty playlist in the database
 	/// 
 	/// # Arguments
 	/// 
 	/// * `new_playlist` - The new playlist
 	/// * `conn` - A mutable reference to a database connection
 	/// 	
 	/// # Returns
 	/// 
 	/// * `Result<(), Box<dyn Error>>` - A result indicating success with the new playlist, or an error
 	/// 
 	#[cfg(feature = "ssr")]
 	pub fn create_playlist(new_playlist: Playlist, conn: &mut PgPooledConn) -> Result<(), Box<dyn Error>> {
 		use crate::schema::playlists::dsl::*;
 		let new_playlist = Playlist {
 			..new_playlist
 		};
 		diesel::insert_into(playlists)
 			.values(&new_playlist)
 			.execute(conn)?;
 		Ok(())
 	}
 	/// Add a song to this playlist in the database
 	/// 
 	/// The 'id' field of this playlist must be present (Some) to add a song
 	/// 
 	/// # Arguments
 	/// 
 	/// * `new_song_id` - The id of the song to add to this playlist
 	/// * `conn` - A mutable reference to a database connection
 	/// 
 	/// # Returns
 	/// 
 	/// * `Result<(), Box<dyn Error>>` - A result indicating success with an empty value, or an error
 	/// 
 	#[cfg(feature = "ssr")]
 	pub fn add_song(self: &Self, new_song_id: i32, conn: &mut PgPooledConn) -> Result<(), Box<dyn Error>> {
 		use crate::schema::playlist_songs::dsl::*;
 		let my_id = self.id.ok_or("Playlist id must be present (Some) to add a song")?;
 		diesel::insert_into(playlist_songs)
 			.values((playlist_id.eq(my_id), song_id.eq(new_song_id)))
 			.execute(conn)?;
 		Ok(())
 	}
 	/// Get songs by this playlist from the database
 	/// 
 	/// The 'id' field of this playlist must be present (Some) to get songs
 	/// 
 	/// # Arguments
 	/// 
 	/// * `conn` - A mutable reference to a database connection
 	/// 
 	/// # Returns
 	/// 
 	/// * `Result<Vec<Song>, Box<dyn Error>>` - A result indicating success with a vector of songs, or an error
 	/// 
 	#[cfg(feature = "ssr")]
 	pub fn get_songs(self: &Self, conn: &mut PgPooledConn) -> Result<Vec<Song>, Box<dyn Error>> {
 		use crate::schema::songs::dsl::*;
 		use crate::schema::playlist_songs::dsl::*;
 		let my_id = self.id.ok_or("Playlist id must be present (Some) to get songs")?;
 		let my_songs = songs
 			.inner_join(playlist_songs)
 			.filter(playlist_id.eq(my_id))
 			.select(songs::all_columns())
 			.load(conn)?;
 		Ok(my_songs)
 	}
 }
--- a/src/pages/login.rs
+++ b/src/pages/login.rs
@ -73,7 +73,9 @@ pub fn Login() -> impl IntoView {
                        <i></i>
                        <Show
                            when=move || {show_password() == false}
-                            fallback=move || view!{ <button on:click=toggle_password class="login-password-visibility"><Icon icon=icondata::AiEyeInvisibleFilled /></button> /> }
+                            fallback=move || view!{ <button on:click=toggle_password class="login-password-visibility">
                                                  <Icon icon=icondata::AiEyeInvisibleFilled />
                                               </button> /> }
                        >
                            <button on:click=toggle_password class="login-password-visibility">
                                <Icon icon=icondata::AiEyeFilled />
--- a/src/pages/signup.rs
+++ b/src/pages/signup.rs
@ -25,6 +25,7 @@ pub fn Signup() -> impl IntoView {
            email: email.get(),
            password: Some(password.get()),
            created_at: None,
            admin: false,
        };
        log!("new user: {:?}", new_user);
--- a/src/schema.rs
+++ b/src/schema.rs
@ -12,6 +12,7 @@ diesel::table! {
        id -> Int4,
        title -> Varchar,
        release_date -> Nullable<Date>,
        image_path -> Nullable<Varchar>,
    }
 }
@ -22,22 +23,6 @@ diesel::table! {
    }
 }
 diesel::table! {
    playlist_songs (playlist_id, song_id) {
        playlist_id -> Int4,
        song_id -> Int4,
        position -> Int4,
    }
 }
 diesel::table! {
    playlists (id) {
        id -> Int4,
        name -> Varchar,
        user_id -> Int4,
    }
 }
 diesel::table! {
    song_artists (song_id, artist_id) {
        song_id -> Int4,
@ -65,14 +50,12 @@ diesel::table! {
        email -> Varchar,
        password -> Varchar,
        created_at -> Timestamp,
        admin -> Bool,
    }
 }
 diesel::joinable!(album_artists -> albums (album_id));
 diesel::joinable!(album_artists -> artists (artist_id));
 diesel::joinable!(playlist_songs -> playlists (playlist_id));
 diesel::joinable!(playlist_songs -> songs (song_id));
 diesel::joinable!(playlists -> users (user_id));
 diesel::joinable!(song_artists -> artists (artist_id));
 diesel::joinable!(song_artists -> songs (song_id));
 diesel::joinable!(songs -> albums (album_id));
@ -81,8 +64,6 @@ diesel::allow_tables_to_appear_in_same_query!(
    album_artists,
    albums,
    artists,
    playlist_songs,
    playlists,
    song_artists,
    songs,
    users,
--- a/src/search.rs
+++ b/src/search.rs
@ -102,7 +102,7 @@ pub async fn search(query: String, limit: i64) -> Result<(Vec<Album>, Vec<Artist
 	let artists = search_artists(query.clone(), limit);
 	let songs = search_songs(query.clone(), limit);
-	use futures::join;
+	use tokio::join;
 	let (albums, artists, songs) = join!(albums, artists, songs);
 	Ok((albums?, artists?, songs?))
--- a/src/upload.rs
+++ b/src/upload.rs
@ -0,0 +1,294 @@
 use leptos::*;
 use server_fn::codec::{MultipartData, MultipartFormData};
 use cfg_if::cfg_if;
 cfg_if! {
 	if #[cfg(feature = "ssr")] {
 		use multer::Field;
 		use crate::database::get_db_conn;
 		use diesel::prelude::*;
 		use log::*;
 		use server_fn::error::NoCustomError;
 		use time::Date;
 	}
 }
 /// Extract the text from a multipart field
 #[cfg(feature = "ssr")]
 async fn extract_field(field: Field<'static>) -> Result<String, ServerFnError> {
 	let field = match field.text().await {
 		Ok(field) => field,
 		Err(e) => Err(ServerFnError::<NoCustomError>::ServerError(format!("Error reading field: {}", e)))?,
 	};
 	Ok(field)
 }
 /// Validate the artist ids in a multipart field
 /// Expects a field with a comma-separated list of artist ids, and ensures each is a valid artist id in the database
 #[cfg(feature = "ssr")]
 async fn validate_artist_ids(artist_ids: Field<'static>) -> Result<Vec<i32>, ServerFnError> {
    use crate::models::Artist;
 	use diesel::result::Error::NotFound;
 	// Extract the artist id from the field
 	match artist_ids.text().await {
 		Ok(artist_ids) => {
 			let artist_ids = artist_ids.trim_end_matches(',').split(',');
 			artist_ids.filter(|artist_id| !artist_id.is_empty()).map(|artist_id| {
 				// Parse the artist id as an integer
 				if let Ok(artist_id) = artist_id.parse::<i32>() {
 					// Check if the artist exists
 					let db_con = &mut get_db_conn();
 					let artist = crate::schema::artists::dsl::artists.find(artist_id).first::<Artist>(db_con);
 					match artist {
 						Ok(_) => Ok(artist_id),
 						Err(NotFound) => Err(ServerFnError::<NoCustomError>::
 							ServerError("Artist does not exist".to_string())),
 						Err(e) => Err(ServerFnError::<NoCustomError>::
 							ServerError(format!("Error finding artist id: {}", e))),
 					}
 				} else {
 					Err(ServerFnError::<NoCustomError>::ServerError("Error parsing artist id".to_string()))
 				}
 			}).collect()
 		},
 		Err(e) => Err(ServerFnError::<NoCustomError>::ServerError(format!("Error reading artist id: {}", e))),
 	}
 }
 /// Validate the album id in a multipart field
 /// Expects a field with an album id, and ensures it is a valid album id in the database
 #[cfg(feature = "ssr")]
 async fn validate_album_id(album_id: Field<'static>) -> Result<Option<i32>, ServerFnError> {
 	use crate::models::Album;
 	use diesel::result::Error::NotFound;
 	// Extract the album id from the field
 	match album_id.text().await {
 		Ok(album_id) => {
 			if album_id.is_empty() {
 				return Ok(None);
 			}
 			// Parse the album id as an integer
 			if let Ok(album_id) = album_id.parse::<i32>() {
 				// Check if the album exists
 				let db_con = &mut get_db_conn();
 				let album = crate::schema::albums::dsl::albums.find(album_id).first::<Album>(db_con);
 				match album {
 					Ok(_) => Ok(Some(album_id)),
 					Err(NotFound) => Err(ServerFnError::<NoCustomError>::
 						ServerError("Album does not exist".to_string())),
 					Err(e) => Err(ServerFnError::<NoCustomError>::
 						ServerError(format!("Error finding album id: {}", e))),
 				}
 			} else {
 				Err(ServerFnError::<NoCustomError>::ServerError("Error parsing album id".to_string()))
 			}
 		},
 		Err(e) => Err(ServerFnError::<NoCustomError>::ServerError(format!("Error reading album id: {}", e))),
 	}
 }
 /// Validate the track number in a multipart field
 /// Expects a field with a track number, and ensures it is a valid track number (non-negative integer)
 #[cfg(feature = "ssr")]
 async fn validate_track_number(track_number: Field<'static>) -> Result<Option<i32>, ServerFnError> {
 	match track_number.text().await {
 		Ok(track_number) => {
 			if track_number.is_empty() {
 				return Ok(None);
 			}
 			if let Ok(track_number) = track_number.parse::<i32>() {
 				if track_number < 0 {
 					return Err(ServerFnError::<NoCustomError>::
 						ServerError("Track number must be positive or 0".to_string()));
 				} else {
 					Ok(Some(track_number))
 				}
 			} else {
 				return Err(ServerFnError::<NoCustomError>::ServerError("Error parsing track number".to_string()));
 			}
 		},
 		Err(e) => Err(ServerFnError::<NoCustomError>::ServerError(format!("Error reading track number: {}", e)))?,
 	}
 }
 /// Validate the release date in a multipart field
 /// Expects a field with a release date, and ensures it is a valid date in the format [year]-[month]-[day]
 #[cfg(feature = "ssr")]
 async fn validate_release_date(release_date: Field<'static>) -> Result<Option<Date>, ServerFnError> {
 	match release_date.text().await {
 		Ok(release_date) => {
 			if release_date.trim().is_empty() {
 				return Ok(None);
 			}
 			let date_format = time::macros::format_description!("[year]-[month]-[day]");
 			let release_date = Date::parse(&release_date.trim(), date_format);
 			match release_date {
 				Ok(release_date) => Ok(Some(release_date)),
 				Err(_) => Err(ServerFnError::<NoCustomError>::ServerError("Invalid release date".to_string())),
 			}
 		},
 		Err(e) => Err(ServerFnError::<NoCustomError>::ServerError(format!("Error reading release date: {}", e))),
 	}
 }
 /// Handle the file upload form
 #[server(input = MultipartFormData, endpoint = "/upload")]
 pub async fn upload(data: MultipartData) -> Result<(), ServerFnError> {
 	// Safe to unwrap - "On the server side, this always returns Some(_). On the client side, always returns None."
 	let mut data = data.into_inner().unwrap();
 	let mut title = None;
 	let mut artist_ids = None;
 	let mut album_id = None;
 	let mut track = None;
 	let mut release_date = None;
 	let mut file_name = None;
 	let mut duration = None;
 	// Fetch the fields from the form data
 	while let Ok(Some(mut field)) = data.next_field().await {
 		let name = field.name().unwrap_or_default().to_string();
 		match name.as_str() {
 			"title" => { title = Some(extract_field(field).await?); },
 			"artist_ids" => { artist_ids = Some(validate_artist_ids(field).await?); },
 			"album_id" => { album_id = Some(validate_album_id(field).await?); },
 			"track_number" => { track = Some(validate_track_number(field).await?); },
 			"release_date" => { release_date = Some(validate_release_date(field).await?); },
 			"file" => {
 				use symphonia::core::codecs::CODEC_TYPE_MP3;
 				use crate::util::audio::extract_metadata;
 				use std::fs::OpenOptions;
 				use std::io::{Seek, Write};
 				// Some logging is done here where there is high potential for bugs / failures,
 				// or behavior that we may wish to change in the future
 				// Create file name
 				let title = title.clone().ok_or(ServerFnError::<NoCustomError>::
 					ServerError("Title field required and must precede file field".to_string()))?;
 				let clean_title = title.replace(" ", "_").replace("/", "_");
 				let date_format = time::macros::format_description!("[year]-[month]-[day]_[hour]:[minute]:[second]");
 				let date_str = time::OffsetDateTime::now_utc().format(date_format).unwrap_or_default();
 				let upload_path = format!("assets/audio/upload-{}_{}.mp3", date_str, clean_title);
 				file_name = Some(format!("upload-{}_{}.mp3", date_str, clean_title));
 				debug!("Saving uploaded file {}", upload_path);
 				// Save file to disk
 				// Use these open options to create the file, write to it, then read from it
 				let mut file = OpenOptions::new()
 					.read(true)
 					.write(true)
 					.create(true)
 					.open(upload_path.clone())?;
 				while let Some(chunk) = field.chunk().await? {
 					file.write(&chunk)?;
 				}
 				file.flush()?;
 				// Rewind the file so the duration can be measured
 				file.rewind()?;
 				// Get the codec and duration of the file
 				let (file_codec, file_duration) = extract_metadata(file)
 					.map_err(|e| {
 						let msg = format!("Error measuring duration of audio file {}: {}", upload_path, e);
 						warn!("{}", msg);
 						ServerFnError::<NoCustomError>::ServerError(msg)
 					})?;
 				if file_codec != CODEC_TYPE_MP3 {
 					let msg = format!("Invalid uploaded audio file codec: {}", file_codec);
 					warn!("{}", msg);
 					return Err(ServerFnError::<NoCustomError>::ServerError(msg));
 				}
 				duration = Some(file_duration);
 			},
 			_ => {
 				warn!("Unknown file upload field: {}", name);
 			}
 		}
 	}
 	// Unwrap mandatory fields
 	let title = title.ok_or(ServerFnError::<NoCustomError>::ServerError("Missing title".to_string()))?;
 	let artist_ids = artist_ids.unwrap_or(vec![]);
 	let file_name = file_name.ok_or(ServerFnError::<NoCustomError>::ServerError("Missing file".to_string()))?;
 	let duration = duration.ok_or(ServerFnError::<NoCustomError>::ServerError("Missing duration".to_string()))?;
 	let duration = i32::try_from(duration).map_err(|e| ServerFnError::<NoCustomError>::
 		ServerError(format!("Error converting duration to i32: {}", e)))?;
 	let album_id = album_id.unwrap_or(None);
 	let track = track.unwrap_or(None);
 	let release_date = release_date.unwrap_or(None);
 	if album_id.is_some() != track.is_some() {
 		return Err(ServerFnError::<NoCustomError>
 			::ServerError("Album id and track number must both be present or both be absent".to_string()));
 	}
 	// Create the song
 	use crate::models::Song;
 	let song = Song {
 		id: None,
 		title,
 		album_id,
 		track,
 		duration,
 		release_date,
 		storage_path: file_name,
 		image_path: None,
 	};
 	// Save the song to the database
 	let db_con = &mut get_db_conn();
 	let song = song.insert_into(crate::schema::songs::table)
 		.get_result::<Song>(db_con)
 		.map_err(|e| {
 			let msg = format!("Error saving song to database: {}", e);
 			warn!("{}", msg);
 			ServerFnError::<NoCustomError>::ServerError(msg)
 		})?;
 	// Save the song's artists to the database
 	let song_id = song.id.ok_or_else(|| {
 		let msg = "Error saving song to database: song id not found after insertion".to_string();
 		warn!("{}", msg);
 		ServerFnError::<NoCustomError>::ServerError(msg)
 	})?;
 	use crate::schema::song_artists;
 	use diesel::ExpressionMethods;
 	let artist_ids = artist_ids.into_iter().map(|artist_id| {
 		(song_artists::song_id.eq(song_id), song_artists::artist_id.eq(artist_id))
 	}).collect::<Vec<_>>();
 	diesel::insert_into(crate::schema::song_artists::table)
 		.values(&artist_ids)
 		.execute(db_con)
 		.map_err(|e| {
 			let msg = format!("Error saving song artists to database: {}", e);
 			warn!("{}", msg);
 			ServerFnError::<NoCustomError>::ServerError(msg)
 		})?;
 	Ok(())
 }
--- a/src/util/audio.rs
+++ b/src/util/audio.rs
@ -0,0 +1,37 @@
 use symphonia::core::codecs::CodecType;
 use symphonia::core::formats::FormatOptions;
 use symphonia::core::io::MediaSourceStream;
 use symphonia::core::meta::MetadataOptions;
 use symphonia::core::probe::Hint;
 use std::fs::File;
 /// Extract the codec and duration of an audio file
 /// This is combined into one function because the file object will be consumed
 pub fn extract_metadata(file: File) -> Result<(CodecType, u64), Box<dyn std::error::Error>> {
 	let source_stream = MediaSourceStream::new(Box::new(file), Default::default());
 	let hint = Hint::new();
 	let format_opts = FormatOptions::default();
 	let metadata_opts = MetadataOptions::default();
 	let probe = symphonia::default::get_probe().format(&hint, source_stream, &format_opts, &metadata_opts)?;
 	let reader = probe.format;
 	if reader.tracks().len() != 1 {
 		return Err(format!("Expected 1 track, found {}", reader.tracks().len()).into())
 	}
 	let track = &reader.tracks()[0];
 	let time_base = track.codec_params.time_base.ok_or("Missing time base")?;
 	let duration = track.codec_params.n_frames
 		.map(|frames| track.codec_params.start_ts + frames)
 		.ok_or("Missing number of frames")?;
 	let duration = duration
 		.checked_mul(time_base.numer as u64)
 		.and_then(|v| v.checked_div(time_base.denom as u64))
 		.ok_or("Overflow while computing duration")?;
 	Ok((track.codec_params.codec, duration))
 }
--- a/src/util/mod.rs
+++ b/src/util/mod.rs
@ -0,0 +1,7 @@
 use cfg_if::cfg_if;
 cfg_if! {
 	if #[cfg(feature = "ssr")] {
 		pub mod audio;
 	}
 }
--- a/style/main.scss
+++ b/style/main.scss
@ -8,6 +8,7 @@
@import 'home.scss';
@import 'search.scss';
@import 'personal.scss';
@import 'upload.scss';
 body {
  font-family: sans-serif;
--- a/style/sidebar.scss
+++ b/style/sidebar.scss
@ -4,56 +4,74 @@
  background-color: transparent;
  width: 22rem;
  height: calc(100% - 75px);
-}
+  .sidebar-top-container {
-
+    border-radius: 1rem;
-.sidebar-top-container {
+    background-color: #1c1c1c;
-  border-radius: 1rem;
+    height: 9rem;
-  background-color: #1c1c1c;
+    margin: 3px;
-  height: 9rem;
+    padding: 0.1rem 1rem 1rem 1rem;
-  margin: 3px;
+    position: relative;
-  padding: 0.1rem 1rem 1rem 1rem;
+    .header {
-}
+      font-size: 1.2rem;
-
+    }
-.sidebar-top-container .header {
+    .upload-btn {
-  font-size: 1.2rem;
+      position: absolute;
-}
+      top: 10px;
-.sidebar-top-container .buttons {
+      right: 7px;
-  display: flex;
+      display: flex;
-  flex-direction: row;
+      flex-direction: row;
-  font-size: 1.8rem;
+      align-items: center;
-  align-items: center;
+      justify-content: center;
-  transition: all 0.5s;
+      font-size: 0.9rem;
-  cursor: pointer;
+      border-radius: 50px;
-  color: grey;
+      border: none;
-}
+      height: 2.2rem;
-.sidebar-top-container .buttons:hover {
+      padding-right: 1rem;
-  color: white;
+      padding-left: 1rem;
-}
+      cursor: pointer;
-
+      transition: background-color 0.3s ease;
-.sidebar-top-container .buttons:last-child {
+      .add-sign {
-  margin-left: 0.02rem;
+        font-size: 1.5rem;
-  margin-top: 0.5rem;
+        margin-top: auto;
-}
+        margin-right: 5px;
-
+        color: white;
-.sidebar-top-container h1 {
+      }
-  font-size: 0.95rem;
+    }
-  margin-left: 0.9rem;
+    .upload-btn:hover {
-  font-weight: 400;
+      background-color: #9e9e9e;
-  font-style: $standard-font;
+    }
-  letter-spacing: 0.5px;
+    .buttons {
-}
+      display: flex;
-
+      flex-direction: row;
-.sidebar-bottom-container {
+      font-size: 1.8rem;
-  border-radius: 1rem;
+      align-items: center;
-  background-color: #1c1c1c;
+      transition: all 0.5s;
-  margin: 3px;
+      cursor: pointer;
-  margin-top: 6px;
+      color: grey;
-  padding: 0.2rem 1rem 1rem 1rem;
+      text-decoration: none;
-  height: calc(100% - 9rem);
+    }
-
+    .buttons:hover {
-  .sidebar-playlists-container {
+      color: white;
-    width: 100%;
+    }
-    height: 100%;
+    .buttons:last-child {
      margin-left: 0.02rem;
      margin-top: 0.5rem;
    }
    h1 {
      font-size: 0.95rem;
      margin-left: 0.9rem;
      font-weight: 400;
      font-style: $standard-font;
      letter-spacing: 0.5px;
    }
  }
  .sidebar-bottom-container {
    border-radius: 1rem;
    background-color: #1c1c1c;
    margin: 3px;
    margin-top: 6px;
    padding: 0.2rem 1rem 1rem 1rem;
    height: calc(100% - 9rem);
    .heading {
      display: flex;
@ -92,252 +110,7 @@
        background-color: #9e9e9e;
      }
    }
-    .create-playlist-popup-container {
+  }  
      display: flex;
      position: relative;
      flex-direction: column;
      // background-color: #1c1c1c;
      height: 12rem;
      width: 20rem;
      border-radius: 2px;
      padding: 1rem;
      padding-top: 0.1rem;
      border: 1px solid grey;
      position: fixed;
      top: 40%;
      left: 50%;
      transform: translate(-50%, -50%);
      .close-button {
        position: absolute;
        top: 5px;
        right: 5px;
        display: flex;
        justify-content: center;
        align-items: center;
        cursor: pointer;
        border-radius: 50%;
        font-size: 1.6rem;
        transition: all 0.3s;
      }
      .close-button:hover {
        transform: scale(1.1);
        background-color: rgba(255, 255, 255, 0.1);
      }
      .close-button:active {
        transform: scale(0.8);
      }
      .header {
        font-size: 1.2rem;
        font-weight: 200;
        margin-bottom: 0.5rem;
      }
      .create-playlist-form {
        display: flex;
        flex-direction: column;
        position: relative;
        height: 100%;
        .name-input {
          background: transparent;
          border: none;
          border-bottom: 1px solid grey;
          font-size: 1.1rem;
          color: white;
          margin-top: 2rem;
        }
        .name-input:focus {
          outline: none;
        }
        .create-button {
          position: absolute;
          bottom: 0px;
          width: 5rem;
          padding: 0.4rem;
          border-radius: 0.5rem;
          cursor: pointer;
        }
      }
    }
    .playlists {
      list-style: none;
      padding: 0;
      margin: 0;
      margin-top: 5px;
      height: 100%;
      .playlist {
        padding: 0;
        margin: 0;
        margin-top: 5px;
        display: flex;
        flex-direction: row;
        border: 1px solid grey;
        height: 3rem;
        border-radius: 5px;
        cursor: pointer;
        transition: background-color 0.3s ease;
        .screen-darkener {
          position: fixed;
          top: 0;
          left: 0;
          width: 100%;
          height: 100%;
          background-color: rgba(0, 0, 0, 0.5);
          z-index: 1;
        }
        .name {
          font-size: 1rem;
          margin-left: 1rem;
          margin-top: 0.5rem;
          color: white;
        }
        .playlist-container {
          background-color: #1c1c1c;
          width: 40rem;
          height: 40rem;
          position: fixed;
          top: 50%;
          left: 50%;
          transform: translate(-50%, -50%);
          border: 1px solid white;
          border-radius: 5px;
          padding: 1rem;
          padding-top: 0;
          z-index: 2;
          display: flex;
          flex-direction: column;
          .close-button {
            position: absolute;
            top: 5px;
            right: 5px;
            display: flex;
            justify-content: center;
            align-items: center;
            cursor: pointer;
            border-radius: 50%;
            font-size: 1.6rem;
            transition: all 0.3s;
          }
          .close-button:hover {
            transform: scale(1.1);
            background-color: rgba(255, 255, 255, 0.1);
          }
          .close-button:active {
            transform: scale(0.8);
          }
          h1 {
            font-size: 2rem;
            font-weight: bolder;
            margin-bottom: 0.5rem;
          }
          .info {
            display:flex;
            flex-direction: row;
            align-items: end;
            h1 {
              font-weight: bold;
              font-size: 2rem;
              margin-left: .5rem;
              margin-right:2rem;
            }
            p {
              color: #aaa;
            }
          }
          .options {
            display: flex;
            button {
              background-color: white;
              border: none;
              color: black;
              font-size: 1rem;
              padding: .6rem;
              border-radius: 5px;
              cursor: pointer;
              transition: background-color 0.3s ease;
              display: flex;
              flex-direction: row;
              align-items: center;
              margin-right: 10px;
              margin-top: 1rem;
              margin-left: 5px;
              .button-icons {
                margin-right: 7px;
                font-size: 1.3rem;
              }  
            }
          }
          .songs {
            list-style: none;
            padding: 0;
            margin: 0;
            margin-top: 2rem;
            .song {
              display: flex;
              align-items: center;
              padding: 7px 10px 7px 10px;
 				      border-bottom: 1px solid #ccc; /* Separator line color */
              img {
                max-width: 40px; /* Adjust maximum width for images */
                margin-right: 10px; /* Add spacing between image and text */
                border-radius: 5px; /* Add border radius to image */
              }
              .song-info {
                h3 {
                  margin: 0; /* Remove default margin for heading */
                  color: #fff; /* Adjust text color for song */
                  font-size: 1rem;
                  font-weight: 200;
                }
                p {
                  margin: 0; /* Remove default margin for paragraph */
                  color: #aaa; /* Adjust text color for artist */
                  font-size: 0.9rem;
                }
              }
              .right {
                position: fixed;
                right: 25px;
                transition: all 0.3s ease;
                .duration {
                }
                .delete-song {
                  cursor: pointer;
                  display: flex;
                  justify-content: center;
                  align-items: center;
                }
                .delete-song:hover {
                  transform: scale(1.1);
                }
                .delete-song:active {
                  transform: scale(0.8);
                }
              }
            }
            .song:first-child {
              border-top: 1px solid #ccc;
            }
          }
        }
      }
      .playlist:hover {
        background-color: #adadad36;
      }
    }
  }
 }
--- a/style/upload.scss
+++ b/style/upload.scss
@ -0,0 +1,188 @@
@import "theme.scss";
 .upload-container {
    position: fixed;
    top: 45%;
    left: 50%;
    transform: translate(-50%, -50%);
    width: 30rem;
    height: 30rem;
    border: 1px solid white;
    border-radius: 5px;
    padding: 1rem;
    padding-top: 0;
    z-index: 2;
    display: flex;
    flex-direction: column;
    background-color: #1c1c1c;
    .close-button {
        position: absolute;
        top: 5px;
        right: 5px;
        display: flex;
        justify-content: center;
        align-items: center;
        cursor: pointer;
        border-radius: 50%;
        font-size: 1.6rem;
        transition: all 0.3s;
        border: none;
    }
    .close-button:hover {
    transform: scale(1.1);
    background-color: rgba(255, 255, 255, 0.1);
    }
    .close-button:active {
    transform: scale(0.8);
    }
    .upload-header {
        font-size: .7rem;
        font-weight: 300;
        padding-bottom: 0;
        border-bottom: 1px solid white;
        font-family: "Roboto", sans-serif;
    }
    .upload-form {
        padding: .1rem;
        display: flex;
        flex-direction: column;
        .input-bx{
            margin-top: 1rem;
            position: relative;
            width: 300px;
            input{
                width: 100%;
                padding: 10px;
                border: 2px solid #7f8fa6;
                border-radius: 5px;
                outline: none;
                font-size: 1rem;
                transition: 0.6s;
                background-color: transparent;
            }
            span{
                position: absolute;
                left: 0;
                top: 1px;
                padding: 10px;
                font-size: 1rem;
                color: #7f8fa6;
                text-transform: uppercase;
                pointer-events: none;
                transition: 0.6s;
                background-color: transparent;
            }
            input:valid ~ span,
            input:focus ~ span{
                color: #fff;
                transform: translateX(10px) translateY(-7px);
                font-size: 0.65rem;
                font-weight: 600;
                padding: 0 10px;
                background: #1c1c1c;
                letter-spacing: 0.1rem;
            }
            input:valid,
            input:focus{
                color: #fff;
                border: 2px solid #fff;
            }
        }
        .release-date {
            margin-top: 1rem;
            font-size: 1.2rem;
            color: #7f8fa6;
            font-family: "Roboto", sans-serif;
            display: flex;
            align-items: center;
            .left {
                display: flex;
                flex-direction: column;
                margin-left: 5px;
                margin-right: 10px;
            }
            span {
                font-size: .85rem;
            }
            input {
                padding: 8px;
            }
        }
        .file {
            margin-top: .5rem;
            display: flex;
            align-items: center;
            span {
                font-size: .9rem;
                color: #7f8fa6;
                font-family: "Roboto", sans-serif;
                margin-left: 5px;
                margin-right: 10px;
            }
            input {
                padding: 10px;
            }
        }
        .upload-button {
            margin-top: 1rem;
            padding: 10px;
            background-color: #7f8fa6;
            color: #fff;
            font-size: 1rem;
            font-family: "Roboto", sans-serif;
            border: none;
            border-radius: 5px;
            cursor: pointer;
            transition: 0.3s;
            &:hover {
                background-color: #fff;
                color: #7f8fa6;
            }
        }
        .has-search {
            position: relative;
            width: 325px;
            .search-results {
                display: flex;
                flex-direction: column;
                border: 1px solid white;
                width: 100%;
                position: absolute;
                top: 75%;
                background-color: #1c1c1c;
                z-index: 2;
                border-radius: 5px;
                padding: 0;
                .result {
                    border-bottom: 1px solid white; 
                    padding: 10px;
                    cursor: pointer;
                    transition: 0.3s;
                    &:hover {
                        background-color: #7f8fa6;
                    }
                }
                .result:last-child {
                    border-bottom: none;
                }
            }
        }
    }
    .error-msg {
        padding-top: 10px;
        color: red;
        display: flex;
        justify-content: center;
        align-items: center;
        svg {
            width: 20px;
            height: 20px;
            margin-right: 5px;
        }
    }
 }
Author	SHA1	Message	Date
Ethan Girouard	4513335784	Merge branch '29-implement-admin-user-permission-flag' into 'main' Implement admin user permission flag Closes #29 See merge request libretunes/libretunes!28	2024-05-19 12:43:51 -04:00
Ethan Girouard	fa26ee40ed	Add auth functions for checking admin status	2024-05-19 12:20:50 -04:00
Ethan Girouard	c27ad19499	Prevent arbitrary admin user creation	2024-05-19 10:45:50 -04:00
Ethan Girouard	6ae55d5cfc	Add admin column to users table	2024-05-19 10:45:45 -04:00
Ethan Girouard	7bcb5f8c04	Merge branch '40-reduce-dependencies-and-their-features' into 'main' Reduce dependencies and their features Closes #40 See merge request libretunes/libretunes!27	2024-05-18 20:29:27 -04:00
Ethan Girouard	9a462d5ee9	Make async-trait required for backend only	2024-05-18 18:51:59 -04:00
Ethan Girouard	5cc504b4d6	Merge branch '19-implement-file-uploads' into 'main' Resolve "Implement file uploads" Closes #19 See merge request libretunes/libretunes!26	2024-05-18 18:51:30 -04:00
Ethan Girouard	eb4dcd4776	Remove tower_sessions dependency	2024-05-18 18:39:14 -04:00
Ethan Girouard	355c791ea7	Reset form fields after sucessful submission	2024-05-18 18:15:50 -04:00
Ethan Girouard	b0edd2174e	Don't initially show upload error message	2024-05-18 18:10:48 -04:00
Ethan Girouard	3978526231	Merge remote-tracking branch 'origin/main' into 19-implement-file-uploads	2024-05-18 18:10:03 -04:00
Ethan Girouard	0adf294cfc	Display error message when upload song fails	2024-05-18 16:36:37 -04:00
Ethan Girouard	e7e7a8175e	Add web_sys dependency	2024-05-18 16:34:48 -04:00
Ethan Girouard	952fb93e1e	Only allow mp3 file upload selections	2024-05-18 16:34:07 -04:00
Ethan Girouard	1633d8c1a5	Fix required/optional form fields	2024-05-18 16:33:48 -04:00
Ethan Girouard	b4054aa2b7	Ensure track is specified if album is specified	2024-05-18 16:32:31 -04:00
Ethan Girouard	3934a25900	Handle present but empty fields	2024-05-18 16:32:04 -04:00
Ethan Girouard	26c34e0012	Merge branch '39-add-images-to-albums' into 'main' Add image_path column to albums table Closes #39 See merge request libretunes/libretunes!25	2024-05-16 21:58:49 -04:00
Ethan Girouard	522658c0dc	Merge branch '38-refactor-navigation-using-leptos-nested-routing' into 'main' Use nested routing for navigation Closes #38 See merge request libretunes/libretunes!24	2024-05-16 21:50:21 -04:00
Ethan Girouard	3c9ae521b1	Remove trailing comma from artist id field	2024-05-16 20:59:48 -04:00
dannyzou18	4958d3a881	fixed bug	2024-05-16 20:58:27 -04:00
Ethan Girouard	965bf5a457	Reduce axum features to tokio, http1	2024-05-16 19:30:46 -04:00
Ethan Girouard	8ffe09381c	Remove futures dependency Use tokio::join instead of futures::join	2024-05-16 19:23:48 -04:00
Ethan Girouard	12384b5a75	Disable default features in time	2024-05-16 19:18:53 -04:00
Ethan Girouard	bf9067aa43	Disable default features in serde	2024-05-16 19:17:21 -04:00
Ethan Girouard	7b43906632	Disable default features in diesel	2024-05-16 19:14:38 -04:00
Ethan Girouard	4685861af3	Make wasm-bindgen required for frontend only	2024-05-16 19:08:22 -04:00
Ethan Girouard	df78afbe60	Disable default features in wasm-bindgen	2024-05-16 19:07:39 -04:00
dannyzou18	caefc46fcc	added album search feature for upload	2024-05-16 18:59:16 -04:00
Ethan Girouard	94d62ea2d5	Disable default features in leptos crate	2024-05-16 18:53:58 -04:00
Ethan Girouard	893c411c7f	Disable default features in http crate	2024-05-16 18:51:47 -04:00
Ethan Girouard	618b7d65ce	Make console_error_panic_hook required for frontend only	2024-05-16 18:47:45 -04:00
Ethan Girouard	78d8e1243d	Remove csr feature	2024-05-16 18:42:03 -04:00
dannyzou18	955fc84412	allow choosing artists by searching for upload	2024-05-16 18:35:02 -04:00
Ethan Girouard	cc4aee4ab4	Add image_path column to albums table	2024-05-16 18:13:14 -04:00
dannyzou18	5775d3148b	finished upload design	2024-05-16 15:44:13 -04:00
dannyzou18	714fbc596a	styled upload form	2024-05-12 23:56:59 -07:00
Ethan Girouard	ff43b3f7e8	Use nested routing for navigation Remove dashboard_open signal Use <a> tags to navigate to new pages Add dashboard and search to nested routing	2024-05-12 11:00:47 -04:00
Ethan Girouard	8a959d530d	Implement basic upload dialog	2024-05-10 15:51:26 -04:00
Ethan Girouard	7abfbaf600	Fix unused imports	2024-05-10 15:25:57 -04:00
Ethan Girouard	161ea5f9c2	Implement file upload backend	2024-05-10 15:20:57 -04:00
Ethan Girouard	353a8e3a9c	Allow finding Artist and Album by primary key	2024-05-10 14:18:48 -04:00
Ethan Girouard	5d7ac2bb80	Add returning codec type to audio util function	2024-05-10 14:09:24 -04:00
Ethan Girouard	695f404ba8	Merge remote-tracking branch 'origin/main' into 19-implement-file-uploads	2024-05-10 12:49:58 -04:00
Ethan Girouard	79ba191415	Add function to get audio file duration	2024-05-10 11:28:43 -04:00
Ethan Girouard	3338cc2662	Add util module	2024-05-10 11:28:11 -04:00
Ethan Girouard	60ad643669	Merge branch '34-fix-serde-version-warning-in-cargo-toml' into 'main' Fix unspecified dependency version warnings in Cargo.toml Closes #34 See merge request libretunes/libretunes!23	2024-05-10 11:11:11 -04:00
Ethan Girouard	490772654d	Add multer crate	2024-05-10 10:55:26 -04:00
Ethan Girouard	b2fd8dc8e5	Fix misspelling of "version" for tower	2024-05-10 10:33:16 -04:00
Ethan Girouard	91812f4695	Fix misspelling of "version" for serde	2024-05-10 10:32:19 -04:00
Ethan Girouard	9b1ea51896	Merge branch '30-add-logging-to-startup-of-backend' into 'main' Add logging Closes #30 See merge request libretunes/libretunes!22	2024-05-08 17:56:45 -04:00
Ethan Girouard	6bf08b7507	Add symphonia crate	2024-04-19 09:23:10 -04:00
Ethan Girouard	04e0a66122	Add server_fn crate	2024-04-12 17:04:51 -04:00
Ethan Girouard	b6066e2d3e	Include ASCII art file in Docker build	2024-04-11 23:42:22 -04:00
Ethan Girouard	241389e5f7	Add logging to main	2024-04-11 23:19:21 -04:00
Ethan Girouard	557c189a17	Add ASCII art of logo and name	2024-04-11 23:19:02 -04:00
Ethan Girouard	4f6f3f90c1	Add flexi_logger crate	2024-04-11 23:14:53 -04:00
Ethan Girouard	7062c75013	Add log crate	2024-04-11 23:06:04 -04:00
		`@ -1,2 +0,0 @@`
			-- This file should undo anything in `up.sql`
			`DROP TABLE playlists;`
		`@ -0,0 +1 @@`
							`ALTER TABLE albums ADD COLUMN image_path VARCHAR;`
		`@ -0,0 +1 @@`
							`ALTER TABLE users ADD COLUMN admin BOOLEAN DEFAULT FALSE NOT NULL;`