+1

Cargo.lock

··· 277 277 "clap", 278 278 "dotenv", 279 279 "duckdb", 280 280 + "futures-util", 280 281 "owo-colors", 281 282 "polars", 282 283 "serde",

+1

crates/analytics/Cargo.toml

··· 27 27 polars = "0.46.0" 28 28 clap = "4.5.31" 29 29 actix-web = "4.9.0" 30 30 + futures-util = "0.3.31"

+34 -10

crates/analytics/src/cmd/serve.rs

··· 1 1 use std::env; 2 2 3 3 - use actix_web::{get, App, HttpRequest, HttpServer}; 3 3 + use actix_web::{get, post, web::{self, Data}, App, HttpRequest, HttpServer, Responder}; 4 4 use duckdb::Connection; 5 5 use anyhow::Error; 6 6 use owo_colors::OwoColorize; 7 7 + use std::sync::{Arc, Mutex}; 8 8 + 9 9 + use crate::handlers::handle; 7 10 8 11 #[get("/")] 9 12 async fn index(_req: HttpRequest) -> String { 10 13 "Hello world!".to_owned() 11 14 } 12 15 13 13 - pub async fn serve(_conn: &Connection) -> Result<(), Error> { 14 14 - let host = env::var("HOST").unwrap_or_else(|_| "127.0.0.1".to_string()); 15 15 - let port = env::var("PORT").unwrap_or_else(|_| "7879".to_string()); 16 16 + #[post("/{method}")] 17 17 + async fn call_method( 18 18 + data: web::Data<Arc<Mutex<Connection>>>, 19 19 + mut payload: web::Payload, 20 20 + req: HttpRequest) -> Result<impl Responder, actix_web::Error> { 21 21 + let method = req.match_info().get("method").unwrap_or("unknown"); 22 22 + println!("Method: {}", method.bright_green()); 23 23 + 24 24 + let conn = data.get_ref().clone(); 25 25 + handle(method, &mut payload, &req, conn).await 26 26 + .map_err(actix_web::error::ErrorInternalServerError) 27 27 + } 28 28 + 29 29 + 30 30 + pub async fn serve(conn: Arc<Mutex<Connection>>) -> Result<(), Error> { 31 31 + let host = env::var("ANALYTICS_HOST").unwrap_or_else(|_| "127.0.0.1".to_string()); 32 32 + let port = env::var("ANALYTICS_PORT").unwrap_or_else(|_| "7879".to_string()); 16 33 let addr = format!("{}:{}", host, port); 17 34 18 35 let url = format!("http://{}", addr); 19 36 println!("Listening on {}", url.bright_green()); 20 37 21 21 - HttpServer::new(|| App::new().service(index)) 22 22 - .bind(&addr)? 23 23 - .run() 24 24 - .await 25 25 - .map_err(Error::new)?; 38 38 + let conn = conn.clone(); 39 39 + HttpServer::new(move || { 40 40 + App::new() 41 41 + .app_data(Data::new( conn.clone())) 42 42 + .service(index) 43 43 + .service(call_method) 44 44 + }) 45 45 + .bind(&addr)? 46 46 + .run() 47 47 + .await 48 48 + .map_err(Error::new)?; 49 49 + 26 50 Ok(()) 27 27 - } 51 51 + }

+14 -12

crates/analytics/src/cmd/sync.rs

··· 1 1 + use std::sync::{Arc, Mutex}; 2 2 + 1 3 use anyhow::Error; 2 4 use duckdb::Connection; 3 5 use sqlx::{Pool, Postgres}; 4 6 use crate::core::*; 5 7 6 6 - pub async fn sync(conn: &Connection, pool: &Pool<Postgres>) -> Result<(), Error> { 7 7 - load_tracks(conn, pool).await?; 8 8 - load_artists(conn, pool).await?; 9 9 - load_albums(conn, pool).await?; 10 10 - load_users(conn, pool).await?; 11 11 - load_scrobbles(conn, pool).await?; 12 12 - load_album_tracks(conn, pool).await?; 13 13 - load_loved_tracks(conn, pool).await?; 14 14 - load_artist_tracks(conn, pool).await?; 15 15 - load_user_albums(conn, pool).await?; 16 16 - load_user_artists(conn, pool).await?; 17 17 - load_user_tracks(conn, pool).await?; 8 8 + pub async fn sync(conn: Arc<Mutex<Connection>>, pool: &Pool<Postgres>) -> Result<(), Error> { 9 9 + load_tracks(conn.clone(), pool).await?; 10 10 + load_artists(conn.clone(), pool).await?; 11 11 + load_albums(conn.clone(), pool).await?; 12 12 + load_users(conn.clone(), pool).await?; 13 13 + load_scrobbles(conn.clone(), pool).await?; 14 14 + load_album_tracks(conn.clone(), pool).await?; 15 15 + load_loved_tracks(conn.clone(), pool).await?; 16 16 + load_artist_tracks(conn.clone(), pool).await?; 17 17 + load_user_albums(conn.clone(), pool).await?; 18 18 + load_user_artists(conn.clone(), pool).await?; 19 19 + load_user_tracks(conn.clone(), pool).await?; 18 20 19 21 Ok(()) 20 22 }

+24 -11

crates/analytics/src/core.rs

··· 1 1 + use std::sync::{Arc, Mutex}; 2 2 + 1 3 use duckdb::{params, Connection}; 2 4 use anyhow::Error; 3 5 use owo_colors::OwoColorize; ··· 174 176 Ok(()) 175 177 } 176 178 177 177 - pub async fn load_tracks(conn: &Connection, pool: &Pool<Postgres>) -> Result<(), Error> { 179 179 + pub async fn load_tracks(conn: Arc<Mutex<Connection>>, pool: &Pool<Postgres>) -> Result<(), Error> { 180 180 + let conn = conn.lock().unwrap(); 178 181 let tracks: Vec<xata::track::Track> = sqlx::query_as(r#" 179 182 SELECT * FROM tracks 180 183 "#) ··· 246 249 Ok(()) 247 250 } 248 251 249 249 - pub async fn load_artists(conn: &Connection, pool: &Pool<Postgres>) -> Result<(), Error> { 252 252 + pub async fn load_artists(conn: Arc<Mutex<Connection>>, pool: &Pool<Postgres>) -> Result<(), Error> { 253 253 + let conn = conn.lock().unwrap(); 250 254 let artists: Vec<xata::artist::Artist> = sqlx::query_as(r#" 251 255 SELECT * FROM artists 252 256 "#) ··· 308 312 Ok(()) 309 313 } 310 314 311 311 - pub async fn load_albums(conn: &Connection, pool: &Pool<Postgres>) -> Result<(), Error> { 315 315 + pub async fn load_albums(conn: Arc<Mutex<Connection>>, pool: &Pool<Postgres>) -> Result<(), Error> { 316 316 + let conn = conn.lock().unwrap(); 312 317 let albums: Vec<xata::album::Album> = sqlx::query_as(r#" 313 318 SELECT * FROM albums 314 319 "#) ··· 370 375 Ok(()) 371 376 } 372 377 373 373 - pub async fn load_users(conn: &Connection, pool: &Pool<Postgres>) -> Result<(), Error> { 378 378 + pub async fn load_users(conn: Arc<Mutex<Connection>>, pool: &Pool<Postgres>) -> Result<(), Error> { 379 379 + let conn = conn.lock().unwrap(); 374 380 let users: Vec<xata::user::User> = sqlx::query_as(r#" 375 381 SELECT * FROM users 376 382 "#) ··· 408 414 Ok(()) 409 415 } 410 416 411 411 - pub async fn load_scrobbles(conn: &Connection, pool: &Pool<Postgres>) -> Result<(), Error> { 417 417 + pub async fn load_scrobbles(conn: Arc<Mutex<Connection>>, pool: &Pool<Postgres>) -> Result<(), Error> { 418 418 + let conn = conn.lock().unwrap(); 412 419 let scrobbles: Vec<xata::scrobble::Scrobble> = sqlx::query_as(r#" 413 420 SELECT * FROM scrobbles 414 421 "#) ··· 457 464 Ok(()) 458 465 } 459 466 460 460 - pub async fn load_album_tracks(conn: &Connection, pool: &Pool<Postgres>) -> Result<(), Error> { 467 467 + pub async fn load_album_tracks(conn: Arc<Mutex<Connection>>, pool: &Pool<Postgres>) -> Result<(), Error> { 468 468 + let conn = conn.lock().unwrap(); 461 469 let album_tracks: Vec<xata::album_track::AlbumTrack> = sqlx::query_as(r#" 462 470 SELECT * FROM album_tracks 463 471 "#) ··· 488 496 Ok(()) 489 497 } 490 498 491 491 - pub async fn load_loved_tracks(conn: &Connection, pool: &Pool<Postgres>) -> Result<(), Error> { 499 499 + pub async fn load_loved_tracks(conn: Arc<Mutex<Connection>>, pool: &Pool<Postgres>) -> Result<(), Error> { 500 500 + let conn = conn.lock().unwrap(); 492 501 let loved_tracks: Vec<xata::user_track::UserTrack> = sqlx::query_as(r#" 493 502 SELECT * FROM loved_tracks 494 503 "#) ··· 523 532 Ok(()) 524 533 } 525 534 526 526 - pub async fn load_artist_tracks(conn: &Connection, pool: &Pool<Postgres>) -> Result<(), Error> { 535 535 + pub async fn load_artist_tracks(conn: Arc<Mutex<Connection>>, pool: &Pool<Postgres>) -> Result<(), Error> { 536 536 + let conn = conn.lock().unwrap(); 527 537 let artist_tracks: Vec<xata::artist_track::ArtistTrack> = sqlx::query_as(r#" 528 538 SELECT * FROM artist_tracks 529 539 "#) ··· 550 560 Ok(()) 551 561 } 552 562 553 553 - pub async fn load_user_albums(conn: &Connection, pool: &Pool<Postgres>) -> Result<(), Error> { 563 563 + pub async fn load_user_albums(conn: Arc<Mutex<Connection>>, pool: &Pool<Postgres>) -> Result<(), Error> { 564 564 + let conn = conn.lock().unwrap(); 554 565 let user_albums: Vec<xata::user_album::UserAlbum> = sqlx::query_as(r#" 555 566 SELECT * FROM user_albums 556 567 "#) ··· 577 588 Ok(()) 578 589 } 579 590 580 580 - pub async fn load_user_artists(conn: &Connection, pool: &Pool<Postgres>) -> Result<(), Error> { 591 591 + pub async fn load_user_artists(conn: Arc<Mutex<Connection>>, pool: &Pool<Postgres>) -> Result<(), Error> { 592 592 + let conn = conn.lock().unwrap(); 581 593 let user_artists: Vec<xata::user_artist::UserArtist> = sqlx::query_as(r#" 582 594 SELECT * FROM user_artists 583 595 "#) ··· 604 616 Ok(()) 605 617 } 606 618 607 607 - pub async fn load_user_tracks(conn: &Connection, pool: &Pool<Postgres>) -> Result<(), Error> { 619 619 + pub async fn load_user_tracks(conn: Arc<Mutex<Connection>>, pool: &Pool<Postgres>) -> Result<(), Error> { 620 620 + let conn = conn.lock().unwrap(); 608 621 let user_tracks: Vec<xata::user_track::UserTrack> = sqlx::query_as(r#" 609 622 SELECT * FROM user_tracks 610 623 "#)

+187

crates/analytics/src/handlers/albums.rs

··· 1 1 + use std::sync::{Arc, Mutex}; 2 2 + 3 3 + use actix_web::{web, HttpRequest, HttpResponse}; 4 4 + use analytics::types::album::{Album, GetAlbumsParams, GetTopAlbumsParams}; 5 5 + use duckdb::Connection; 6 6 + use anyhow::Error; 7 7 + use futures_util::StreamExt; 8 8 + 9 9 + use crate::read_payload; 10 10 + 11 11 + pub async fn get_albums(payload: &mut web::Payload, _req: &HttpRequest, conn: Arc<Mutex<Connection>>) -> Result<HttpResponse, Error> { 12 12 + let body = read_payload!(payload); 13 13 + let params = serde_json::from_slice::<GetAlbumsParams>(&body)?; 14 14 + let pagination = params.pagination.unwrap_or_default(); 15 15 + let offset = pagination.skip.unwrap_or(0); 16 16 + let limit = pagination.take.unwrap_or(20); 17 17 + let did = params.user_did; 18 18 + 19 19 + let conn = conn.lock().unwrap(); 20 20 + let mut stmt = match did { 21 21 + Some(_) => { 22 22 + conn.prepare(r#" 23 23 + SELECT a.* FROM user_albums ua 24 24 + LEFT JOIN albums a ON ua.album_id = a.id 25 25 + LEFT JOIN users u ON ua.user_id = u.id 26 26 + WHERE u.did = ? 27 27 + ORDER BY a.title ASC OFFSET ? LIMIT ?; 28 28 + "#)? 29 29 + }, 30 30 + None => { 31 31 + conn.prepare("SELECT * FROM albums ORDER BY title ASC OFFSET ? LIMIT ?")? 32 32 + } 33 33 + }; 34 34 + 35 35 + match did { 36 36 + Some(did) => { 37 37 + let albums_iter = stmt.query_map([did, limit.to_string(), offset.to_string()], |row| { 38 38 + Ok(Album { 39 39 + id: row.get(0)?, 40 40 + title: row.get(1)?, 41 41 + artist: row.get(2)?, 42 42 + release_date: row.get(3)?, 43 43 + album_art: row.get(4)?, 44 44 + year: row.get(5)?, 45 45 + spotify_link: row.get(6)?, 46 46 + tidal_link: row.get(7)?, 47 47 + youtube_link: row.get(8)?, 48 48 + apple_music_link: row.get(9)?, 49 49 + sha256: row.get(10)?, 50 50 + uri: row.get(11)?, 51 51 + artist_uri: row.get(12)?, 52 52 + ..Default::default() 53 53 + }) 54 54 + })?; 55 55 + 56 56 + let albums: Result<Vec<_>, _> = albums_iter.collect(); 57 57 + Ok(HttpResponse::Ok().json(web::Json(albums?))) 58 58 + }, 59 59 + None => { 60 60 + let albums_iter = stmt.query_map([limit, offset], |row| { 61 61 + Ok(Album { 62 62 + id: row.get(0)?, 63 63 + title: row.get(1)?, 64 64 + artist: row.get(2)?, 65 65 + release_date: row.get(3)?, 66 66 + album_art: row.get(4)?, 67 67 + year: row.get(5)?, 68 68 + spotify_link: row.get(6)?, 69 69 + tidal_link: row.get(7)?, 70 70 + youtube_link: row.get(8)?, 71 71 + apple_music_link: row.get(9)?, 72 72 + sha256: row.get(10)?, 73 73 + uri: row.get(11)?, 74 74 + artist_uri: row.get(12)?, 75 75 + ..Default::default() 76 76 + }) 77 77 + })?; 78 78 + 79 79 + let albums: Result<Vec<_>, _> = albums_iter.collect(); 80 80 + Ok(HttpResponse::Ok().json(web::Json(albums?))) 81 81 + } 82 82 + } 83 83 + } 84 84 + 85 85 + 86 86 + pub async fn get_top_albums(payload: &mut web::Payload, _req: &HttpRequest, conn: Arc<Mutex<Connection>>) -> Result<HttpResponse, Error> { 87 87 + let body = read_payload!(payload); 88 88 + let params = serde_json::from_slice::<GetTopAlbumsParams>(&body)?; 89 89 + let pagination = params.pagination.unwrap_or_default(); 90 90 + let offset = pagination.skip.unwrap_or(0); 91 91 + let limit = pagination.take.unwrap_or(20); 92 92 + let did = params.user_did; 93 93 + 94 94 + let conn = conn.lock().unwrap(); 95 95 + let mut stmt = match did { 96 96 + Some(_) => conn.prepare(r#" 97 97 + SELECT 98 98 + s.album_id AS id, 99 99 + a.title AS title, 100 100 + ar.name AS artist, 101 101 + a.album_art AS album_art, 102 102 + a.release_date, 103 103 + a.year, 104 104 + a.uri AS uri, 105 105 + COUNT(*) AS play_count, 106 106 + COUNT(DISTINCT s.user_id) AS unique_listeners 107 107 + FROM 108 108 + scrobbles s 109 109 + LEFT JOIN 110 110 + albums a ON s.album_id = a.id 111 111 + LEFT JOIN 112 112 + artists ar ON a.artist_uri = ar.uri 113 113 + LEFT JOIN 114 114 + users u ON s.user_id = u.id 115 115 + WHERE s.album_id IS NOT NULL AND u.did = ? 116 116 + GROUP BY 117 117 + s.album_id, a.title, ar.name, a.release_date, a.year, a.uri, a.album_art 118 118 + ORDER BY 119 119 + play_count DESC 120 120 + OFFSET ? 121 121 + LIMIT ?; 122 122 + "#)?, 123 123 + None => conn.prepare(r#" 124 124 + SELECT 125 125 + s.album_id AS id, 126 126 + a.title AS title, 127 127 + ar.name AS artist, 128 128 + a.album_art AS album_art, 129 129 + a.release_date, 130 130 + a.year, 131 131 + a.uri AS uri, 132 132 + COUNT(*) AS play_count, 133 133 + COUNT(DISTINCT s.user_id) AS unique_listeners 134 134 + FROM 135 135 + scrobbles s 136 136 + LEFT JOIN 137 137 + albums a ON s.album_id = a.id 138 138 + LEFT JOIN 139 139 + artists ar ON a.artist_uri = ar.uri WHERE s.album_id IS NOT NULL 140 140 + GROUP BY 141 141 + s.album_id, a.title, ar.name, a.release_date, a.year, a.uri, a.album_art 142 142 + ORDER BY 143 143 + play_count DESC 144 144 + OFFSET ? 145 145 + LIMIT ?; 146 146 + "#)? 147 147 + }; 148 148 + 149 149 + match did { 150 150 + Some(did) => { 151 151 + let albums = stmt.query_map([did, limit.to_string(), offset.to_string()], |row| { 152 152 + Ok(Album { 153 153 + id: row.get(0)?, 154 154 + title: row.get(1)?, 155 155 + artist: row.get(2)?, 156 156 + album_art: row.get(3)?, 157 157 + release_date: row.get(4)?, 158 158 + year: row.get(5)?, 159 159 + uri: row.get(6)?, 160 160 + play_count: Some(row.get(7)?), 161 161 + unique_listeners: Some(row.get(8)?), 162 162 + ..Default::default() 163 163 + }) 164 164 + })?; 165 165 + let albums: Result<Vec<_>, _> = albums.collect(); 166 166 + Ok(HttpResponse::Ok().json(web::Json(albums?))) 167 167 + }, 168 168 + None => { 169 169 + let albums = stmt.query_map([limit, offset], |row| { 170 170 + Ok(Album { 171 171 + id: row.get(0)?, 172 172 + title: row.get(1)?, 173 173 + artist: row.get(2)?, 174 174 + album_art: row.get(3)?, 175 175 + release_date: row.get(4)?, 176 176 + year: row.get(5)?, 177 177 + uri: row.get(6)?, 178 178 + play_count: Some(row.get(7)?), 179 179 + unique_listeners: Some(row.get(8)?), 180 180 + ..Default::default() 181 181 + }) 182 182 + })?; 183 183 + let albums: Result<Vec<_>, _> = albums.collect(); 184 184 + Ok(HttpResponse::Ok().json(web::Json(albums?))) 185 185 + } 186 186 + } 187 187 + }

+199

crates/analytics/src/handlers/artists.rs

··· 1 1 + use std::sync::{Arc, Mutex}; 2 2 + 3 3 + use actix_web::{web, HttpRequest, HttpResponse}; 4 4 + use analytics::types::artist::{Artist, GetTopArtistsParams}; 5 5 + use duckdb::Connection; 6 6 + use anyhow::Error; 7 7 + use futures_util::StreamExt; 8 8 + 9 9 + use crate::{read_payload, types::artist::GetArtistsParams}; 10 10 + 11 11 + pub async fn get_artists(payload: &mut web::Payload, _req: &HttpRequest, conn: Arc<Mutex<Connection>>) -> Result<HttpResponse, Error> { 12 12 + let body = read_payload!(payload); 13 13 + let params = serde_json::from_slice::<GetArtistsParams>(&body)?; 14 14 + let pagination = params.pagination.unwrap_or_default(); 15 15 + let offset = pagination.skip.unwrap_or(0); 16 16 + let limit = pagination.take.unwrap_or(20); 17 17 + let did = params.user_did; 18 18 + 19 19 + let conn = conn.lock().unwrap(); 20 20 + let mut stmt = match did { 21 21 + Some(_) => { 22 22 + conn.prepare(r#" 23 23 + SELECT a.* FROM user_artists ua 24 24 + LEFT JOIN artists a ON ua.artist_id = a.id 25 25 + LEFT JOIN users u ON ua.user_id = u.id 26 26 + WHERE u.did = ? 27 27 + ORDER BY a.name ASC OFFSET ? LIMIT ?; 28 28 + "#)? 29 29 + }, 30 30 + None => { 31 31 + conn.prepare("SELECT * FROM artists ORDER BY name ASC OFFSET ? LIMIT ?")? 32 32 + } 33 33 + }; 34 34 + 35 35 + match did { 36 36 + Some(did) => { 37 37 + let artists = stmt.query_map([did, limit.to_string(), offset.to_string()], |row| { 38 38 + Ok(Artist { 39 39 + id: row.get(0)?, 40 40 + name: row.get(1)?, 41 41 + biography: row.get(2)?, 42 42 + born: row.get(3)?, 43 43 + born_in: row.get(4)?, 44 44 + died: row.get(5)?, 45 45 + picture: row.get(6)?, 46 46 + sha256: row.get(7)?, 47 47 + spotify_link: row.get(8)?, 48 48 + tidal_link: row.get(9)?, 49 49 + youtube_link: row.get(10)?, 50 50 + apple_music_link: row.get(11)?, 51 51 + uri: row.get(12)?, 52 52 + play_count: None, 53 53 + unique_listeners: None, 54 54 + }) 55 55 + })?; 56 56 + 57 57 + let artists: Result<Vec<_>, _> = artists.collect(); 58 58 + Ok(HttpResponse::Ok().json(artists?)) 59 59 + }, 60 60 + None => { 61 61 + let artists = stmt.query_map([limit, offset], |row| { 62 62 + Ok(Artist { 63 63 + id: row.get(0)?, 64 64 + name: row.get(1)?, 65 65 + biography: row.get(2)?, 66 66 + born: row.get(3)?, 67 67 + born_in: row.get(4)?, 68 68 + died: row.get(5)?, 69 69 + picture: row.get(6)?, 70 70 + sha256: row.get(7)?, 71 71 + spotify_link: row.get(8)?, 72 72 + tidal_link: row.get(9)?, 73 73 + youtube_link: row.get(10)?, 74 74 + apple_music_link: row.get(11)?, 75 75 + uri: row.get(12)?, 76 76 + play_count: None, 77 77 + unique_listeners: None, 78 78 + }) 79 79 + })?; 80 80 + 81 81 + let artists: Result<Vec<_>, _> = artists.collect(); 82 82 + Ok(HttpResponse::Ok().json(artists?)) 83 83 + } 84 84 + } 85 85 + } 86 86 + 87 87 + pub async fn get_top_artists(payload: &mut web::Payload, _req: &HttpRequest, conn: Arc<Mutex<Connection>>) -> Result<HttpResponse, Error> { 88 88 + let body = read_payload!(payload); 89 89 + let params = serde_json::from_slice::<GetTopArtistsParams>(&body)?; 90 90 + let pagination = params.pagination.unwrap_or_default(); 91 91 + let offset = pagination.skip.unwrap_or(0); 92 92 + let limit = pagination.take.unwrap_or(20); 93 93 + let did = params.user_did; 94 94 + 95 95 + let conn = conn.lock().unwrap(); 96 96 + let mut stmt = match did { 97 97 + Some(_) => { 98 98 + conn.prepare(r#" 99 99 + SELECT 100 100 + s.artist_id AS id, 101 101 + ar.name AS artist_name, 102 102 + ar.picture AS picture, 103 103 + ar.sha256 AS sha256, 104 104 + ar.uri AS uri, 105 105 + COUNT(*) AS play_count, 106 106 + COUNT(DISTINCT s.user_id) AS unique_listeners 107 107 + FROM 108 108 + scrobbles s 109 109 + LEFT JOIN 110 110 + artists ar ON s.artist_id = ar.id 111 111 + LEFT JOIN 112 112 + users u ON s.user_id = u.id 113 113 + WHERE 114 114 + s.artist_id IS NOT NULL AND u.did = ? 115 115 + GROUP BY 116 116 + s.artist_id, ar.name, ar.uri, ar.picture, ar.sha256 117 117 + ORDER BY 118 118 + play_count DESC 119 119 + OFFSET ? 120 120 + LIMIT ?; 121 121 + "#)? 122 122 + }, 123 123 + None => { 124 124 + conn.prepare(r#" 125 125 + SELECT 126 126 + s.artist_id AS id, 127 127 + ar.name AS artist_name, 128 128 + ar.picture AS picture, 129 129 + ar.sha256 AS sha256, 130 130 + ar.uri AS uri, 131 131 + COUNT(*) AS play_count, 132 132 + COUNT(DISTINCT s.user_id) AS unique_listeners 133 133 + FROM 134 134 + scrobbles s 135 135 + LEFT JOIN 136 136 + artists ar ON s.artist_id = ar.id 137 137 + WHERE 138 138 + s.artist_id IS NOT NULL 139 139 + GROUP BY 140 140 + s.artist_id, ar.name, ar.uri, ar.picture, ar.sha256 141 141 + ORDER BY 142 142 + play_count DESC 143 143 + OFFSET ? 144 144 + LIMIT ?; 145 145 + "#)? 146 146 + } 147 147 + }; 148 148 + 149 149 + match did { 150 150 + Some(did) => { 151 151 + let artists = stmt.query_map([did, limit.to_string(), offset.to_string()], |row| { 152 152 + Ok(Artist { 153 153 + id: row.get(0)?, 154 154 + name: row.get(1)?, 155 155 + biography: None, 156 156 + born: None, 157 157 + born_in: None, 158 158 + died: None, 159 159 + picture: row.get(2)?, 160 160 + sha256: row.get(3)?, 161 161 + spotify_link: None, 162 162 + tidal_link: None, 163 163 + youtube_link: None, 164 164 + apple_music_link: None, 165 165 + uri: row.get(4)?, 166 166 + play_count: Some(row.get(5)?), 167 167 + unique_listeners: Some(row.get(6)?), 168 168 + }) 169 169 + })?; 170 170 + 171 171 + let artists: Result<Vec<_>, _> = artists.collect(); 172 172 + Ok(HttpResponse::Ok().json(artists?)) 173 173 + }, 174 174 + None => { 175 175 + let artists = stmt.query_map([limit, offset], |row| { 176 176 + Ok(Artist { 177 177 + id: row.get(0)?, 178 178 + name: row.get(1)?, 179 179 + biography: None, 180 180 + born: None, 181 181 + born_in: None, 182 182 + died: None, 183 183 + picture: row.get(2)?, 184 184 + sha256: row.get(3)?, 185 185 + spotify_link: None, 186 186 + tidal_link: None, 187 187 + youtube_link: None, 188 188 + apple_music_link: None, 189 189 + uri: row.get(4)?, 190 190 + play_count: Some(row.get(5)?), 191 191 + unique_listeners: Some(row.get(6)?), 192 192 + }) 193 193 + })?; 194 194 + 195 195 + let artists: Result<Vec<_>, _> = artists.collect(); 196 196 + Ok(HttpResponse::Ok().json(artists?)) 197 197 + } 198 198 + } 199 199 + }

+50

crates/analytics/src/handlers/mod.rs

··· 1 1 + use std::sync::{Arc, Mutex}; 2 2 + 3 3 + use actix_web::{web, HttpRequest, HttpResponse}; 4 4 + use albums::{get_albums, get_top_albums}; 5 5 + use artists::{get_artists, get_top_artists}; 6 6 + use duckdb::Connection; 7 7 + use scrobbles::get_scrobbles; 8 8 + use stats::{get_scrobbles_per_day, get_scrobbles_per_month, get_scrobbles_per_year, get_stats}; 9 9 + use tracks::{get_loved_tracks, get_top_tracks, get_tracks}; 10 10 + use anyhow::Error; 11 11 + 12 12 + pub mod albums; 13 13 + pub mod artists; 14 14 + pub mod scrobbles; 15 15 + pub mod tracks; 16 16 + pub mod stats; 17 17 + 18 18 + 19 19 + #[macro_export] 20 20 + macro_rules! read_payload { 21 21 + ($payload:expr) => {{ 22 22 + let mut body = Vec::new(); 23 23 + while let Some(chunk) = $payload.next().await { 24 24 + match chunk { 25 25 + Ok(bytes) => body.extend_from_slice(&bytes), 26 26 + Err(err) => return Err(err.into()), 27 27 + } 28 28 + } 29 29 + body 30 30 + }}; 31 31 + } 32 32 + 33 33 + 34 34 + pub async fn handle(method: &str, payload: &mut web::Payload, req: &HttpRequest, conn: Arc<Mutex<Connection>>) -> Result<HttpResponse, Error> { 35 35 + match method { 36 36 + "library.getAlbums" => get_albums(payload, req, conn.clone()).await, 37 37 + "library.getArtists" => get_artists(payload, req, conn.clone()).await, 38 38 + "library.getTracks" => get_tracks(payload, req, conn.clone()).await, 39 39 + "library.getScrobbles" => get_scrobbles(payload, req, conn.clone()).await, 40 40 + "library.getLovedTracks" => get_loved_tracks(payload, req, conn.clone()).await, 41 41 + "library.getStats" => get_stats(payload, req, conn.clone()).await, 42 42 + "library.getTopAlbums" => get_top_albums(payload, req, conn.clone()).await, 43 43 + "library.getTopArtists" => get_top_artists(payload, req, conn.clone()).await, 44 44 + "library.getTopTracks" => get_top_tracks(payload, req, conn.clone()).await, 45 45 + "library.getScrobblesPerDay" => get_scrobbles_per_day(payload, req, conn.clone()).await, 46 46 + "library.getScrobblesPerMonth" => get_scrobbles_per_month(payload, req, conn.clone()).await, 47 47 + "library.getScrobblesPerYear" => get_scrobbles_per_year(payload, req, conn.clone()).await, 48 48 + _ => return Err(anyhow::anyhow!("Method not found")), 49 49 + } 50 50 + }

+117

crates/analytics/src/handlers/scrobbles.rs

··· 1 1 + use std::sync::{Arc, Mutex}; 2 2 + 3 3 + use actix_web::{web, HttpRequest, HttpResponse}; 4 4 + use analytics::types::scrobble::{GetScrobblesParams, ScrobbleTrack}; 5 5 + use duckdb::Connection; 6 6 + use anyhow::Error; 7 7 + use futures_util::StreamExt; 8 8 + 9 9 + use crate::read_payload; 10 10 + 11 11 + pub async fn get_scrobbles(payload: &mut web::Payload, _req: &HttpRequest, conn: Arc<Mutex<Connection>>) -> Result<HttpResponse, Error> { 12 12 + let body = read_payload!(payload); 13 13 + let params = serde_json::from_slice::<GetScrobblesParams>(&body)?; 14 14 + let pagination = params.pagination.unwrap_or_default(); 15 15 + let offset = pagination.skip.unwrap_or(0); 16 16 + let limit = pagination.take.unwrap_or(20); 17 17 + let did = params.user_did; 18 18 + 19 19 + let conn = conn.lock().unwrap(); 20 20 + let mut stmt = match did { 21 21 + Some(_) => conn.prepare(r#" 22 22 + SELECT 23 23 + s.id, 24 24 + t.id as track_id, 25 25 + t.title, 26 26 + t.artist, 27 27 + t.album_artist, 28 28 + t.album, 29 29 + t.album_art, 30 30 + u.handle, 31 31 + s.uri, 32 32 + t.uri as track_uri, 33 33 + a.uri as artist_uri, 34 34 + al.uri as album_uri, 35 35 + s.created_at 36 36 + FROM scrobbles s 37 37 + LEFT JOIN artists a ON s.artist_id = a.id 38 38 + LEFT JOIN albums al ON s.album_id = al.id 39 39 + LEFT JOIN tracks t ON s.track_id = t.id 40 40 + LEFT JOIN users u ON s.user_id = u.id 41 41 + WHERE u.did = ? 42 42 + GROUP BY s.id, s.created_at, t.id, t.title, t.artist, t.album_artist, t.album, t.album_art, s.uri, t.uri, u.handle, a.uri, al.uri, s.created_at 43 43 + ORDER BY s.created_at DESC 44 44 + OFFSET ? 45 45 + LIMIT ?; 46 46 + "#)?, 47 47 + None => conn.prepare(r#" 48 48 + SELECT 49 49 + s.id, 50 50 + t.id as track_id, 51 51 + t.title, 52 52 + t.artist, 53 53 + t.album_artist, 54 54 + t.album, 55 55 + t.album_art, 56 56 + u.handle, 57 57 + s.uri, 58 58 + t.uri as track_uri, 59 59 + a.uri as artist_uri, 60 60 + al.uri as album_uri, 61 61 + s.created_at 62 62 + FROM scrobbles s 63 63 + LEFT JOIN artists a ON s.artist_id = a.id 64 64 + LEFT JOIN albums al ON s.album_id = al.id 65 65 + LEFT JOIN tracks t ON s.track_id = t.id 66 66 + LEFT JOIN users u ON s.user_id = u.id 67 67 + GROUP BY s.id, s.created_at, t.id, t.title, t.artist, t.album_artist, t.album, t.album_art, s.uri, t.uri, u.handle, a.uri, al.uri, s.created_at 68 68 + ORDER BY s.created_at DESC 69 69 + OFFSET ? 70 70 + LIMIT ?; 71 71 + "#)?, 72 72 + }; 73 73 + match did { 74 74 + Some(did) => { 75 75 + let scrobbles = stmt.query_map([did, limit.to_string(), offset.to_string()], |row| { 76 76 + Ok(ScrobbleTrack { 77 77 + id: row.get(0)?, 78 78 + track_id: row.get(1)?, 79 79 + title: row.get(2)?, 80 80 + artist: row.get(3)?, 81 81 + album_artist: row.get(4)?, 82 82 + album: row.get(5)?, 83 83 + album_art: row.get(6)?, 84 84 + handle: row.get(7)?, 85 85 + uri: row.get(8)?, 86 86 + track_uri: row.get(9)?, 87 87 + artist_uri: row.get(10)?, 88 88 + album_uri: row.get(11)?, 89 89 + created_at: row.get(12)?, 90 90 + }) 91 91 + })?; 92 92 + let scrobbles: Result<Vec<_>, _> = scrobbles.collect(); 93 93 + Ok(HttpResponse::Ok().json(scrobbles?)) 94 94 + }, 95 95 + None => { 96 96 + let scrobbles = stmt.query_map([limit, offset], |row| { 97 97 + Ok(ScrobbleTrack { 98 98 + id: row.get(0)?, 99 99 + track_id: row.get(1)?, 100 100 + title: row.get(2)?, 101 101 + artist: row.get(3)?, 102 102 + album_artist: row.get(4)?, 103 103 + album: row.get(5)?, 104 104 + album_art: row.get(6)?, 105 105 + handle: row.get(7)?, 106 106 + uri: row.get(8)?, 107 107 + track_uri: row.get(9)?, 108 108 + artist_uri: row.get(10)?, 109 109 + album_uri: row.get(11)?, 110 110 + created_at: row.get(12)?, 111 111 + }) 112 112 + })?; 113 113 + let scrobbles: Result<Vec<_>, _> = scrobbles.collect(); 114 114 + Ok(HttpResponse::Ok().json(scrobbles?)) 115 115 + } 116 116 + } 117 117 + }

+222

crates/analytics/src/handlers/stats.rs

··· 1 1 + use std::sync::{Arc, Mutex}; 2 2 + 3 3 + use actix_web::{web, HttpRequest, HttpResponse}; 4 4 + use analytics::types::{scrobble::{ScrobblesPerDay, ScrobblesPerMonth, ScrobblesPerYear}, stats::{GetScrobblesPerDayParams, GetScrobblesPerMonthParams, GetScrobblesPerYearParams, GetStatsParams}}; 5 5 + use duckdb::Connection; 6 6 + use anyhow::Error; 7 7 + use serde_json::json; 8 8 + use futures_util::StreamExt; 9 9 + use crate::read_payload; 10 10 + 11 11 + pub async fn get_stats(payload: &mut web::Payload, _req: &HttpRequest, conn: Arc<Mutex<Connection>>) -> Result<HttpResponse, Error> { 12 12 + let body = read_payload!(payload); 13 13 + let params = serde_json::from_slice::<GetStatsParams>(&body)?; 14 14 + 15 15 + let conn = conn.lock().unwrap(); 16 16 + let mut stmt = conn.prepare("SELECT COUNT(*) FROM scrobbles s LEFT JOIN users u ON s.user_id = u.id WHERE u.did = ?")?; 17 17 + let scrobbles: i64 = stmt.query_row([&params.user_did], |row| row.get(0))?; 18 18 + 19 19 + let mut stmt = conn.prepare("SELECT COUNT(*) FROM user_artists LEFT JOIN users u ON user_artists.user_id = u.id WHERE u.did = ?")?; 20 20 + let artists: i64 = stmt.query_row([&params.user_did], |row| row.get(0))?; 21 21 + 22 22 + let mut stmt = conn.prepare("SELECT COUNT(*) FROM loved_tracks LEFT JOIN users u ON loved_tracks.user_id = u.id WHERE u.did = ?")?; 23 23 + let loved_tracks: i64 = stmt.query_row([&params.user_did], |row| row.get(0))?; 24 24 + 25 25 + let mut stmt = conn.prepare("SELECT COUNT(*) FROM user_albums LEFT JOIN users u ON user_albums.user_id = u.id WHERE u.did = ?")?; 26 26 + let albums: i64 = stmt.query_row([&params.user_did], |row| row.get(0))?; 27 27 + 28 28 + let mut stmt = conn.prepare("SELECT COUNT(*) FROM user_tracks LEFT JOIN users u ON user_tracks.user_id = u.id WHERE u.did = ?")?; 29 29 + let tracks: i64 = stmt.query_row([&params.user_did], |row| row.get(0))?; 30 30 + 31 31 + Ok(HttpResponse::Ok().json(json!({ 32 32 + "scrobbles": scrobbles, 33 33 + "artists": artists, 34 34 + "loved_tracks": loved_tracks, 35 35 + "albums": albums, 36 36 + "tracks": tracks, 37 37 + }))) 38 38 + } 39 39 + 40 40 + pub async fn get_scrobbles_per_day(payload: &mut web::Payload, _req: &HttpRequest, conn: Arc<Mutex<Connection>>) -> Result<HttpResponse, Error> { 41 41 + let body = read_payload!(payload); 42 42 + let params = serde_json::from_slice::<GetScrobblesPerDayParams>(&body)?; 43 43 + let start = params.start.unwrap_or(GetScrobblesPerDayParams::default().start.unwrap()); 44 44 + let end = params.end.unwrap_or(GetScrobblesPerDayParams::default().end.unwrap()); 45 45 + let did = params.user_did; 46 46 + 47 47 + let conn = conn.lock().unwrap(); 48 48 + match did { 49 49 + Some(did) => { 50 50 + let mut stmt = conn.prepare(r#" 51 51 + SELECT 52 52 + date_trunc('day', created_at) AS date, 53 53 + COUNT(track_id) AS count 54 54 + FROM 55 55 + scrobbles 56 56 + LEFT JOIN users u ON scrobbles.user_id = u.id 57 57 + WHERE 58 58 + u.did = ? 59 59 + AND created_at BETWEEN ? AND ? 60 60 + GROUP BY 61 61 + date_trunc('day', created_at) 62 62 + ORDER BY 63 63 + date; 64 64 + "#)?; 65 65 + let scrobbles = stmt.query_map([did, start, end], |row| { 66 66 + Ok(ScrobblesPerDay { 67 67 + date: row.get(0)?, 68 68 + count: row.get(1)?, 69 69 + }) 70 70 + })?; 71 71 + let scrobbles: Result<Vec<_>, _> = scrobbles.collect(); 72 72 + Ok(HttpResponse::Ok().json(scrobbles?)) 73 73 + }, 74 74 + None => { 75 75 + let mut stmt = conn.prepare(r#" 76 76 + SELECT 77 77 + date_trunc('day', created_at) AS date, 78 78 + COUNT(track_id) AS count 79 79 + FROM 80 80 + scrobbles 81 81 + WHERE 82 82 + created_at BETWEEN ? AND ? 83 83 + GROUP BY 84 84 + date_trunc('day', created_at) 85 85 + ORDER BY 86 86 + date; 87 87 + "#)?; 88 88 + let scrobbles = stmt.query_map([start, end], |row| { 89 89 + Ok(ScrobblesPerDay { 90 90 + date: row.get(0)?, 91 91 + count: row.get(1)?, 92 92 + }) 93 93 + })?; 94 94 + let scrobbles: Result<Vec<_>, _> = scrobbles.collect(); 95 95 + Ok(HttpResponse::Ok().json(scrobbles?)) 96 96 + } 97 97 + } 98 98 + } 99 99 + 100 100 + pub async fn get_scrobbles_per_month(payload: &mut web::Payload, _req: &HttpRequest, conn: Arc<Mutex<Connection>>) -> Result<HttpResponse, Error> { 101 101 + let body = read_payload!(payload); 102 102 + let params = serde_json::from_slice::<GetScrobblesPerMonthParams>(&body)?; 103 103 + let start = params.start.unwrap_or(GetScrobblesPerDayParams::default().start.unwrap()); 104 104 + let end = params.end.unwrap_or(GetScrobblesPerDayParams::default().end.unwrap()); 105 105 + let did = params.user_did; 106 106 + 107 107 + let conn = conn.lock().unwrap(); 108 108 + match did { 109 109 + Some(did) => { 110 110 + let mut stmt = conn.prepare(r#" 111 111 + SELECT 112 112 + EXTRACT(YEAR FROM created_at) || '-' || 113 113 + LPAD(EXTRACT(MONTH FROM created_at)::VARCHAR, 2, '0') AS year_month, 114 114 + COUNT(*) AS count 115 115 + FROM 116 116 + scrobbles 117 117 + LEFT JOIN users u ON scrobbles.user_id = u.id 118 118 + WHERE 119 119 + u.did = ? 120 120 + AND created_at BETWEEN ? AND ? 121 121 + GROUP BY 122 122 + EXTRACT(YEAR FROM created_at), 123 123 + EXTRACT(MONTH FROM created_at) 124 124 + ORDER BY 125 125 + year_month; 126 126 + "#)?; 127 127 + let scrobbles = stmt.query_map([did, start, end], |row| { 128 128 + Ok(ScrobblesPerMonth { 129 129 + year_month: row.get(0)?, 130 130 + count: row.get(1)?, 131 131 + }) 132 132 + })?; 133 133 + let scrobbles: Result<Vec<_>, _> = scrobbles.collect(); 134 134 + Ok(HttpResponse::Ok().json(scrobbles?)) 135 135 + }, 136 136 + None => { 137 137 + let mut stmt = conn.prepare(r#" 138 138 + SELECT 139 139 + EXTRACT(YEAR FROM created_at) || '-' || 140 140 + LPAD(EXTRACT(MONTH FROM created_at)::VARCHAR, 2, '0') AS year_month, 141 141 + COUNT(*) AS count 142 142 + FROM 143 143 + scrobbles 144 144 + WHERE 145 145 + created_at BETWEEN ? AND ? 146 146 + GROUP BY 147 147 + EXTRACT(YEAR FROM created_at), 148 148 + EXTRACT(MONTH FROM created_at) 149 149 + ORDER BY 150 150 + year_month; 151 151 + "#)?; 152 152 + let scrobbles = stmt.query_map([start, end], |row| { 153 153 + Ok(ScrobblesPerMonth { 154 154 + year_month: row.get(0)?, 155 155 + count: row.get(1)?, 156 156 + }) 157 157 + })?; 158 158 + let scrobbles: Result<Vec<_>, _> = scrobbles.collect(); 159 159 + Ok(HttpResponse::Ok().json(scrobbles?)) 160 160 + } 161 161 + } 162 162 + } 163 163 + 164 164 + pub async fn get_scrobbles_per_year(payload: &mut web::Payload, _req: &HttpRequest, conn: Arc<Mutex<Connection>>) -> Result<HttpResponse, Error> { 165 165 + let body = read_payload!(payload); 166 166 + let params = serde_json::from_slice::<GetScrobblesPerYearParams>(&body)?; 167 167 + let start = params.start.unwrap_or(GetScrobblesPerDayParams::default().start.unwrap()); 168 168 + let end = params.end.unwrap_or(GetScrobblesPerDayParams::default().end.unwrap()); 169 169 + let did = params.user_did; 170 170 + 171 171 + let conn = conn.lock().unwrap(); 172 172 + match did { 173 173 + Some(did) => { 174 174 + let mut stmt = conn.prepare(r#" 175 175 + SELECT 176 176 + EXTRACT(YEAR FROM created_at) AS year, 177 177 + COUNT(*) AS count 178 178 + FROM 179 179 + scrobbles 180 180 + LEFT JOIN users u ON scrobbles.user_id = u.id 181 181 + WHERE 182 182 + u.did = ? 183 183 + AND created_at BETWEEN ? AND ? 184 184 + GROUP BY 185 185 + EXTRACT(YEAR FROM created_at) 186 186 + ORDER BY 187 187 + year; 188 188 + "#)?; 189 189 + let scrobbles = stmt.query_map([did, start, end], |row| { 190 190 + Ok(ScrobblesPerYear { 191 191 + year: row.get(0)?, 192 192 + count: row.get(1)?, 193 193 + }) 194 194 + })?; 195 195 + let scrobbles: Result<Vec<_>, _> = scrobbles.collect(); 196 196 + Ok(HttpResponse::Ok().json(scrobbles?)) 197 197 + }, 198 198 + None => { 199 199 + let mut stmt = conn.prepare(r#" 200 200 + SELECT 201 201 + EXTRACT(YEAR FROM created_at) AS year, 202 202 + COUNT(*) AS count 203 203 + FROM 204 204 + scrobbles 205 205 + WHERE 206 206 + created_at BETWEEN ? AND ? 207 207 + GROUP BY 208 208 + EXTRACT(YEAR FROM created_at) 209 209 + ORDER BY 210 210 + year; 211 211 + "#)?; 212 212 + let scrobbles = stmt.query_map([start, end], |row| { 213 213 + Ok(ScrobblesPerYear { 214 214 + year: row.get(0)?, 215 215 + count: row.get(1)?, 216 216 + }) 217 217 + })?; 218 218 + let scrobbles: Result<Vec<_>, _> = scrobbles.collect(); 219 219 + Ok(HttpResponse::Ok().json(scrobbles?)) 220 220 + } 221 221 + } 222 222 + }

+344

crates/analytics/src/handlers/tracks.rs

··· 1 1 + use std::sync::{Arc, Mutex}; 2 2 + 3 3 + use actix_web::{web, HttpRequest, HttpResponse}; 4 4 + use analytics::types::track::{GetLovedTracksParams, GetTopTracksParams, GetTracksParams, Track}; 5 5 + use duckdb::Connection; 6 6 + use anyhow::Error; 7 7 + use futures_util::StreamExt; 8 8 + 9 9 + use crate::read_payload; 10 10 + 11 11 + pub async fn get_tracks(payload: &mut web::Payload, _req: &HttpRequest, conn: Arc<Mutex<Connection>> 12 12 + ) -> Result<HttpResponse, Error> { 13 13 + let body = read_payload!(payload); 14 14 + let params = serde_json::from_slice::<GetTracksParams>(&body)?; 15 15 + let pagination = params.pagination.unwrap_or_default(); 16 16 + let offset = pagination.skip.unwrap_or(0); 17 17 + let limit = pagination.take.unwrap_or(20); 18 18 + let did = params.user_did; 19 19 + 20 20 + let conn = conn.lock().unwrap(); 21 21 + match did { 22 22 + Some(did) => { 23 23 + let mut stmt = conn.prepare(r#" 24 24 + SELECT 25 25 + t.id, 26 26 + t.title, 27 27 + t.artist, 28 28 + t.album_artist, 29 29 + t.album_art, 30 30 + t.album, 31 31 + t.track_number, 32 32 + t.duration, 33 33 + t.mb_id, 34 34 + t.youtube_link, 35 35 + t.spotify_link, 36 36 + t.tidal_link, 37 37 + t.apple_music_link, 38 38 + t.sha256, 39 39 + t.composer, 40 40 + t.genre, 41 41 + t.disc_number, 42 42 + t.label, 43 43 + t.uri, 44 44 + t.copyright_message, 45 45 + t.artist_uri, 46 46 + t.album_uri, 47 47 + t.created_at, 48 48 + FROM tracks t 49 49 + LEFT JOIN user_tracks ut ON t.id = ut.track_id 50 50 + LEFT JOIN users u ON ut.user_id = u.id 51 51 + WHERE u.did = ? 52 52 + ORDER BY t.title ASC 53 53 + OFFSET ? 54 54 + LIMIT ?; 55 55 + "#)?; 56 56 + let tracks = stmt.query_map([did, limit.to_string(), offset.to_string()], |row| { 57 57 + Ok(Track { 58 58 + id: row.get(0)?, 59 59 + title: row.get(1)?, 60 60 + artist: row.get(2)?, 61 61 + album_artist: row.get(3)?, 62 62 + album_art: row.get(4)?, 63 63 + album: row.get(5)?, 64 64 + track_number: row.get(6)?, 65 65 + duration: row.get(7)?, 66 66 + mb_id: row.get(8)?, 67 67 + youtube_link: row.get(9)?, 68 68 + spotify_link: row.get(10)?, 69 69 + tidal_link: row.get(11)?, 70 70 + apple_music_link: row.get(12)?, 71 71 + sha256: row.get(13)?, 72 72 + composer: row.get(14)?, 73 73 + genre: row.get(15)?, 74 74 + disc_number: row.get(16)?, 75 75 + label: row.get(17)?, 76 76 + uri: row.get(18)?, 77 77 + copyright_message: row.get(19)?, 78 78 + artist_uri: row.get(20)?, 79 79 + album_uri: row.get(21)?, 80 80 + created_at: row.get(22)?, 81 81 + ..Default::default() 82 82 + }) 83 83 + })?; 84 84 + let tracks: Result<Vec<_>, _> = tracks.collect(); 85 85 + Ok(HttpResponse::Ok().json(tracks?)) 86 86 + }, 87 87 + None => { 88 88 + let mut stmt = conn.prepare(r#" 89 89 + SELECT 90 90 + id, 91 91 + title, 92 92 + artist, 93 93 + album_artist, 94 94 + album_art, 95 95 + album, 96 96 + track_number, 97 97 + duration, 98 98 + mb_id, 99 99 + youtube_link, 100 100 + spotify_link, 101 101 + tidal_link, 102 102 + apple_music_link, 103 103 + sha256, 104 104 + composer, 105 105 + genre, 106 106 + disc_number, 107 107 + label, 108 108 + uri, 109 109 + copyright_message, 110 110 + artist_uri, 111 111 + album_uri, 112 112 + created_at, 113 113 + FROM tracks 114 114 + ORDER BY title ASC 115 115 + OFFSET ? 116 116 + LIMIT ?; 117 117 + "#)?; 118 118 + let tracks = stmt.query_map([limit, offset], |row| { 119 119 + Ok(Track { 120 120 + id: row.get(0)?, 121 121 + title: row.get(1)?, 122 122 + artist: row.get(2)?, 123 123 + album_artist: row.get(3)?, 124 124 + album_art: row.get(4)?, 125 125 + album: row.get(5)?, 126 126 + track_number: row.get(6)?, 127 127 + duration: row.get(7)?, 128 128 + mb_id: row.get(8)?, 129 129 + youtube_link: row.get(9)?, 130 130 + spotify_link: row.get(10)?, 131 131 + tidal_link: row.get(11)?, 132 132 + apple_music_link: row.get(12)?, 133 133 + sha256: row.get(13)?, 134 134 + composer: row.get(14)?, 135 135 + genre: row.get(15)?, 136 136 + disc_number: row.get(16)?, 137 137 + label: row.get(17)?, 138 138 + uri: row.get(18)?, 139 139 + copyright_message: row.get(19)?, 140 140 + artist_uri: row.get(20)?, 141 141 + album_uri: row.get(21)?, 142 142 + created_at: row.get(22)?, 143 143 + ..Default::default() 144 144 + }) 145 145 + })?; 146 146 + let tracks: Result<Vec<_>, _> = tracks.collect(); 147 147 + Ok(HttpResponse::Ok().json(tracks?)) 148 148 + } 149 149 + } 150 150 + } 151 151 + 152 152 + pub async fn get_loved_tracks(payload: &mut web::Payload, _req: &HttpRequest, conn: Arc<Mutex<Connection>>) -> Result<HttpResponse, Error> { 153 153 + let body = read_payload!(payload); 154 154 + let params = serde_json::from_slice::<GetLovedTracksParams>(&body)?; 155 155 + let pagination = params.pagination.unwrap_or_default(); 156 156 + let offset = pagination.skip.unwrap_or(0); 157 157 + let limit = pagination.take.unwrap_or(20); 158 158 + let did = params.user_did; 159 159 + 160 160 + let conn = conn.lock().unwrap(); 161 161 + let mut stmt = conn.prepare(r#" 162 162 + SELECT 163 163 + t.id, 164 164 + t.title, 165 165 + t.artist, 166 166 + t.album, 167 167 + t.album_artist, 168 168 + t.album_art, 169 169 + t.album_uri, 170 170 + t.artist_uri, 171 171 + t.composer, 172 172 + t.copyright_message, 173 173 + t.disc_number, 174 174 + t.duration, 175 175 + t.track_number, 176 176 + t.label, 177 177 + t.spotify_link, 178 178 + t.tidal_link, 179 179 + t.youtube_link, 180 180 + t.apple_music_link, 181 181 + t.sha256, 182 182 + t.uri, 183 183 + u.handle, 184 184 + u.did, 185 185 + l.created_at 186 186 + FROM loved_tracks l 187 187 + LEFT JOIN users u ON l.user_id = u.id 188 188 + LEFT JOIN tracks t ON l.track_id = t.id 189 189 + WHERE u.did = ? 190 190 + ORDER BY l.created_at DESC 191 191 + OFFSET ? 192 192 + LIMIT ?; 193 193 + "#)?; 194 194 + let loved_tracks = stmt.query_map([did, limit.to_string(), offset.to_string()], |row| { 195 195 + Ok(Track { 196 196 + id: row.get(0)?, 197 197 + title: row.get(1)?, 198 198 + artist: row.get(2)?, 199 199 + album: row.get(3)?, 200 200 + album_artist: row.get(4)?, 201 201 + album_art: row.get(5)?, 202 202 + album_uri: row.get(6)?, 203 203 + artist_uri: row.get(7)?, 204 204 + composer: row.get(8)?, 205 205 + copyright_message: row.get(9)?, 206 206 + disc_number: row.get(10)?, 207 207 + duration: row.get(11)?, 208 208 + track_number: row.get(12)?, 209 209 + label: row.get(13)?, 210 210 + spotify_link: row.get(14)?, 211 211 + tidal_link: row.get(15)?, 212 212 + youtube_link: row.get(16)?, 213 213 + apple_music_link: row.get(17)?, 214 214 + sha256: row.get(18)?, 215 215 + uri: row.get(19)?, 216 216 + handle: row.get(20)?, 217 217 + did: row.get(21)?, 218 218 + created_at: row.get(22)?, 219 219 + ..Default::default() 220 220 + }) 221 221 + })?; 222 222 + let loved_tracks: Result<Vec<_>, _> = loved_tracks.collect(); 223 223 + Ok(HttpResponse::Ok().json(loved_tracks?)) 224 224 + } 225 225 + 226 226 + pub async fn get_top_tracks(payload: &mut web::Payload, _req: &HttpRequest, conn: Arc<Mutex<Connection>>) -> Result<HttpResponse, Error> { 227 227 + let body = read_payload!(payload); 228 228 + let params = serde_json::from_slice::<GetTopTracksParams>(&body)?; 229 229 + let pagination = params.pagination.unwrap_or_default(); 230 230 + let offset = pagination.skip.unwrap_or(0); 231 231 + let limit = pagination.take.unwrap_or(20); 232 232 + let did = params.user_did; 233 233 + 234 234 + let conn = conn.lock().unwrap(); 235 235 + match did { 236 236 + Some(did) => { 237 237 + let mut stmt = conn.prepare(r#" 238 238 + SELECT 239 239 + t.id, 240 240 + t.title, 241 241 + t.artist, 242 242 + t.album_artist, 243 243 + t.album, 244 244 + t.uri, 245 245 + t.album_art, 246 246 + t.duration, 247 247 + t.disc_number, 248 248 + t.track_number, 249 249 + t.artist_uri, 250 250 + t.album_uri, 251 251 + t.sha256, 252 252 + t.created_at, 253 253 + COUNT(*) AS play_count, 254 254 + COUNT(DISTINCT s.user_id) AS unique_listeners 255 255 + FROM scrobbles s 256 256 + LEFT JOIN tracks t ON s.track_id = t.id 257 257 + LEFT JOIN artists ar ON s.artist_id = ar.id 258 258 + LEFT JOIN albums a ON s.album_id = a.id 259 259 + LEFT JOIN users u ON s.user_id = u.id 260 260 + WHERE u.did = ? 261 261 + GROUP BY t.id, s.track_id, t.title, ar.name, a.title, t.artist, t.uri, t.album_art, t.duration, t.disc_number, t.track_number, t.artist_uri, t.album_uri, t.created_at, t.sha256, t.album_artist, t.album 262 262 + ORDER BY play_count DESC 263 263 + OFFSET ? 264 264 + LIMIT ?; 265 265 + "#)?; 266 266 + let top_tracks = stmt.query_map([did, limit.to_string(), offset.to_string()], |row| { 267 267 + Ok(Track { 268 268 + id: row.get(0)?, 269 269 + title: row.get(1)?, 270 270 + artist: row.get(2)?, 271 271 + album_artist: row.get(3)?, 272 272 + album: row.get(4)?, 273 273 + uri: row.get(5)?, 274 274 + album_art: row.get(6)?, 275 275 + duration: row.get(7)?, 276 276 + disc_number: row.get(8)?, 277 277 + track_number: row.get(9)?, 278 278 + artist_uri: row.get(10)?, 279 279 + album_uri: row.get(11)?, 280 280 + sha256: row.get(12)?, 281 281 + created_at: row.get(13)?, 282 282 + play_count: row.get(14)?, 283 283 + unique_listeners: row.get(15)?, 284 284 + ..Default::default() 285 285 + }) 286 286 + })?; 287 287 + let top_tracks: Result<Vec<_>, _> = top_tracks.collect(); 288 288 + Ok(HttpResponse::Ok().json(top_tracks?)) 289 289 + }, 290 290 + None => { 291 291 + let mut stmt = conn.prepare(r#" 292 292 + SELECT 293 293 + t.id, 294 294 + t.title, 295 295 + t.artist, 296 296 + t.album_artist, 297 297 + t.album, 298 298 + t.uri, 299 299 + t.album_art, 300 300 + t.duration, 301 301 + t.disc_number, 302 302 + t.track_number, 303 303 + t.artist_uri, 304 304 + t.album_uri, 305 305 + t.sha256, 306 306 + t.created_at, 307 307 + COUNT(*) AS play_count, 308 308 + COUNT(DISTINCT s.user_id) AS unique_listeners 309 309 + FROM scrobbles s 310 310 + LEFT JOIN tracks t ON s.track_id = t.id 311 311 + LEFT JOIN artists ar ON s.artist_id = ar.id 312 312 + LEFT JOIN albums a ON s.album_id = a.id 313 313 + WHERE s.track_id IS NOT NULL AND s.artist_id IS NOT NULL AND s.album_id IS NOT NULL 314 314 + GROUP BY t.id, s.track_id, t.title, ar.name, a.title, t.artist, t.uri, t.album_art, t.duration, t.disc_number, t.track_number, t.artist_uri, t.album_uri, t.created_at, t.sha256, t.album_artist, t.album 315 315 + ORDER BY play_count DESC 316 316 + OFFSET ? 317 317 + LIMIT ?; 318 318 + "#)?; 319 319 + let top_tracks = stmt.query_map([limit, offset], |row| { 320 320 + Ok(Track { 321 321 + id: row.get(0)?, 322 322 + title: row.get(1)?, 323 323 + artist: row.get(2)?, 324 324 + album_artist: row.get(3)?, 325 325 + album: row.get(4)?, 326 326 + uri: row.get(5)?, 327 327 + album_art: row.get(6)?, 328 328 + duration: row.get(7)?, 329 329 + disc_number: row.get(8)?, 330 330 + track_number: row.get(9)?, 331 331 + artist_uri: row.get(10)?, 332 332 + album_uri: row.get(11)?, 333 333 + sha256: row.get(12)?, 334 334 + created_at: row.get(13)?, 335 335 + play_count: row.get(14)?, 336 336 + unique_listeners: row.get(15)?, 337 337 + ..Default::default() 338 338 + }) 339 339 + })?; 340 340 + let top_tracks: Result<Vec<_>, _> = top_tracks.collect(); 341 341 + Ok(HttpResponse::Ok().json(top_tracks?)) 342 342 + } 343 343 + } 344 344 + }

+7 -5

crates/analytics/src/main.rs

··· 1 1 use core::create_tables; 2 2 - use std::env; 2 2 + use std::{env, sync::{Arc, Mutex}}; 3 3 4 4 use clap::Command; 5 5 use cmd::{serve::serve, sync::sync}; ··· 10 10 pub mod types; 11 11 pub mod xata; 12 12 pub mod cmd; 13 13 - pub mod core; 13 13 + pub mod core; 14 14 + pub mod handlers; 14 15 15 16 fn cli() -> Command { 16 17 Command::new("analytics") ··· 37 38 create_tables(&conn).await?; 38 39 39 40 let args = cli().get_matches(); 41 41 + let conn = Arc::new(Mutex::new(conn)); 40 42 41 43 match args.subcommand() { 42 42 - Some(("sync", _)) => sync(&conn, &pool).await?, 43 43 - Some(("serve", _)) => serve(&conn).await?, 44 44 - _ => serve(&conn).await?, 44 44 + Some(("sync", _)) => sync(conn, &pool).await?, 45 45 + Some(("serve", _)) => serve(conn).await?, 46 46 + _ => serve(conn).await?, 45 47 } 46 48 47 49 Ok(())

+25 -12

crates/analytics/src/types/album.rs

··· 1 1 - use actix_web::{body::BoxBody, http::header::ContentType, HttpRequest, HttpResponse, Responder}; 2 1 use serde::{Deserialize, Serialize}; 3 2 4 4 - #[derive(Debug, Serialize, Deserialize)] 3 3 + use super::pagination::Pagination; 4 4 + 5 5 + #[derive(Debug, Serialize, Deserialize, Default)] 5 6 pub struct Album { 6 7 pub id: String, 7 8 pub title: String, 8 9 pub artist: String, 10 10 + #[serde(skip_serializing_if = "Option::is_none")] 9 11 pub release_date: Option<String>, 12 12 + #[serde(skip_serializing_if = "Option::is_none")] 10 13 pub album_art: Option<String>, 14 14 + #[serde(skip_serializing_if = "Option::is_none")] 11 15 pub year: Option<i32>, 16 16 + #[serde(skip_serializing_if = "Option::is_none")] 12 17 pub spotify_link: Option<String>, 18 18 + #[serde(skip_serializing_if = "Option::is_none")] 13 19 pub tidal_link: Option<String>, 20 20 + #[serde(skip_serializing_if = "Option::is_none")] 14 21 pub youtube_link: Option<String>, 22 22 + #[serde(skip_serializing_if = "Option::is_none")] 15 23 pub apple_music_link: Option<String>, 16 24 pub sha256: String, 25 25 + #[serde(skip_serializing_if = "Option::is_none")] 17 26 pub uri: Option<String>, 27 27 + #[serde(skip_serializing_if = "Option::is_none")] 18 28 pub artist_uri: Option<String>, 29 29 + #[serde(skip_serializing_if = "Option::is_none")] 30 30 + pub play_count: Option<i32>, 31 31 + #[serde(skip_serializing_if = "Option::is_none")] 32 32 + pub unique_listeners: Option<i32>, 19 33 } 20 34 21 21 - impl Responder for Album { 22 22 - type Body = BoxBody; 23 23 - 24 24 - fn respond_to(self, _req: &HttpRequest) -> HttpResponse<Self::Body> { 25 25 - let body = serde_json::to_string(&self).unwrap(); 35 35 + #[derive(Debug, Serialize, Deserialize, Default)] 36 36 + pub struct GetAlbumsParams { 37 37 + pub user_did: Option<String>, 38 38 + pub pagination: Option<Pagination>, 39 39 + } 26 40 27 27 - // Create response and set content type 28 28 - HttpResponse::Ok() 29 29 - .content_type(ContentType::json()) 30 30 - .body(body) 31 31 - } 41 41 + #[derive(Debug, Serialize, Deserialize, Default)] 42 42 + pub struct GetTopAlbumsParams { 43 43 + pub user_did: Option<String>, 44 44 + pub pagination: Option<Pagination>, 32 45 }

crates/analytics/src/types/album_track.rs

This is a binary file and will not be displayed.

+25 -12

crates/analytics/src/types/artist.rs

··· 1 1 - use actix_web::{body::BoxBody, http::header::ContentType, HttpRequest, HttpResponse, Responder}; 1 1 + use super::pagination::Pagination; 2 2 use chrono::NaiveDate; 3 3 use serde::{Deserialize, Serialize}; 4 4 5 5 - #[derive(Debug, Serialize, Deserialize)] 5 5 + #[derive(Debug, Serialize, Deserialize, Default)] 6 6 pub struct Artist { 7 7 pub id: String, 8 8 pub name: String, 9 9 + #[serde(skip_serializing_if = "Option::is_none")] 9 10 pub biography: Option<String>, 11 11 + #[serde(skip_serializing_if = "Option::is_none")] 10 12 pub born: Option<NaiveDate>, 13 13 + #[serde(skip_serializing_if = "Option::is_none")] 11 14 pub born_in: Option<String>, 15 15 + #[serde(skip_serializing_if = "Option::is_none")] 12 16 pub died: Option<NaiveDate>, 17 17 + #[serde(skip_serializing_if = "Option::is_none")] 13 18 pub picture: Option<String>, 14 19 pub sha256: String, 20 20 + #[serde(skip_serializing_if = "Option::is_none")] 15 21 pub spotify_link: Option<String>, 22 22 + #[serde(skip_serializing_if = "Option::is_none")] 16 23 pub tidal_link: Option<String>, 24 24 + #[serde(skip_serializing_if = "Option::is_none")] 17 25 pub youtube_link: Option<String>, 26 26 + #[serde(skip_serializing_if = "Option::is_none")] 18 27 pub apple_music_link: Option<String>, 28 28 + #[serde(skip_serializing_if = "Option::is_none")] 19 29 pub uri: Option<String>, 30 30 + #[serde(skip_serializing_if = "Option::is_none")] 31 31 + pub play_count: Option<i32>, 32 32 + #[serde(skip_serializing_if = "Option::is_none")] 33 33 + pub unique_listeners: Option<i32>, 20 34 } 21 35 22 22 - impl Responder for Artist { 23 23 - type Body = BoxBody; 24 24 - 25 25 - fn respond_to(self, _req: &HttpRequest) -> HttpResponse<Self::Body> { 26 26 - let body = serde_json::to_string(&self).unwrap(); 36 36 + #[derive(Debug, Serialize, Deserialize, Default)] 37 37 + pub struct GetArtistsParams { 38 38 + pub user_did: Option<String>, 39 39 + pub pagination: Option<Pagination>, 40 40 + } 27 41 28 28 - // Create response and set content type 29 29 - HttpResponse::Ok() 30 30 - .content_type(ContentType::json()) 31 31 - .body(body) 32 32 - } 42 42 + #[derive(Debug, Serialize, Deserialize, Default)] 43 43 + pub struct GetTopArtistsParams { 44 44 + pub user_did: Option<String>, 45 45 + pub pagination: Option<Pagination>, 33 46 }

crates/analytics/src/types/artist_album.rs

This is a binary file and will not be displayed.

crates/analytics/src/types/artist_track.rs

This is a binary file and will not be displayed.

+8

crates/analytics/src/types/filters.rs

··· 1 1 + use serde::{Deserialize, Serialize}; 2 2 + 3 3 + #[derive(Debug, Clone, Serialize, Deserialize, Default)] 4 4 + pub struct Filters { 5 5 + pub user_did: Option<String>, 6 6 + pub order_by: Option<String>, 7 7 + pub asc: Option<bool>, 8 8 + }

crates/analytics/src/types/loved_track.rs

This is a binary file and will not be displayed.

+3 -6

crates/analytics/src/types/mod.rs

··· 1 1 pub mod album; 2 2 - pub mod album_track; 3 2 pub mod artist; 4 4 - pub mod artist_track; 3 3 + pub mod filters; 4 4 + pub mod pagination; 5 5 pub mod playlist; 6 6 - pub mod playlist_track; 7 6 pub mod scrobble; 7 7 + pub mod stats; 8 8 pub mod track; 9 9 pub mod user; 10 10 - pub mod user_album; 11 11 - pub mod user_artist; 12 12 - pub mod user_playlist;

+16

crates/analytics/src/types/pagination.rs

··· 1 1 + use serde::{Deserialize, Serialize}; 2 2 + 3 3 + #[derive(Debug, Clone, Serialize, Deserialize)] 4 4 + pub struct Pagination { 5 5 + pub skip: Option<u32>, 6 6 + pub take: Option<u32>, 7 7 + } 8 8 + 9 9 + impl Default for Pagination { 10 10 + fn default() -> Self { 11 11 + Pagination { 12 12 + skip: Some(0), 13 13 + take: Some(20), 14 14 + } 15 15 + } 16 16 + }

+2 -15

crates/analytics/src/types/playlist.rs

··· 1 1 - use actix_web::{body::BoxBody, http::header::ContentType, HttpRequest, HttpResponse, Responder}; 2 1 use chrono::NaiveDateTime; 3 2 use serde::{Deserialize, Serialize}; 4 3 5 5 - #[derive(Debug, Serialize, Deserialize)] 4 4 + #[derive(Debug, Serialize, Deserialize, Default)] 6 5 pub struct Playlist { 7 6 pub id: String, 8 7 pub name: String, ··· 12 11 pub updated_at: NaiveDateTime, 13 12 pub uri: Option<String>, 14 13 pub created_by: String, 15 15 - } 16 16 - 17 17 - impl Responder for Playlist { 18 18 - type Body = BoxBody; 19 19 - 20 20 - fn respond_to(self, _req: &HttpRequest) -> HttpResponse<Self::Body> { 21 21 - let body = serde_json::to_string(&self).unwrap(); 22 22 - 23 23 - // Create response and set content type 24 24 - HttpResponse::Ok() 25 25 - .content_type(ContentType::json()) 26 26 - .body(body) 27 27 - } 14 14 + pub listeners: Option<i32>, 28 15 }

crates/analytics/src/types/playlist_track.rs

This is a binary file and will not be displayed.

+45 -2

crates/analytics/src/types/scrobble.rs

··· 1 1 - use chrono::NaiveDateTime; 1 1 + use chrono::{NaiveDate, NaiveDateTime}; 2 2 use serde::{Deserialize, Serialize}; 3 3 4 4 - #[derive(Debug, Serialize, Deserialize)] 4 4 + use super::pagination::Pagination; 5 5 + 6 6 + #[derive(Debug, Serialize, Deserialize, Default)] 5 7 pub struct Scrobble { 6 8 pub id: String, 7 9 pub user_id: String, ··· 11 13 pub uri: Option<String>, 12 14 pub created_at: NaiveDateTime, 13 15 } 16 16 + 17 17 + #[derive(Debug, Serialize, Deserialize, Default)] 18 18 + pub struct ScrobbleTrack { 19 19 + pub id: String, 20 20 + pub track_id: String, 21 21 + pub title: String, 22 22 + pub artist: String, 23 23 + pub album_artist: String, 24 24 + pub album_art: Option<String>, 25 25 + pub album: String, 26 26 + pub handle: String, 27 27 + pub uri: Option<String>, 28 28 + pub track_uri: Option<String>, 29 29 + pub artist_uri: Option<String>, 30 30 + pub album_uri: Option<String>, 31 31 + pub created_at: NaiveDateTime, 32 32 + } 33 33 + 34 34 + #[derive(Debug, Serialize, Deserialize, Default)] 35 35 + pub struct ScrobblesPerDay { 36 36 + pub date: NaiveDate, 37 37 + pub count: i32, 38 38 + } 39 39 + 40 40 + #[derive(Debug, Serialize, Deserialize, Default)] 41 41 + pub struct ScrobblesPerMonth { 42 42 + pub year_month: String, 43 43 + pub count: i32, 44 44 + } 45 45 + 46 46 + #[derive(Debug, Serialize, Deserialize, Default)] 47 47 + pub struct ScrobblesPerYear { 48 48 + pub year: i32, 49 49 + pub count: i32, 50 50 + } 51 51 + 52 52 + #[derive(Debug, Serialize, Deserialize, Default)] 53 53 + pub struct GetScrobblesParams { 54 54 + pub user_did: Option<String>, 55 55 + pub pagination: Option<Pagination>, 56 56 + }

+70

crates/analytics/src/types/stats.rs

··· 1 1 + use super::pagination::Pagination; 2 2 + 3 3 + use chrono::{Datelike, Duration, NaiveDate, Utc}; 4 4 + use serde::{Deserialize, Serialize}; 5 5 + 6 6 + #[derive(Debug, Serialize, Deserialize, Default)] 7 7 + pub struct GetStatsParams { 8 8 + pub user_did: String, 9 9 + pub pagination: Option<Pagination>, 10 10 + } 11 11 + 12 12 + #[derive(Debug, Serialize, Deserialize)] 13 13 + pub struct GetScrobblesPerDayParams { 14 14 + pub user_did: Option<String>, 15 15 + pub start: Option<String>, 16 16 + pub end: Option<String>, 17 17 + } 18 18 + 19 19 + impl Default for GetScrobblesPerDayParams { 20 20 + fn default() -> Self { 21 21 + let current_date = Utc::now().naive_utc(); 22 22 + let date_30_days_ago = current_date - Duration::days(30); 23 23 + 24 24 + GetScrobblesPerDayParams { 25 25 + user_did: None, 26 26 + start: Some(date_30_days_ago.to_string()), 27 27 + end: Some(current_date.to_string()), 28 28 + } 29 29 + } 30 30 + } 31 31 + 32 32 + #[derive(Debug, Serialize, Deserialize)] 33 33 + pub struct GetScrobblesPerMonthParams { 34 34 + pub user_did: Option<String>, 35 35 + pub start: Option<String>, 36 36 + pub end: Option<String>, 37 37 + } 38 38 + 39 39 + impl Default for GetScrobblesPerMonthParams { 40 40 + fn default() -> Self { 41 41 + let current_date = Utc::now().naive_utc(); 42 42 + let january = NaiveDate::from_ymd_opt(current_date.year(), 1, 1).unwrap(); 43 43 + 44 44 + GetScrobblesPerMonthParams { 45 45 + user_did: None, 46 46 + start: Some(january.to_string()), 47 47 + end: Some(current_date.to_string()), 48 48 + } 49 49 + } 50 50 + } 51 51 + 52 52 + #[derive(Debug, Serialize, Deserialize)] 53 53 + pub struct GetScrobblesPerYearParams { 54 54 + pub user_did: Option<String>, 55 55 + pub start: Option<String>, 56 56 + pub end: Option<String>, 57 57 + } 58 58 + 59 59 + impl Default for GetScrobblesPerYearParams { 60 60 + fn default() -> Self { 61 61 + let current_date = Utc::now().naive_utc(); 62 62 + let start = NaiveDate::from_ymd_opt(2025, 1, 1).unwrap(); 63 63 + 64 64 + GetScrobblesPerYearParams { 65 65 + user_did: None, 66 66 + start: Some(start.to_string()), 67 67 + end: Some(current_date.to_string()), 68 68 + } 69 69 + } 70 70 + }

+39 -11

crates/analytics/src/types/track.rs

··· 1 1 - use actix_web::{body::BoxBody, http::header::ContentType, HttpRequest, HttpResponse, Responder}; 1 1 + use super::pagination::Pagination; 2 2 + 2 3 use chrono::NaiveDateTime; 3 4 use serde::{Deserialize, Serialize}; 4 5 5 5 - #[derive(Debug, Serialize, Deserialize)] 6 6 + #[derive(Debug, Serialize, Deserialize, Default)] 6 7 pub struct Track { 7 8 pub id: String, 8 9 pub title: String, 9 10 pub artist: String, 10 11 pub album_artist: String, 12 12 + #[serde(skip_serializing_if = "Option::is_none")] 11 13 pub album_art: Option<String>, 12 14 pub album: String, 13 15 pub track_number: i32, 14 16 pub duration: i32, 17 17 + #[serde(skip_serializing_if = "Option::is_none")] 15 18 pub mb_id: Option<String>, 19 19 + #[serde(skip_serializing_if = "Option::is_none")] 16 20 pub youtube_link: Option<String>, 21 21 + #[serde(skip_serializing_if = "Option::is_none")] 17 22 pub spotify_link: Option<String>, 23 23 + #[serde(skip_serializing_if = "Option::is_none")] 18 24 pub tidal_link: Option<String>, 25 25 + #[serde(skip_serializing_if = "Option::is_none")] 19 26 pub apple_music_link: Option<String>, 20 27 pub sha256: String, 28 28 + #[serde(skip_serializing_if = "Option::is_none")] 21 29 pub lyrics: Option<String>, 30 30 + #[serde(skip_serializing_if = "Option::is_none")] 22 31 pub composer: Option<String>, 32 32 + #[serde(skip_serializing_if = "Option::is_none")] 23 33 pub genre: Option<String>, 24 34 pub disc_number: i32, 35 35 + #[serde(skip_serializing_if = "Option::is_none")] 25 36 pub copyright_message: Option<String>, 37 37 + #[serde(skip_serializing_if = "Option::is_none")] 26 38 pub label: Option<String>, 39 39 + #[serde(skip_serializing_if = "Option::is_none")] 27 40 pub uri: Option<String>, 41 41 + #[serde(skip_serializing_if = "Option::is_none")] 28 42 pub artist_uri: Option<String>, 43 43 + #[serde(skip_serializing_if = "Option::is_none")] 29 44 pub album_uri: Option<String>, 45 45 + #[serde(skip_serializing_if = "Option::is_none")] 46 46 + pub handle: Option<String>, 47 47 + #[serde(skip_serializing_if = "Option::is_none")] 48 48 + pub did: Option<String>, 30 49 pub created_at: NaiveDateTime, 50 50 + #[serde(skip_serializing_if = "Option::is_none")] 51 51 + pub play_count: Option<i32>, 52 52 + #[serde(skip_serializing_if = "Option::is_none")] 53 53 + pub unique_listeners: Option<i32>, 31 54 } 32 55 33 33 - impl Responder for Track { 34 34 - type Body = BoxBody; 56 56 + #[derive(Debug, Serialize, Deserialize, Default)] 57 57 + pub struct GetTracksParams { 58 58 + pub user_did: Option<String>, 59 59 + pub pagination: Option<Pagination>, 60 60 + } 35 61 36 36 - fn respond_to(self, _req: &HttpRequest) -> HttpResponse<Self::Body> { 37 37 - let body = serde_json::to_string(&self).unwrap(); 62 62 + #[derive(Debug, Serialize, Deserialize, Default)] 63 63 + pub struct GetTopTracksParams { 64 64 + pub user_did: Option<String>, 65 65 + pub pagination: Option<Pagination>, 66 66 + } 38 67 39 39 - // Create response and set content type 40 40 - HttpResponse::Ok() 41 41 - .content_type(ContentType::json()) 42 42 - .body(body) 43 43 - } 68 68 + #[derive(Debug, Serialize, Deserialize, Default)] 69 69 + pub struct GetLovedTracksParams { 70 70 + pub user_did: String, 71 71 + pub pagination: Option<Pagination>, 44 72 }

+1 -15

crates/analytics/src/types/user.rs

··· 1 1 - use actix_web::{body::BoxBody, http::header::ContentType, HttpRequest, HttpResponse, Responder}; 2 1 use serde::{Deserialize, Serialize}; 3 2 4 4 - #[derive(Debug, Serialize, Deserialize)] 3 3 + #[derive(Debug, Serialize, Deserialize, Default)] 5 4 pub struct User { 6 5 pub id: String, 7 6 pub display_name: String, ··· 9 8 pub handle: String, 10 9 pub avatar: String, 11 10 } 12 12 - 13 13 - impl Responder for User { 14 14 - type Body = BoxBody; 15 15 - 16 16 - fn respond_to(self, _req: &HttpRequest) -> HttpResponse<Self::Body> { 17 17 - let body = serde_json::to_string(&self).unwrap(); 18 18 - 19 19 - // Create response and set content type 20 20 - HttpResponse::Ok() 21 21 - .content_type(ContentType::json()) 22 22 - .body(body) 23 23 - } 24 24 - }

crates/analytics/src/types/user_album.rs

This is a binary file and will not be displayed.

crates/analytics/src/types/user_artist.rs

This is a binary file and will not be displayed.

crates/analytics/src/types/user_playlist.rs

This is a binary file and will not be displayed.

crates/analytics/src/types/user_track.rs

This is a binary file and will not be displayed.