Compare commits
16 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 ab
|
8073ac9a97 | ||
|
ab
|
ec7c5c9049 | ||
|
ab
|
d1113effa5 | ||
|
ab
|
072c00a48e | ||
|
ab
|
34e25fac2c | ||
|
ab
|
0cb731fb26 | ||
 Ultradesu
|
c43ee02b00 | ||
|
Ultradesu
|
fc6090d6a0 | ||
|
Ultradesu
|
476b300a6c | ||
|
Ultradesu
|
59910bc34e | ||
|
Ultradesu
|
5600a8065d | ||
|
Ultradesu
|
015d75c701 | ||
|
Ultradesu
|
1c70349df8 | ||
|
Ultradesu
|
65da460c0c | ||
|
Ultradesu
|
538a6f6abf | ||
|
ab
|
04c30bc4b8 |
Generated
+118
-1
@@ -501,6 +501,12 @@ version = "1.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
|
||||
|
||||
[[package]]
|
||||
name = "byteorder-lite"
|
||||
version = "0.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
|
||||
|
||||
[[package]]
|
||||
name = "bytes"
|
||||
version = "1.11.1"
|
||||
@@ -599,6 +605,12 @@ version = "0.1.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b9e769b5c8c8283982a987c6e948e540254f1058d5a74b8794914d4ef5fc2a24"
|
||||
|
||||
[[package]]
|
||||
name = "color_quant"
|
||||
version = "1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
|
||||
|
||||
[[package]]
|
||||
name = "colorchoice"
|
||||
version = "1.0.5"
|
||||
@@ -1304,6 +1316,15 @@ version = "2.4.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
|
||||
|
||||
[[package]]
|
||||
name = "fdeflate"
|
||||
version = "0.3.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
|
||||
dependencies = [
|
||||
"simd-adler32",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ff"
|
||||
version = "0.13.1"
|
||||
@@ -1397,7 +1418,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
|
||||
|
||||
[[package]]
|
||||
name = "furumusic"
|
||||
version = "0.1.15"
|
||||
version = "0.2.4"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"async-trait",
|
||||
@@ -1407,7 +1428,9 @@ dependencies = [
|
||||
"croner",
|
||||
"encoding_rs",
|
||||
"id3",
|
||||
"image",
|
||||
"librqbit",
|
||||
"md-5",
|
||||
"openidconnect",
|
||||
"reqwest",
|
||||
"schemars 0.9.0",
|
||||
@@ -1588,6 +1611,16 @@ dependencies = [
|
||||
"wasip3",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "gif"
|
||||
version = "0.14.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ee8cfcc411d9adbbaba82fb72661cc1bcca13e8bba98b364e62b2dba8f960159"
|
||||
dependencies = [
|
||||
"color_quant",
|
||||
"weezl",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "gimli"
|
||||
version = "0.32.3"
|
||||
@@ -2026,6 +2059,34 @@ dependencies = [
|
||||
"icu_properties",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "image"
|
||||
version = "0.25.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
|
||||
dependencies = [
|
||||
"bytemuck",
|
||||
"byteorder-lite",
|
||||
"color_quant",
|
||||
"gif",
|
||||
"image-webp",
|
||||
"moxcms",
|
||||
"num-traits",
|
||||
"png",
|
||||
"zune-core",
|
||||
"zune-jpeg",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "image-webp"
|
||||
version = "0.2.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3"
|
||||
dependencies = [
|
||||
"byteorder-lite",
|
||||
"quick-error",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "indexmap"
|
||||
version = "1.9.3"
|
||||
@@ -2522,6 +2583,16 @@ dependencies = [
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "moxcms"
|
||||
version = "0.8.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"
|
||||
dependencies = [
|
||||
"num-traits",
|
||||
"pxfm",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "multer"
|
||||
version = "3.1.0"
|
||||
@@ -3000,6 +3071,19 @@ version = "0.2.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
|
||||
|
||||
[[package]]
|
||||
name = "png"
|
||||
version = "0.18.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
|
||||
dependencies = [
|
||||
"bitflags 2.11.1",
|
||||
"crc32fast",
|
||||
"fdeflate",
|
||||
"flate2",
|
||||
"miniz_oxide",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "portable-atomic"
|
||||
version = "1.13.1"
|
||||
@@ -3067,6 +3151,12 @@ dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "pxfm"
|
||||
version = "0.1.29"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e0c5ccf5294c6ccd63a74f1565028353830a9c2f5eb0c682c355c471726a6e3f"
|
||||
|
||||
[[package]]
|
||||
name = "quanta"
|
||||
version = "0.12.6"
|
||||
@@ -3082,6 +3172,12 @@ dependencies = [
|
||||
"winapi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quick-error"
|
||||
version = "2.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
|
||||
|
||||
[[package]]
|
||||
name = "quick-xml"
|
||||
version = "0.37.5"
|
||||
@@ -5142,6 +5238,12 @@ dependencies = [
|
||||
"rustls-pki-types",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "weezl"
|
||||
version = "0.1.12"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
|
||||
|
||||
[[package]]
|
||||
name = "whoami"
|
||||
version = "1.6.1"
|
||||
@@ -5690,3 +5792,18 @@ name = "zmij"
|
||||
version = "1.0.21"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
|
||||
|
||||
[[package]]
|
||||
name = "zune-core"
|
||||
version = "0.5.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cb8a0807f7c01457d0379ba880ba6322660448ddebc890ce29bb64da71fb40f9"
|
||||
|
||||
[[package]]
|
||||
name = "zune-jpeg"
|
||||
version = "0.5.15"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296"
|
||||
dependencies = [
|
||||
"zune-core",
|
||||
]
|
||||
|
||||
+3
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "furumusic"
|
||||
version = "0.1.16"
|
||||
version = "0.2.5"
|
||||
edition = "2024"
|
||||
description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
|
||||
|
||||
@@ -20,6 +20,8 @@ symphonia = { version = "0.5", default-features = false, features = ["mp3","aac"
|
||||
id3 = "1"
|
||||
encoding_rs = "0.8"
|
||||
sha2 = "0.10"
|
||||
md-5 = "0.10"
|
||||
image = { version = "0.25", default-features = false, features = ["jpeg", "png", "webp", "gif", "bmp"] }
|
||||
sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "postgres"] }
|
||||
anyhow = "1.0"
|
||||
tokio-cron-scheduler = "0.15"
|
||||
|
||||
+116
-4
@@ -20,8 +20,8 @@ use crate::i18n::I18n;
|
||||
use crate::scheduler::{JobRegistry, SchedulerHandle};
|
||||
use crate::user::User;
|
||||
use views::{
|
||||
ArtistForm, CronForm, MetadataBackfillForm, OidcSettingsForm, ReleaseForm, ReviewsBulkForm,
|
||||
SetImageBody, SetupForm, UploadImageBody, UserForm,
|
||||
ArtistForm, CronForm, MetadataBackfillForm, OidcSettingsForm, ReleaseForm, ReviewApproveForm,
|
||||
ReviewsBulkForm, SetImageBody, SetupForm, UploadImageBody, UserForm,
|
||||
};
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
@@ -227,6 +227,35 @@ impl App for AdminApp {
|
||||
},
|
||||
"admin_v2_reviews_bulk",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/v2/api/reviews/{id}/approve",
|
||||
{
|
||||
let pool = Arc::clone(&pool);
|
||||
let pool_config = Arc::clone(&pool_config);
|
||||
cot::router::method::post(
|
||||
move |session: Session,
|
||||
db: Database,
|
||||
path: Path<PathId>,
|
||||
json: Json<v2::ReviewEditDto>| {
|
||||
let pool = Arc::clone(&pool);
|
||||
let pool_config = Arc::clone(&pool_config);
|
||||
async move {
|
||||
let pg_pool = pool
|
||||
.get_or_init(|| async {
|
||||
sqlx::postgres::PgPoolOptions::new()
|
||||
.max_connections(5)
|
||||
.connect(&pool_config.database_url)
|
||||
.await
|
||||
.expect("admin pool")
|
||||
})
|
||||
.await;
|
||||
v2::approve_review(session, db, pg_pool, path.0.id, json).await
|
||||
}
|
||||
},
|
||||
)
|
||||
},
|
||||
"admin_v2_review_approve",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/v2/api/jobs",
|
||||
{
|
||||
@@ -399,6 +428,88 @@ impl App for AdminApp {
|
||||
},
|
||||
"admin_v2_library_item",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/v2/api/library/item/detail",
|
||||
{
|
||||
let pool = Arc::clone(&pool);
|
||||
let pool_config = Arc::clone(&pool_config);
|
||||
get(move |session: Session,
|
||||
db: Database,
|
||||
query: UrlQuery<v2::LibraryItemDetailQuery>| {
|
||||
let pool = Arc::clone(&pool);
|
||||
let pool_config = Arc::clone(&pool_config);
|
||||
async move {
|
||||
let pg_pool = pool
|
||||
.get_or_init(|| async {
|
||||
sqlx::postgres::PgPoolOptions::new()
|
||||
.max_connections(5)
|
||||
.connect(&pool_config.database_url)
|
||||
.await
|
||||
.expect("admin pool")
|
||||
})
|
||||
.await;
|
||||
v2::library_item_detail(session, db, pg_pool, query.0).await
|
||||
}
|
||||
})
|
||||
},
|
||||
"admin_v2_library_item_detail",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/v2/api/library/item/image",
|
||||
{
|
||||
let pool = Arc::clone(&pool);
|
||||
let pool_config = Arc::clone(&pool_config);
|
||||
cot::router::method::post(
|
||||
move |session: Session,
|
||||
db: Database,
|
||||
json: Json<v2::SetLibraryImageRequest>| {
|
||||
let pool = Arc::clone(&pool);
|
||||
let pool_config = Arc::clone(&pool_config);
|
||||
async move {
|
||||
let pg_pool = pool
|
||||
.get_or_init(|| async {
|
||||
sqlx::postgres::PgPoolOptions::new()
|
||||
.max_connections(5)
|
||||
.connect(&pool_config.database_url)
|
||||
.await
|
||||
.expect("admin pool")
|
||||
})
|
||||
.await;
|
||||
v2::set_library_item_image(session, db, pg_pool, json).await
|
||||
}
|
||||
},
|
||||
)
|
||||
},
|
||||
"admin_v2_library_item_image",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/v2/api/library/item/upload-image",
|
||||
{
|
||||
let pool = Arc::clone(&pool);
|
||||
let pool_config = Arc::clone(&pool_config);
|
||||
cot::router::method::post(
|
||||
move |session: Session,
|
||||
db: Database,
|
||||
json: Json<v2::UploadLibraryImageRequest>| {
|
||||
let pool = Arc::clone(&pool);
|
||||
let pool_config = Arc::clone(&pool_config);
|
||||
async move {
|
||||
let pg_pool = pool
|
||||
.get_or_init(|| async {
|
||||
sqlx::postgres::PgPoolOptions::new()
|
||||
.max_connections(5)
|
||||
.connect(&pool_config.database_url)
|
||||
.await
|
||||
.expect("admin pool")
|
||||
})
|
||||
.await;
|
||||
v2::upload_library_item_image(session, db, pg_pool, json).await
|
||||
}
|
||||
},
|
||||
)
|
||||
},
|
||||
"admin_v2_library_item_upload_image",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/v2/api/library/bulk",
|
||||
{
|
||||
@@ -1048,7 +1159,8 @@ impl App for AdminApp {
|
||||
let config = Arc::clone(&self.config);
|
||||
let pool = Arc::clone(&pool);
|
||||
let pool_config = Arc::clone(&pool_config);
|
||||
move |session: Session, db: Database, path: Path<PathId>| {
|
||||
move |session: Session, db: Database, path: Path<PathId>,
|
||||
form: RequestForm<ReviewApproveForm>| {
|
||||
let config = Arc::clone(&config);
|
||||
let pool = Arc::clone(&pool);
|
||||
let pool_config = Arc::clone(&pool_config);
|
||||
@@ -1064,7 +1176,7 @@ impl App for AdminApp {
|
||||
.await
|
||||
.expect("admin pool")
|
||||
}).await;
|
||||
views::review_approve(admin, &config, &db, pg_pool, path.0.id).await
|
||||
views::review_approve(admin, &config, &db, pg_pool, path.0.id, form).await
|
||||
}
|
||||
}
|
||||
}),
|
||||
|
||||
+484
-3
@@ -1,4 +1,4 @@
|
||||
use std::collections::HashMap;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
use cot::db::{Database, Model};
|
||||
use cot::html::Html;
|
||||
@@ -67,6 +67,31 @@ pub(super) struct UpdateLibraryItemRequest {
|
||||
id: i64,
|
||||
title: String,
|
||||
hidden: bool,
|
||||
release_type: Option<String>,
|
||||
year: Option<String>,
|
||||
artist_ids: Option<Vec<i64>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub(super) struct LibraryItemDetailQuery {
|
||||
kind: String,
|
||||
id: i64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub(super) struct SetLibraryImageRequest {
|
||||
kind: String,
|
||||
id: i64,
|
||||
media_file_id: Option<i64>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub(super) struct UploadLibraryImageRequest {
|
||||
kind: String,
|
||||
id: i64,
|
||||
data: String,
|
||||
filename: String,
|
||||
mime_type: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Deserialize, Serialize, JsonSchema)]
|
||||
@@ -156,10 +181,24 @@ struct ReviewDto {
|
||||
token_count: Option<i64>,
|
||||
tags: Vec<TagDto>,
|
||||
error_message: Option<String>,
|
||||
normalized: ReviewEditDto,
|
||||
created_at: String,
|
||||
updated_at: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
|
||||
pub(super) struct ReviewEditDto {
|
||||
title: String,
|
||||
artist: String,
|
||||
album: String,
|
||||
year: String,
|
||||
track_number: String,
|
||||
genre: String,
|
||||
featured_artists: String,
|
||||
release_type: String,
|
||||
notes: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
struct JobDto {
|
||||
name: String,
|
||||
@@ -221,6 +260,8 @@ struct AdminSettingsDto {
|
||||
values: AdminSettingsValues,
|
||||
sources: AdminSettingsSources,
|
||||
lastfm_api_key_configured: bool,
|
||||
lastfm_shared_secret_configured: bool,
|
||||
lastfm_scrobbling_configured: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
|
||||
@@ -235,6 +276,7 @@ struct AdminSettingsValues {
|
||||
oidc_user_groups: String,
|
||||
swagger_enabled: bool,
|
||||
lastfm_api_key: String,
|
||||
lastfm_shared_secret: String,
|
||||
agent_enabled: bool,
|
||||
agent_inbox_dir: String,
|
||||
agent_storage_dir: String,
|
||||
@@ -258,6 +300,7 @@ struct AdminSettingsSources {
|
||||
oidc_user_groups: &'static str,
|
||||
swagger_enabled: &'static str,
|
||||
lastfm_api_key: &'static str,
|
||||
lastfm_shared_secret: &'static str,
|
||||
agent_enabled: &'static str,
|
||||
agent_inbox_dir: &'static str,
|
||||
agent_storage_dir: &'static str,
|
||||
@@ -281,6 +324,7 @@ pub(super) struct UpdateSettingsRequest {
|
||||
oidc_user_groups: String,
|
||||
swagger_enabled: bool,
|
||||
lastfm_api_key: String,
|
||||
lastfm_shared_secret: String,
|
||||
agent_enabled: bool,
|
||||
agent_inbox_dir: String,
|
||||
agent_storage_dir: String,
|
||||
@@ -334,6 +378,32 @@ struct LibraryItemDto {
|
||||
updated_at: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
struct LibraryItemDetailDto {
|
||||
item: LibraryItemDto,
|
||||
title: String,
|
||||
hidden: bool,
|
||||
release_type: Option<String>,
|
||||
year: Option<i32>,
|
||||
current_image_url: Option<String>,
|
||||
selected_artist_ids: Vec<i64>,
|
||||
artists: Vec<ArtistOptionDto>,
|
||||
available_covers: Vec<AvailableCoverDto>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
struct ArtistOptionDto {
|
||||
id: i64,
|
||||
name: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
struct AvailableCoverDto {
|
||||
media_file_id: i64,
|
||||
release_title: String,
|
||||
cover_url: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, sqlx::FromRow)]
|
||||
struct IdRow {
|
||||
id: i64,
|
||||
@@ -533,6 +603,65 @@ pub async fn bulk_reviews(
|
||||
Json(BulkReviewsResponse { ok: true, affected }).into_response()
|
||||
}
|
||||
|
||||
pub async fn approve_review(
|
||||
session: Session,
|
||||
db: Database,
|
||||
pool: &PgPool,
|
||||
review_id: i64,
|
||||
Json(body): Json<ReviewEditDto>,
|
||||
) -> cot::Result<cot::response::Response> {
|
||||
if let Err(response) = require_admin_json(&session, &db).await {
|
||||
return Ok(response);
|
||||
}
|
||||
|
||||
let mut review = crate::scheduler::PendingReview::get_by_id(&db, review_id)
|
||||
.await
|
||||
.map_err(|e| cot::Error::internal(e.to_string()))?
|
||||
.ok_or_else(|| cot::Error::internal("review not found"))?;
|
||||
let normalized = normalized_from_review_edit(&body);
|
||||
let result_json = serde_json::to_string(&normalized)
|
||||
.map_err(|e| cot::Error::internal(format!("failed to serialize review fields: {e}")))?;
|
||||
review
|
||||
.set_result_json(&db, result_json)
|
||||
.await
|
||||
.map_err(|e| cot::Error::internal(e.to_string()))?;
|
||||
|
||||
let context: serde_json::Value =
|
||||
serde_json::from_str(review.context_json_str()).unwrap_or_default();
|
||||
let input_path = review.input_path_str().to_owned();
|
||||
let (live_config, _) = AppConfig::load_with_db(&db).await;
|
||||
let stats = crate::scheduler::ProcessingStats::get_by_review_id(&db, review_id)
|
||||
.await
|
||||
.unwrap_or(None);
|
||||
let model_name = stats.as_ref().map(|s| s.model_name.to_string());
|
||||
|
||||
match crate::jobs::inbox_process::finalize_approved(
|
||||
&db,
|
||||
pool,
|
||||
&live_config,
|
||||
&input_path,
|
||||
&normalized,
|
||||
&context,
|
||||
&live_config.agent_storage_dir,
|
||||
model_name.as_deref(),
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(()) => {
|
||||
let _ = review.set_approved(&db).await;
|
||||
Json(serde_json::json!({ "ok": true })).into_response()
|
||||
}
|
||||
Err(error) => {
|
||||
tracing::error!(?error, "review approval failed");
|
||||
let _ = review.set_rejected(&db).await;
|
||||
Ok(json_error(
|
||||
StatusCode::INTERNAL_SERVER_ERROR,
|
||||
"review approval failed",
|
||||
))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn jobs(
|
||||
session: Session,
|
||||
db: Database,
|
||||
@@ -585,6 +714,10 @@ pub async fn update_settings(
|
||||
("oidc_user_groups", body.oidc_user_groups.trim().to_string()),
|
||||
("swagger_enabled", body.swagger_enabled.to_string()),
|
||||
("lastfm_api_key", body.lastfm_api_key.trim().to_string()),
|
||||
(
|
||||
"lastfm_shared_secret",
|
||||
body.lastfm_shared_secret.trim().to_string(),
|
||||
),
|
||||
("agent_enabled", body.agent_enabled.to_string()),
|
||||
("agent_inbox_dir", body.agent_inbox_dir.trim().to_string()),
|
||||
(
|
||||
@@ -661,6 +794,9 @@ pub async fn settings_probe(
|
||||
fn settings_dto(config: AppConfig, sources: ConfigSources) -> AdminSettingsDto {
|
||||
AdminSettingsDto {
|
||||
lastfm_api_key_configured: !config.lastfm_api_key.trim().is_empty(),
|
||||
lastfm_shared_secret_configured: !config.lastfm_shared_secret.trim().is_empty(),
|
||||
lastfm_scrobbling_configured: !config.lastfm_api_key.trim().is_empty()
|
||||
&& !config.lastfm_shared_secret.trim().is_empty(),
|
||||
values: AdminSettingsValues {
|
||||
auth_password_enabled: config.auth_password_enabled,
|
||||
auth_sso_enabled: config.auth_sso_enabled,
|
||||
@@ -672,6 +808,7 @@ fn settings_dto(config: AppConfig, sources: ConfigSources) -> AdminSettingsDto {
|
||||
oidc_user_groups: config.oidc_user_groups,
|
||||
swagger_enabled: config.swagger_enabled,
|
||||
lastfm_api_key: config.lastfm_api_key,
|
||||
lastfm_shared_secret: config.lastfm_shared_secret,
|
||||
agent_enabled: config.agent_enabled,
|
||||
agent_inbox_dir: config.agent_inbox_dir,
|
||||
agent_storage_dir: config.agent_storage_dir,
|
||||
@@ -693,6 +830,7 @@ fn settings_dto(config: AppConfig, sources: ConfigSources) -> AdminSettingsDto {
|
||||
oidc_user_groups: sources.oidc_user_groups.code(),
|
||||
swagger_enabled: sources.swagger_enabled.code(),
|
||||
lastfm_api_key: sources.lastfm_api_key.code(),
|
||||
lastfm_shared_secret: sources.lastfm_shared_secret.code(),
|
||||
agent_enabled: sources.agent_enabled.code(),
|
||||
agent_inbox_dir: sources.agent_inbox_dir.code(),
|
||||
agent_storage_dir: sources.agent_storage_dir.code(),
|
||||
@@ -830,6 +968,28 @@ pub async fn library(
|
||||
Json(page).into_response()
|
||||
}
|
||||
|
||||
pub async fn library_item_detail(
|
||||
session: Session,
|
||||
db: Database,
|
||||
pool: &PgPool,
|
||||
query: LibraryItemDetailQuery,
|
||||
) -> cot::Result<cot::response::Response> {
|
||||
if let Err(response) = require_admin_json(&session, &db).await {
|
||||
return Ok(response);
|
||||
}
|
||||
let kind = normalize_library_kind(Some(query.kind.as_str()));
|
||||
let Some(item) = fetch_library_item(pool, &kind, query.id)
|
||||
.await
|
||||
.map_err(|e| cot::Error::internal(e.to_string()))?
|
||||
else {
|
||||
return Ok(json_error(StatusCode::NOT_FOUND, "library item not found"));
|
||||
};
|
||||
let detail = load_library_item_detail(pool, &kind, item)
|
||||
.await
|
||||
.map_err(|e| cot::Error::internal(e.to_string()))?;
|
||||
Json(detail).into_response()
|
||||
}
|
||||
|
||||
pub async fn update_library_item(
|
||||
session: Session,
|
||||
db: Database,
|
||||
@@ -863,13 +1023,27 @@ pub async fn update_library_item(
|
||||
.await
|
||||
}
|
||||
"releases" => {
|
||||
let release_type = body
|
||||
.release_type
|
||||
.as_deref()
|
||||
.map(str::trim)
|
||||
.filter(|value| !value.is_empty())
|
||||
.unwrap_or("album");
|
||||
let year = body
|
||||
.year
|
||||
.as_deref()
|
||||
.map(str::trim)
|
||||
.filter(|value| !value.is_empty())
|
||||
.and_then(|value| value.parse::<i32>().ok());
|
||||
sqlx::query(
|
||||
"UPDATE furumusic__release \
|
||||
SET title = $1, title_sort = $2, is_hidden = $3, updated_at = $4 \
|
||||
WHERE id = $5",
|
||||
SET title = $1, title_sort = $2, release_type = $3, year = $4, is_hidden = $5, updated_at = $6 \
|
||||
WHERE id = $7",
|
||||
)
|
||||
.bind(title)
|
||||
.bind(normalize_name(title))
|
||||
.bind(release_type)
|
||||
.bind(year)
|
||||
.bind(body.hidden)
|
||||
.bind(&now)
|
||||
.bind(body.id)
|
||||
@@ -897,6 +1071,28 @@ pub async fn update_library_item(
|
||||
if affected == 0 {
|
||||
return Ok(json_error(StatusCode::NOT_FOUND, "library item not found"));
|
||||
}
|
||||
if kind == "releases" {
|
||||
if let Some(mut artist_ids) = body.artist_ids {
|
||||
let mut seen_artist_ids = HashSet::new();
|
||||
artist_ids.retain(|id| *id > 0 && seen_artist_ids.insert(*id));
|
||||
sqlx::query("DELETE FROM furumusic__release_artist WHERE release_id = $1")
|
||||
.bind(body.id)
|
||||
.execute(pool)
|
||||
.await
|
||||
.map_err(|e| cot::Error::internal(e.to_string()))?;
|
||||
for (position, artist_id) in artist_ids.iter().enumerate() {
|
||||
sqlx::query(
|
||||
"INSERT INTO furumusic__release_artist (release_id, artist_id, position) VALUES ($1, $2, $3)",
|
||||
)
|
||||
.bind(body.id)
|
||||
.bind(*artist_id)
|
||||
.bind(position as i32)
|
||||
.execute(pool)
|
||||
.await
|
||||
.map_err(|e| cot::Error::internal(e.to_string()))?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let Some(item) = fetch_library_item(pool, &kind, body.id)
|
||||
.await
|
||||
@@ -908,6 +1104,128 @@ pub async fn update_library_item(
|
||||
Json(item).into_response()
|
||||
}
|
||||
|
||||
pub async fn set_library_item_image(
|
||||
session: Session,
|
||||
db: Database,
|
||||
pool: &PgPool,
|
||||
Json(body): Json<SetLibraryImageRequest>,
|
||||
) -> cot::Result<cot::response::Response> {
|
||||
if let Err(response) = require_admin_json(&session, &db).await {
|
||||
return Ok(response);
|
||||
}
|
||||
let kind = normalize_library_kind(Some(body.kind.as_str()));
|
||||
if kind != "artists" && kind != "releases" {
|
||||
return Ok(json_error(StatusCode::BAD_REQUEST, "unsupported kind"));
|
||||
}
|
||||
if let Some(fid) = body.media_file_id {
|
||||
let exists: Option<i64> = sqlx::query_scalar(
|
||||
"SELECT id FROM furumusic__media_file WHERE id = $1 AND file_type = 'cover_art'",
|
||||
)
|
||||
.bind(fid)
|
||||
.fetch_optional(pool)
|
||||
.await
|
||||
.map_err(|e| cot::Error::internal(e.to_string()))?;
|
||||
if exists.is_none() {
|
||||
return Ok(json_error(StatusCode::NOT_FOUND, "image not found"));
|
||||
}
|
||||
}
|
||||
let now = now_string();
|
||||
let result = if kind == "releases" {
|
||||
sqlx::query(
|
||||
"UPDATE furumusic__release SET cover_file_id = $1, updated_at = $2 WHERE id = $3",
|
||||
)
|
||||
.bind(body.media_file_id)
|
||||
.bind(&now)
|
||||
.bind(body.id)
|
||||
.execute(pool)
|
||||
.await
|
||||
} else {
|
||||
sqlx::query(
|
||||
"UPDATE furumusic__artist SET image_file_id = $1, updated_at = $2 WHERE id = $3",
|
||||
)
|
||||
.bind(body.media_file_id)
|
||||
.bind(&now)
|
||||
.bind(body.id)
|
||||
.execute(pool)
|
||||
.await
|
||||
}
|
||||
.map_err(|e| cot::Error::internal(e.to_string()))?;
|
||||
if result.rows_affected() == 0 {
|
||||
return Ok(json_error(StatusCode::NOT_FOUND, "library item not found"));
|
||||
}
|
||||
Json(serde_json::json!({ "ok": true })).into_response()
|
||||
}
|
||||
|
||||
pub async fn upload_library_item_image(
|
||||
session: Session,
|
||||
db: Database,
|
||||
pool: &PgPool,
|
||||
Json(body): Json<UploadLibraryImageRequest>,
|
||||
) -> cot::Result<cot::response::Response> {
|
||||
if let Err(response) = require_admin_json(&session, &db).await {
|
||||
return Ok(response);
|
||||
}
|
||||
let kind = normalize_library_kind(Some(body.kind.as_str()));
|
||||
if kind != "artists" && kind != "releases" {
|
||||
return Ok(json_error(StatusCode::BAD_REQUEST, "unsupported kind"));
|
||||
}
|
||||
let storage_dir = AppConfig::load_with_db(&db).await.0.agent_storage_dir;
|
||||
if storage_dir.trim().is_empty() {
|
||||
return Err(cot::Error::internal("agent_storage_dir is not configured"));
|
||||
}
|
||||
use base64::Engine;
|
||||
let image_data = base64::engine::general_purpose::STANDARD
|
||||
.decode(body.data.trim())
|
||||
.map_err(|e| cot::Error::internal(format!("invalid base64: {e}")))?;
|
||||
if image_data.is_empty() {
|
||||
return Ok(json_error(StatusCode::BAD_REQUEST, "image is empty"));
|
||||
}
|
||||
let title: Option<String> = if kind == "releases" {
|
||||
sqlx::query_scalar("SELECT title::text FROM furumusic__release WHERE id = $1")
|
||||
} else {
|
||||
sqlx::query_scalar("SELECT name::text FROM furumusic__artist WHERE id = $1")
|
||||
}
|
||||
.bind(body.id)
|
||||
.fetch_optional(pool)
|
||||
.await
|
||||
.map_err(|e| cot::Error::internal(e.to_string()))?;
|
||||
let Some(title) = title else {
|
||||
return Ok(json_error(StatusCode::NOT_FOUND, "library item not found"));
|
||||
};
|
||||
let cover = crate::agent::cover_art::CoverImage {
|
||||
data: image_data,
|
||||
mime_type: body.mime_type,
|
||||
source: crate::agent::cover_art::CoverSource::FolderFile(std::path::PathBuf::from(
|
||||
body.filename,
|
||||
)),
|
||||
};
|
||||
let media_file_id = crate::agent::cover_art::save_cover_to_storage(
|
||||
&db,
|
||||
pool,
|
||||
&storage_dir,
|
||||
&title,
|
||||
if kind == "artists" {
|
||||
"__artist_image__"
|
||||
} else {
|
||||
"__release_cover__"
|
||||
},
|
||||
&cover,
|
||||
)
|
||||
.await
|
||||
.map_err(|e| cot::Error::internal(format!("failed to save image: {e}")))?;
|
||||
set_library_item_image(
|
||||
session,
|
||||
db,
|
||||
pool,
|
||||
Json(SetLibraryImageRequest {
|
||||
kind,
|
||||
id: body.id,
|
||||
media_file_id: Some(media_file_id),
|
||||
}),
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
pub async fn bulk_library(
|
||||
session: Session,
|
||||
db: Database,
|
||||
@@ -1209,6 +1527,11 @@ fn review_dto(
|
||||
.as_deref()
|
||||
.and_then(|json| serde_json::from_str::<serde_json::Value>(json).ok())
|
||||
.and_then(|value| value.get("confidence").and_then(|v| v.as_f64()));
|
||||
let normalized = row
|
||||
.result_json
|
||||
.as_deref()
|
||||
.map(review_edit_dto_from_json)
|
||||
.unwrap_or_default();
|
||||
|
||||
ReviewDto {
|
||||
id: row.id,
|
||||
@@ -1224,11 +1547,72 @@ fn review_dto(
|
||||
token_count: stat.map(|s| s.prompt_tokens + s.completion_tokens),
|
||||
tags,
|
||||
error_message: row.error_message,
|
||||
normalized,
|
||||
created_at: row.created_at,
|
||||
updated_at: row.updated_at,
|
||||
}
|
||||
}
|
||||
|
||||
fn review_edit_dto_from_json(result_json: &str) -> ReviewEditDto {
|
||||
let Ok(normalized) = serde_json::from_str::<crate::agent::dto::NormalizedFields>(result_json)
|
||||
else {
|
||||
return ReviewEditDto::default();
|
||||
};
|
||||
ReviewEditDto {
|
||||
title: normalized.title.unwrap_or_default(),
|
||||
artist: normalized.artist.unwrap_or_default(),
|
||||
album: normalized.album.unwrap_or_default(),
|
||||
year: normalized.year.map(|v| v.to_string()).unwrap_or_default(),
|
||||
track_number: normalized
|
||||
.track_number
|
||||
.map(|v| v.to_string())
|
||||
.unwrap_or_default(),
|
||||
genre: normalized.genre.unwrap_or_default(),
|
||||
featured_artists: normalized.featured_artists.join(", "),
|
||||
release_type: normalized
|
||||
.release_type
|
||||
.unwrap_or_else(|| "album".to_owned()),
|
||||
notes: normalized.notes.unwrap_or_default(),
|
||||
}
|
||||
}
|
||||
|
||||
fn optional_trimmed(value: &str) -> Option<String> {
|
||||
let trimmed = value.trim();
|
||||
if trimmed.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(trimmed.to_owned())
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_optional_i32(value: &str) -> Option<i32> {
|
||||
value.trim().parse::<i32>().ok()
|
||||
}
|
||||
|
||||
fn parse_featured_artists(value: &str) -> Vec<String> {
|
||||
value
|
||||
.split(',')
|
||||
.map(str::trim)
|
||||
.filter(|part| !part.is_empty())
|
||||
.map(str::to_owned)
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn normalized_from_review_edit(edit: &ReviewEditDto) -> crate::agent::dto::NormalizedFields {
|
||||
crate::agent::dto::NormalizedFields {
|
||||
title: optional_trimmed(&edit.title),
|
||||
artist: optional_trimmed(&edit.artist),
|
||||
album: optional_trimmed(&edit.album),
|
||||
year: parse_optional_i32(&edit.year),
|
||||
track_number: parse_optional_i32(&edit.track_number),
|
||||
genre: optional_trimmed(&edit.genre),
|
||||
featured_artists: parse_featured_artists(&edit.featured_artists),
|
||||
release_type: optional_trimmed(&edit.release_type).or_else(|| Some("album".to_owned())),
|
||||
confidence: Some(1.0),
|
||||
notes: optional_trimmed(&edit.notes),
|
||||
}
|
||||
}
|
||||
|
||||
fn media_tags(row: &ReviewMediaRow) -> Vec<TagDto> {
|
||||
let mut tags = Vec::new();
|
||||
if let Some(format) = row.audio_format.as_deref().filter(|s| !s.trim().is_empty()) {
|
||||
@@ -1480,6 +1864,103 @@ async fn fetch_library_item(
|
||||
Ok(row.map(|row| library_item_dto(kind, row)))
|
||||
}
|
||||
|
||||
async fn load_library_item_detail(
|
||||
pool: &PgPool,
|
||||
kind: &str,
|
||||
item: LibraryItemDto,
|
||||
) -> anyhow::Result<LibraryItemDetailDto> {
|
||||
let mut detail = LibraryItemDetailDto {
|
||||
title: item.title.clone(),
|
||||
hidden: item.is_hidden.unwrap_or(false),
|
||||
release_type: None,
|
||||
year: None,
|
||||
current_image_url: None,
|
||||
selected_artist_ids: Vec::new(),
|
||||
artists: Vec::new(),
|
||||
available_covers: Vec::new(),
|
||||
item,
|
||||
};
|
||||
|
||||
match kind {
|
||||
"artists" => {
|
||||
let image_file_id: Option<i64> =
|
||||
sqlx::query_scalar("SELECT image_file_id FROM furumusic__artist WHERE id = $1")
|
||||
.bind(detail.item.id)
|
||||
.fetch_optional(pool)
|
||||
.await?
|
||||
.flatten();
|
||||
detail.current_image_url =
|
||||
image_file_id.map(|id| format!("/api/player/cover/{id}/large"));
|
||||
detail.available_covers = artist_available_covers(pool, detail.item.id).await?;
|
||||
}
|
||||
"releases" => {
|
||||
let row: Option<(Option<String>, Option<i32>, Option<i64>)> = sqlx::query_as(
|
||||
"SELECT release_type::text, year, cover_file_id FROM furumusic__release WHERE id = $1",
|
||||
)
|
||||
.bind(detail.item.id)
|
||||
.fetch_optional(pool)
|
||||
.await?;
|
||||
if let Some((release_type, year, cover_file_id)) = row {
|
||||
detail.release_type = release_type;
|
||||
detail.year = year;
|
||||
detail.current_image_url =
|
||||
cover_file_id.map(|id| format!("/api/player/cover/{id}/large"));
|
||||
}
|
||||
detail.selected_artist_ids = sqlx::query_as::<_, IdRow>(
|
||||
"SELECT artist_id AS id FROM furumusic__release_artist WHERE release_id = $1 ORDER BY position, artist_id",
|
||||
)
|
||||
.bind(detail.item.id)
|
||||
.fetch_all(pool)
|
||||
.await?
|
||||
.into_iter()
|
||||
.map(|row| row.id)
|
||||
.collect();
|
||||
detail.artists = load_artist_options(pool).await?;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
Ok(detail)
|
||||
}
|
||||
|
||||
async fn load_artist_options(pool: &PgPool) -> anyhow::Result<Vec<ArtistOptionDto>> {
|
||||
let rows = sqlx::query_as::<_, (i64, String)>(
|
||||
"SELECT id, name::text FROM furumusic__artist ORDER BY name ASC",
|
||||
)
|
||||
.fetch_all(pool)
|
||||
.await?;
|
||||
Ok(rows
|
||||
.into_iter()
|
||||
.map(|(id, name)| ArtistOptionDto { id, name })
|
||||
.collect())
|
||||
}
|
||||
|
||||
async fn artist_available_covers(
|
||||
pool: &PgPool,
|
||||
artist_id: i64,
|
||||
) -> anyhow::Result<Vec<AvailableCoverDto>> {
|
||||
let rows = sqlx::query_as::<_, (i64, String)>(
|
||||
"SELECT DISTINCT r.cover_file_id AS media_file_id, r.title::text AS release_title \
|
||||
FROM furumusic__release r \
|
||||
LEFT JOIN furumusic__release_artist ra ON ra.release_id = r.id \
|
||||
LEFT JOIN furumusic__track t ON t.release_id = r.id \
|
||||
LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id \
|
||||
WHERE r.cover_file_id IS NOT NULL AND (ra.artist_id = $1 OR ta.artist_id = $1) \
|
||||
ORDER BY r.title::text ASC",
|
||||
)
|
||||
.bind(artist_id)
|
||||
.fetch_all(pool)
|
||||
.await?;
|
||||
Ok(rows
|
||||
.into_iter()
|
||||
.map(|(media_file_id, release_title)| AvailableCoverDto {
|
||||
media_file_id,
|
||||
release_title,
|
||||
cover_url: format!("/api/player/cover/{media_file_id}/medium"),
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
|
||||
async fn library_ids_by_filter(
|
||||
pool: &PgPool,
|
||||
kind: &str,
|
||||
|
||||
+138
-12
@@ -184,6 +184,16 @@ fn config_display_entries(config: &AppConfig, sources: &ConfigSources) -> Vec<Co
|
||||
config.agent_concurrency.to_string(),
|
||||
defaults.agent_concurrency.to_string()
|
||||
),
|
||||
entry!(
|
||||
lastfm_api_key,
|
||||
config.lastfm_api_key.clone(),
|
||||
defaults.lastfm_api_key.clone()
|
||||
),
|
||||
entry!(
|
||||
lastfm_shared_secret,
|
||||
config.lastfm_shared_secret.clone(),
|
||||
defaults.lastfm_shared_secret.clone()
|
||||
),
|
||||
]
|
||||
}
|
||||
|
||||
@@ -258,6 +268,10 @@ struct SettingsTemplate {
|
||||
agent_context_limit_source: &'static str,
|
||||
agent_concurrency: String,
|
||||
agent_concurrency_source: &'static str,
|
||||
lastfm_api_key: String,
|
||||
lastfm_api_key_source: &'static str,
|
||||
lastfm_shared_secret: String,
|
||||
lastfm_shared_secret_source: &'static str,
|
||||
}
|
||||
|
||||
pub async fn settings_handler(
|
||||
@@ -310,6 +324,10 @@ pub async fn settings_handler(
|
||||
agent_context_limit_source: sources.agent_context_limit.code(),
|
||||
agent_concurrency: config.agent_concurrency.to_string(),
|
||||
agent_concurrency_source: sources.agent_concurrency.code(),
|
||||
lastfm_api_key: config.lastfm_api_key.clone(),
|
||||
lastfm_api_key_source: sources.lastfm_api_key.code(),
|
||||
lastfm_shared_secret: config.lastfm_shared_secret.clone(),
|
||||
lastfm_shared_secret_source: sources.lastfm_shared_secret.code(),
|
||||
};
|
||||
Ok(Html::new(template.render()?))
|
||||
}
|
||||
@@ -334,6 +352,8 @@ pub struct OidcSettingsForm {
|
||||
agent_confidence_threshold: Option<String>,
|
||||
agent_context_limit: Option<String>,
|
||||
agent_concurrency: Option<String>,
|
||||
lastfm_api_key: Option<String>,
|
||||
lastfm_shared_secret: Option<String>,
|
||||
}
|
||||
|
||||
pub async fn settings_submit(
|
||||
@@ -380,7 +400,9 @@ pub async fn settings_submit(
|
||||
let agent_confidence_threshold = data.agent_confidence_threshold.unwrap_or_default();
|
||||
let agent_context_limit = data.agent_context_limit.unwrap_or_default();
|
||||
let agent_concurrency = data.agent_concurrency.unwrap_or_default();
|
||||
let fields: [(&str, &str); 18] = [
|
||||
let lastfm_api_key = data.lastfm_api_key.unwrap_or_default();
|
||||
let lastfm_shared_secret = data.lastfm_shared_secret.unwrap_or_default();
|
||||
let fields: [(&str, &str); 20] = [
|
||||
("auth_password_enabled", pw_enabled),
|
||||
("auth_sso_enabled", sso_enabled),
|
||||
("oidc_button_text", &oidc_button_text),
|
||||
@@ -399,6 +421,8 @@ pub async fn settings_submit(
|
||||
("agent_confidence_threshold", &agent_confidence_threshold),
|
||||
("agent_context_limit", &agent_context_limit),
|
||||
("agent_concurrency", &agent_concurrency),
|
||||
("lastfm_api_key", &lastfm_api_key),
|
||||
("lastfm_shared_secret", &lastfm_shared_secret),
|
||||
];
|
||||
for (key, value) in fields {
|
||||
let mut entry = ConfigEntry::new(key.to_owned(), value.to_owned());
|
||||
@@ -799,7 +823,7 @@ pub async fn artists_edit(
|
||||
.await
|
||||
.ok()
|
||||
.flatten()
|
||||
.map(|mf| format!("/api/player/cover/{}", mf.id_val())),
|
||||
.map(|mf| format!("/api/player/cover/{}/large", mf.id_val())),
|
||||
None => None,
|
||||
};
|
||||
|
||||
@@ -879,7 +903,7 @@ pub async fn artists_available_covers(
|
||||
covers.push(AvailableCover {
|
||||
media_file_id: cover_fid,
|
||||
release_title: release.title_str().to_owned(),
|
||||
cover_url: format!("/api/player/cover/{cover_fid}"),
|
||||
cover_url: format!("/api/player/cover/{cover_fid}/medium"),
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -1794,12 +1818,104 @@ struct ReviewDetailTemplate {
|
||||
user_name: String,
|
||||
user_role: String,
|
||||
review: PendingReview,
|
||||
edit: ReviewEditFields,
|
||||
release_types: &'static [(&'static str, &'static str, &'static str)],
|
||||
lang_code: &'static str,
|
||||
context_pretty: String,
|
||||
result_pretty: String,
|
||||
error_message: String,
|
||||
stats: Option<scheduler::ProcessingStats>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
struct ReviewEditFields {
|
||||
title: String,
|
||||
artist: String,
|
||||
album: String,
|
||||
year: String,
|
||||
track_number: String,
|
||||
genre: String,
|
||||
featured_artists: String,
|
||||
release_type: String,
|
||||
notes: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Form)]
|
||||
pub struct ReviewApproveForm {
|
||||
title: String,
|
||||
artist: String,
|
||||
album: String,
|
||||
year: String,
|
||||
track_number: String,
|
||||
genre: String,
|
||||
featured_artists: String,
|
||||
release_type: String,
|
||||
notes: String,
|
||||
}
|
||||
|
||||
fn optional_trimmed(value: &str) -> Option<String> {
|
||||
let trimmed = value.trim();
|
||||
if trimmed.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(trimmed.to_owned())
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_optional_i32(value: &str) -> Option<i32> {
|
||||
value.trim().parse::<i32>().ok()
|
||||
}
|
||||
|
||||
fn parse_featured_artists(value: &str) -> Vec<String> {
|
||||
value
|
||||
.split(',')
|
||||
.map(str::trim)
|
||||
.filter(|part| !part.is_empty())
|
||||
.map(str::to_owned)
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn edit_fields_from_normalized(
|
||||
normalized: &crate::agent::dto::NormalizedFields,
|
||||
) -> ReviewEditFields {
|
||||
ReviewEditFields {
|
||||
title: normalized.title.clone().unwrap_or_default(),
|
||||
artist: normalized.artist.clone().unwrap_or_default(),
|
||||
album: normalized.album.clone().unwrap_or_default(),
|
||||
year: normalized.year.map(|v| v.to_string()).unwrap_or_default(),
|
||||
track_number: normalized
|
||||
.track_number
|
||||
.map(|v| v.to_string())
|
||||
.unwrap_or_default(),
|
||||
genre: normalized.genre.clone().unwrap_or_default(),
|
||||
featured_artists: normalized.featured_artists.join(", "),
|
||||
release_type: normalized
|
||||
.release_type
|
||||
.clone()
|
||||
.unwrap_or_else(|| "album".to_owned()),
|
||||
notes: normalized.notes.clone().unwrap_or_default(),
|
||||
}
|
||||
}
|
||||
|
||||
fn normalized_from_result_json(result_json: &str) -> crate::agent::dto::NormalizedFields {
|
||||
serde_json::from_str(result_json).unwrap_or_default()
|
||||
}
|
||||
|
||||
fn normalized_from_review_form(form: &ReviewApproveForm) -> crate::agent::dto::NormalizedFields {
|
||||
crate::agent::dto::NormalizedFields {
|
||||
title: optional_trimmed(&form.title),
|
||||
artist: optional_trimmed(&form.artist),
|
||||
album: optional_trimmed(&form.album),
|
||||
year: parse_optional_i32(&form.year),
|
||||
track_number: parse_optional_i32(&form.track_number),
|
||||
genre: optional_trimmed(&form.genre),
|
||||
featured_artists: parse_featured_artists(&form.featured_artists),
|
||||
release_type: optional_trimmed(&form.release_type).or_else(|| Some("album".to_owned())),
|
||||
confidence: Some(1.0),
|
||||
notes: optional_trimmed(&form.notes),
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn review_detail(
|
||||
admin: AuthenticatedUser,
|
||||
i18n: I18n,
|
||||
@@ -1830,12 +1946,17 @@ pub async fn review_detail(
|
||||
let stats = scheduler::ProcessingStats::get_by_review_id(db, review_id)
|
||||
.await
|
||||
.unwrap_or(None);
|
||||
let normalized = normalized_from_result_json(review.result_json_str());
|
||||
let edit = edit_fields_from_normalized(&normalized);
|
||||
|
||||
let template = ReviewDetailTemplate {
|
||||
t: i18n.t,
|
||||
user_name: admin.name,
|
||||
user_role: admin.role.code().to_owned(),
|
||||
review,
|
||||
edit,
|
||||
release_types: RELEASE_TYPES,
|
||||
lang_code: i18n.t.lang.code(),
|
||||
context_pretty,
|
||||
result_pretty,
|
||||
error_message,
|
||||
@@ -1850,23 +1971,28 @@ pub async fn review_approve(
|
||||
db: &Database,
|
||||
pool: &sqlx::PgPool,
|
||||
review_id: i64,
|
||||
form: RequestForm<ReviewApproveForm>,
|
||||
) -> cot::Result<cot::http::Response<Body>> {
|
||||
let mut review = PendingReview::get_by_id(db, review_id)
|
||||
.await
|
||||
.map_err(|e| cot::Error::internal(format!("db error: {e}")))?
|
||||
.ok_or_else(|| cot::Error::internal("review not found"))?;
|
||||
|
||||
let result_str = review.result_json_str().to_owned();
|
||||
let context_str = review.context_json_str().to_owned();
|
||||
let input_path = review.input_path_str().to_owned();
|
||||
|
||||
if result_str.is_empty() {
|
||||
let _ = review.set_rejected(db).await;
|
||||
let RequestForm(form_result) = form;
|
||||
let normalized = match form_result {
|
||||
FormResult::Ok(data) => normalized_from_review_form(&data),
|
||||
FormResult::ValidationError(_) => {
|
||||
return Ok(auth::redirect(&format!("/admin/reviews/{review_id}")));
|
||||
}
|
||||
|
||||
let normalized: crate::agent::dto::NormalizedFields = serde_json::from_str(&result_str)
|
||||
.map_err(|e| cot::Error::internal(format!("invalid result_json: {e}")))?;
|
||||
};
|
||||
let result_str = serde_json::to_string(&normalized)
|
||||
.map_err(|e| cot::Error::internal(format!("failed to serialize review fields: {e}")))?;
|
||||
review
|
||||
.set_result_json(db, result_str)
|
||||
.await
|
||||
.map_err(|e| cot::Error::internal(format!("db error: {e}")))?;
|
||||
let context_str = review.context_json_str().to_owned();
|
||||
let input_path = review.input_path_str().to_owned();
|
||||
|
||||
let context: serde_json::Value = serde_json::from_str(&context_str).unwrap_or_default();
|
||||
|
||||
|
||||
+59
-5
@@ -3,6 +3,7 @@
|
||||
//! Sources (in priority order):
|
||||
//! 1. Standalone image files in the album folder (cover.jpg, folder.jpg, etc.)
|
||||
//! 2. Embedded cover art in audio file metadata (ID3 APIC, Vorbis METADATA_BLOCK_PICTURE, etc.)
|
||||
//! 3. Remote metadata providers used by background backfill jobs.
|
||||
//!
|
||||
//! The first usable image found is saved as a MediaFile with file_type="cover_art"
|
||||
//! and linked to the Release via cover_file_id.
|
||||
@@ -26,6 +27,8 @@ pub enum CoverSource {
|
||||
FolderFile(PathBuf),
|
||||
/// Embedded in an audio file's metadata.
|
||||
Embedded(PathBuf),
|
||||
/// Downloaded from a remote metadata provider.
|
||||
Remote(String),
|
||||
}
|
||||
|
||||
/// Well-known cover art filenames, in priority order.
|
||||
@@ -320,16 +323,51 @@ pub async fn save_cover_to_storage(
|
||||
let hash = hash_image(&cover.data);
|
||||
|
||||
// Check if we already have this exact image in the DB
|
||||
let existing: Option<(i64,)> = sqlx::query_as(
|
||||
"SELECT id FROM furumusic__media_file WHERE sha256_hash = $1 AND file_type = 'cover_art' LIMIT 1",
|
||||
let existing: Option<(i64, String)> = sqlx::query_as(
|
||||
"SELECT id, file_path FROM furumusic__media_file WHERE sha256_hash = $1 AND file_type = 'cover_art' LIMIT 1",
|
||||
)
|
||||
.bind(&hash)
|
||||
.fetch_optional(pool)
|
||||
.await?;
|
||||
|
||||
if let Some((id,)) = existing {
|
||||
if let Some((id, file_path)) = existing {
|
||||
let path = crate::media_paths::resolve_media_file_path(storage_dir, &file_path);
|
||||
let is_inside_storage = crate::media_paths::path_for_root(storage_dir, &path).is_some();
|
||||
if !is_inside_storage {
|
||||
tracing::warn!(
|
||||
media_file_id = id,
|
||||
path = %path.display(),
|
||||
"Ignoring duplicate cover hash whose stored file is outside agent_storage_dir"
|
||||
);
|
||||
} else if !path.exists() {
|
||||
if let Some(parent) = path.parent() {
|
||||
tokio::fs::create_dir_all(parent).await?;
|
||||
}
|
||||
match tokio::fs::write(&path, &cover.data).await {
|
||||
Ok(()) => {
|
||||
tracing::info!(
|
||||
media_file_id = id,
|
||||
path = %path.display(),
|
||||
"Restored missing cover file for existing MediaFile"
|
||||
);
|
||||
}
|
||||
Err(err) => {
|
||||
tracing::warn!(
|
||||
media_file_id = id,
|
||||
path = %path.display(),
|
||||
error = %err,
|
||||
"Failed to restore missing cover file for existing MediaFile; creating a new cover file"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
if is_inside_storage && path.exists() {
|
||||
if let Err(err) = crate::agent::cover_variants::ensure_cover_variants(&path).await {
|
||||
tracing::warn!(media_file_id = id, error = %err, "Failed to generate cover variants");
|
||||
}
|
||||
return Ok(id);
|
||||
}
|
||||
}
|
||||
|
||||
let ext = extension_for_mime(&cover.mime_type);
|
||||
let filename = format!("cover.{ext}");
|
||||
@@ -337,7 +375,9 @@ pub async fn save_cover_to_storage(
|
||||
let artist_dir = sanitize_dir_name(artist_name);
|
||||
let album_dir = sanitize_dir_name(release_title);
|
||||
|
||||
let dest_dir = Path::new(storage_dir).join(&artist_dir).join(&album_dir);
|
||||
let dest_dir = crate::media_paths::resolve_config_path_buf(storage_dir)
|
||||
.join(&artist_dir)
|
||||
.join(&album_dir);
|
||||
tokio::fs::create_dir_all(&dest_dir).await?;
|
||||
|
||||
let dest_path = dest_dir.join(&filename);
|
||||
@@ -345,7 +385,13 @@ pub async fn save_cover_to_storage(
|
||||
// Write image data
|
||||
tokio::fs::write(&dest_path, &cover.data).await?;
|
||||
|
||||
let relative_path = dest_path.to_string_lossy().to_string();
|
||||
let relative_path = crate::media_paths::media_file_path_for_storage(storage_dir, &dest_path)
|
||||
.ok_or_else(|| {
|
||||
anyhow::anyhow!(
|
||||
"cover destination is outside agent_storage_dir: {}",
|
||||
dest_path.display()
|
||||
)
|
||||
})?;
|
||||
let file_size = cover.data.len() as i64;
|
||||
|
||||
let media_file = crate::music::MediaFile::create(
|
||||
@@ -374,6 +420,14 @@ pub async fn save_cover_to_storage(
|
||||
"Saved cover art"
|
||||
);
|
||||
|
||||
if let Err(err) = crate::agent::cover_variants::ensure_cover_variants(&dest_path).await {
|
||||
tracing::warn!(
|
||||
media_file_id = media_file.id_val(),
|
||||
error = %err,
|
||||
"Failed to generate cover variants"
|
||||
);
|
||||
}
|
||||
|
||||
Ok(media_file.id_val())
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,102 @@
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use image::codecs::jpeg::JpegEncoder;
|
||||
use image::imageops::FilterType;
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub struct CoverVariant {
|
||||
pub name: &'static str,
|
||||
pub max_edge: u32,
|
||||
pub quality: u8,
|
||||
}
|
||||
|
||||
pub const COVER_VARIANTS: &[CoverVariant] = &[
|
||||
CoverVariant {
|
||||
name: "small",
|
||||
max_edge: 96,
|
||||
quality: 80,
|
||||
},
|
||||
CoverVariant {
|
||||
name: "medium",
|
||||
max_edge: 256,
|
||||
quality: 82,
|
||||
},
|
||||
CoverVariant {
|
||||
name: "large",
|
||||
max_edge: 512,
|
||||
quality: 85,
|
||||
},
|
||||
];
|
||||
|
||||
pub fn variant_by_name(name: &str) -> Option<CoverVariant> {
|
||||
COVER_VARIANTS
|
||||
.iter()
|
||||
.copied()
|
||||
.find(|variant| variant.name == name)
|
||||
}
|
||||
|
||||
pub fn variant_path(original_path: &Path, variant: CoverVariant) -> PathBuf {
|
||||
let stem = original_path
|
||||
.file_stem()
|
||||
.and_then(|value| value.to_str())
|
||||
.filter(|value| !value.is_empty())
|
||||
.unwrap_or("cover");
|
||||
let filename = format!("{stem}.{}.jpg", variant.name);
|
||||
original_path.with_file_name(filename)
|
||||
}
|
||||
|
||||
pub fn missing_variants(original_path: &Path) -> Vec<CoverVariant> {
|
||||
COVER_VARIANTS
|
||||
.iter()
|
||||
.copied()
|
||||
.filter(|variant| !variant_path(original_path, *variant).exists())
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub async fn ensure_cover_variants(original_path: &Path) -> anyhow::Result<usize> {
|
||||
let missing = missing_variants(original_path);
|
||||
if missing.is_empty() {
|
||||
return Ok(0);
|
||||
}
|
||||
|
||||
let original_path = original_path.to_path_buf();
|
||||
tokio::task::spawn_blocking(move || generate_missing_variants_sync(&original_path, &missing))
|
||||
.await
|
||||
.map_err(|err| anyhow::anyhow!("cover variant task failed: {err}"))?
|
||||
}
|
||||
|
||||
fn generate_missing_variants_sync(
|
||||
original_path: &Path,
|
||||
variants: &[CoverVariant],
|
||||
) -> anyhow::Result<usize> {
|
||||
let data = std::fs::read(original_path)?;
|
||||
let image = image::load_from_memory(&data)?;
|
||||
|
||||
let mut created = 0usize;
|
||||
for variant in variants {
|
||||
let path = variant_path(original_path, *variant);
|
||||
if path.exists() {
|
||||
continue;
|
||||
}
|
||||
|
||||
if let Some(parent) = path.parent() {
|
||||
std::fs::create_dir_all(parent)?;
|
||||
}
|
||||
|
||||
let resized = image
|
||||
.resize(variant.max_edge, variant.max_edge, FilterType::Lanczos3)
|
||||
.to_rgb8();
|
||||
let mut output = Vec::new();
|
||||
let mut encoder = JpegEncoder::new_with_quality(&mut output, variant.quality);
|
||||
encoder.encode(
|
||||
&resized,
|
||||
resized.width(),
|
||||
resized.height(),
|
||||
image::ExtendedColorType::Rgb8,
|
||||
)?;
|
||||
std::fs::write(path, output)?;
|
||||
created += 1;
|
||||
}
|
||||
|
||||
Ok(created)
|
||||
}
|
||||
@@ -1,4 +1,5 @@
|
||||
pub mod cover_art;
|
||||
pub mod cover_variants;
|
||||
pub mod dto;
|
||||
pub mod metadata;
|
||||
pub mod mover;
|
||||
|
||||
+32
-49
@@ -134,6 +134,7 @@ pub struct ConfigSources {
|
||||
pub agent_context_limit: ConfigSource,
|
||||
pub agent_concurrency: ConfigSource,
|
||||
pub lastfm_api_key: ConfigSource,
|
||||
pub lastfm_shared_secret: ConfigSource,
|
||||
}
|
||||
|
||||
impl Default for ConfigSources {
|
||||
@@ -160,6 +161,7 @@ impl Default for ConfigSources {
|
||||
agent_context_limit: ConfigSource::Default,
|
||||
agent_concurrency: ConfigSource::Default,
|
||||
lastfm_api_key: ConfigSource::Default,
|
||||
lastfm_shared_secret: ConfigSource::Default,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -266,6 +268,8 @@ pub struct AppConfig {
|
||||
pub agent_concurrency: u64,
|
||||
/// Last.fm API key for weekly popularity enrichment.
|
||||
pub lastfm_api_key: String,
|
||||
/// Last.fm shared secret for authenticated scrobbling calls.
|
||||
pub lastfm_shared_secret: String,
|
||||
}
|
||||
|
||||
impl Default for AppConfig {
|
||||
@@ -292,6 +296,7 @@ impl Default for AppConfig {
|
||||
agent_context_limit: 8192,
|
||||
agent_concurrency: 2,
|
||||
lastfm_api_key: String::new(),
|
||||
lastfm_shared_secret: String::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -319,12 +324,13 @@ impl_env_overrides!(
|
||||
agent_context_limit,
|
||||
agent_concurrency,
|
||||
lastfm_api_key,
|
||||
lastfm_shared_secret,
|
||||
);
|
||||
|
||||
impl AppConfig {
|
||||
fn normalize_host_paths(&mut self) {
|
||||
self.agent_inbox_dir = normalize_host_path(&self.agent_inbox_dir);
|
||||
self.agent_storage_dir = normalize_host_path(&self.agent_storage_dir);
|
||||
self.agent_inbox_dir = crate::media_paths::resolve_config_path(&self.agent_inbox_dir);
|
||||
self.agent_storage_dir = crate::media_paths::resolve_config_path(&self.agent_storage_dir);
|
||||
}
|
||||
|
||||
/// Build config: start from defaults, then overlay env vars.
|
||||
@@ -403,50 +409,20 @@ impl AppConfig {
|
||||
apply_db_field!(agent_context_limit);
|
||||
apply_db_field!(agent_concurrency);
|
||||
apply_db_field!(lastfm_api_key);
|
||||
apply_db_field!(lastfm_shared_secret);
|
||||
}
|
||||
}
|
||||
|
||||
fn normalize_host_path(value: &str) -> String {
|
||||
let trimmed = value.trim();
|
||||
if trimmed.is_empty() {
|
||||
return String::new();
|
||||
}
|
||||
|
||||
normalize_windows_user_path(trimmed).unwrap_or_else(|| trimmed.to_owned())
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
fn normalize_windows_user_path(value: &str) -> Option<String> {
|
||||
let normalized = value.replace('\\', "/");
|
||||
let mut parts = normalized.split('/').filter(|part| !part.is_empty());
|
||||
let drive = parts.next()?;
|
||||
if drive.len() != 2 || !drive.ends_with(':') {
|
||||
return None;
|
||||
}
|
||||
if !parts.next()?.eq_ignore_ascii_case("Users") {
|
||||
return None;
|
||||
}
|
||||
let user = parts.next()?;
|
||||
if user.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
let mut out = format!("/Users/{user}");
|
||||
for part in parts {
|
||||
out.push('/');
|
||||
out.push_str(part);
|
||||
}
|
||||
Some(out)
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn normalize_windows_user_path(_value: &str) -> Option<String> {
|
||||
None
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::sync::{Mutex, MutexGuard};
|
||||
|
||||
static ENV_LOCK: Mutex<()> = Mutex::new(());
|
||||
|
||||
fn lock_env() -> MutexGuard<'static, ()> {
|
||||
ENV_LOCK.lock().unwrap_or_else(|err| err.into_inner())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn defaults_are_sane() {
|
||||
@@ -455,25 +431,29 @@ mod tests {
|
||||
assert_eq!(cfg.log_level, "info");
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
#[test]
|
||||
fn normalizes_windows_user_path_on_unix() {
|
||||
fn resolves_relative_media_paths_from_working_dir() {
|
||||
let expected = std::env::current_dir()
|
||||
.unwrap()
|
||||
.join("media")
|
||||
.join("uploads")
|
||||
.to_string_lossy()
|
||||
.to_string();
|
||||
assert_eq!(
|
||||
normalize_host_path(r"C:\Users\ab\repos\furumusic\media\uploads"),
|
||||
"/Users/ab/repos/furumusic/media/uploads"
|
||||
crate::media_paths::resolve_config_path("media/uploads"),
|
||||
expected
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
#[test]
|
||||
fn leaves_unix_path_unchanged() {
|
||||
fn keeps_absolute_windows_media_paths() {
|
||||
assert_eq!(
|
||||
normalize_host_path("/Users/ab/repos/furumusic/media/uploads"),
|
||||
"/Users/ab/repos/furumusic/media/uploads"
|
||||
crate::media_paths::resolve_config_path(r"C:\Users\ab\repos\furumusic\media\uploads"),
|
||||
"C:/Users/ab/repos/furumusic/media/uploads"
|
||||
);
|
||||
}
|
||||
|
||||
// SAFETY: tests run with --test-threads=1 so no concurrent env access.
|
||||
// SAFETY: environment-mutating tests take ENV_LOCK before changing vars.
|
||||
unsafe fn set(k: &str, v: &str) {
|
||||
unsafe { std::env::set_var(k, v) };
|
||||
}
|
||||
@@ -483,6 +463,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn env_override_string_field() {
|
||||
let _guard = lock_env();
|
||||
unsafe {
|
||||
set("FURU_OIDC_ISSUER", "https://example.com");
|
||||
}
|
||||
@@ -495,6 +476,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn env_override_bool_field() {
|
||||
let _guard = lock_env();
|
||||
unsafe {
|
||||
set("FURU_AUTH_SSO_ENABLED", "true");
|
||||
}
|
||||
@@ -507,6 +489,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn source_tracking_env() {
|
||||
let _guard = lock_env();
|
||||
unsafe {
|
||||
set("FURU_OIDC_ISSUER", "https://tracked.example.com");
|
||||
}
|
||||
|
||||
@@ -95,6 +95,10 @@ translations! {
|
||||
settings_api: "API" , "API";
|
||||
settings_swagger: "Swagger UI" , "Swagger UI";
|
||||
settings_swagger_help: "Serves interactive API docs at /swagger/ (requires restart)" , "Интерактивная документация API на /swagger/ (требуется перезапуск)";
|
||||
settings_lastfm_api_key: "Last.fm API key" , "API ключ Last.fm";
|
||||
settings_lastfm_api_key_help: "Used for Last.fm popularity and account connection" , "Используется для популярности Last.fm и подключения аккаунта";
|
||||
settings_lastfm_shared_secret: "Last.fm shared secret" , "Shared secret Last.fm";
|
||||
settings_lastfm_shared_secret_help: "Required for signed Last.fm scrobbling requests" , "Нужен для подписанных запросов скробблинга Last.fm";
|
||||
|
||||
// OIDC login errors
|
||||
login_oidc_error: "SSO login failed. Please try again." , "Ошибка входа через SSO. Попробуйте ещё раз.";
|
||||
@@ -268,6 +272,7 @@ translations! {
|
||||
// Player UI
|
||||
player_library: "Library" , "Библиотека";
|
||||
player_artists: "Artists" , "Артисты";
|
||||
player_release: "Release" , "Релиз";
|
||||
player_releases: "Releases" , "Релизы";
|
||||
player_tracks: "Tracks" , "Треки";
|
||||
player_title: "Title" , "Название";
|
||||
@@ -291,6 +296,8 @@ translations! {
|
||||
player_likes_playlist: "Likes" , "Лайки";
|
||||
player_listened: "listened" , "прослушано";
|
||||
player_search_placeholder: "Search artists, releases, tracks..." , "Поиск артистов, релизов, треков...";
|
||||
player_connection_lost: "Server connection lost" , "Нет соединения с сервером";
|
||||
player_connection_lost_detail: "Player cannot reach the server. Retrying..." , "Плеер не может связаться с сервером. Повторяю...";
|
||||
player_no_results: "No results found" , "Ничего не найдено";
|
||||
player_new_playlist: "New Playlist" , "Новый плейлист";
|
||||
player_rename_playlist: "Rename Playlist" , "Переименовать плейлист";
|
||||
@@ -326,6 +333,18 @@ translations! {
|
||||
player_lastfm_playcount: "Last.fm plays" , "Прослушивания Last.fm";
|
||||
player_lastfm_updated: "Last.fm updated" , "Last.fm обновлён";
|
||||
player_lastfm_not_loaded: "not loaded yet" , "ещё не загружено";
|
||||
player_lastfm_profile: "Last.fm" , "Last.fm";
|
||||
player_lastfm_connect: "Connect Last.fm" , "Подключить Last.fm";
|
||||
player_lastfm_connected: "Connected as {user}" , "Подключён: {user}";
|
||||
player_lastfm_reconnect: "Reconnect Last.fm" , "Переподключить Last.fm";
|
||||
player_lastfm_not_configured: "Last.fm is not configured" , "Last.fm не настроен";
|
||||
player_lastfm_status_connect: "connect account" , "подключить аккаунт";
|
||||
player_lastfm_status_connected: "connected" , "подключён";
|
||||
player_lastfm_status_reconnect: "reconnect account" , "переподключить аккаунт";
|
||||
player_lastfm_status_not_configured: "not configured" , "не настроен";
|
||||
player_lastfm_disconnect_confirm: "Disconnect Last.fm account {user}?" , "Отвязать аккаунт Last.fm {user}?";
|
||||
player_lastfm_connect_failed: "Could not open Last.fm connection" , "Не удалось открыть подключение Last.fm";
|
||||
player_lastfm_disconnect_failed: "Could not disconnect Last.fm" , "Не удалось отвязать Last.fm";
|
||||
player_play: "Play" , "Играть";
|
||||
player_like: "Like" , "Лайк";
|
||||
player_add_to_queue: "Add to queue" , "Добавить в очередь";
|
||||
|
||||
@@ -1,60 +0,0 @@
|
||||
use crate::scheduler::{Job, JobContext, JobLog};
|
||||
|
||||
/// Periodic job that auto-assigns artist images from their release covers.
|
||||
///
|
||||
/// For every artist that has no `image_file_id`, picks the cover of the most
|
||||
/// recent release (by year) that has one. Runs after the cover backfill job
|
||||
/// so freshly-extracted covers are available.
|
||||
pub struct ArtistImageBackfillJob;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl Job for ArtistImageBackfillJob {
|
||||
fn name(&self) -> &'static str {
|
||||
"artist_image_backfill"
|
||||
}
|
||||
|
||||
fn description(&self) -> &'static str {
|
||||
"Auto-assign artist images from release covers"
|
||||
}
|
||||
|
||||
fn default_cron(&self) -> &'static str {
|
||||
// 03:15 daily — after cover_backfill at 03:00
|
||||
"0 15 3 * * *"
|
||||
}
|
||||
|
||||
async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
|
||||
let result = sqlx::query(
|
||||
"UPDATE furumusic__artist a \
|
||||
SET image_file_id = ( \
|
||||
SELECT r.cover_file_id \
|
||||
FROM furumusic__release_artist ra \
|
||||
JOIN furumusic__release r ON r.id = ra.release_id \
|
||||
WHERE ra.artist_id = a.id \
|
||||
AND r.cover_file_id IS NOT NULL \
|
||||
ORDER BY r.year DESC NULLS LAST \
|
||||
LIMIT 1 \
|
||||
), \
|
||||
updated_at = $1 \
|
||||
WHERE a.image_file_id IS NULL \
|
||||
AND EXISTS ( \
|
||||
SELECT 1 FROM furumusic__release_artist ra2 \
|
||||
JOIN furumusic__release r2 ON r2.id = ra2.release_id \
|
||||
WHERE ra2.artist_id = a.id AND r2.cover_file_id IS NOT NULL \
|
||||
)",
|
||||
)
|
||||
.bind(chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string())
|
||||
.execute(&ctx.pool)
|
||||
.await?;
|
||||
|
||||
let count = result.rows_affected();
|
||||
if count > 0 {
|
||||
log.info(&format!(
|
||||
"Assigned images to {count} artists from release covers"
|
||||
));
|
||||
} else {
|
||||
log.info("All artists already have images (or no covers available)");
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -1,69 +0,0 @@
|
||||
use crate::scheduler::{Job, JobContext, JobLog};
|
||||
|
||||
/// Fallback job that assigns artist images from track cover art.
|
||||
///
|
||||
/// The primary `artist_image_backfill` job uses release covers. This job
|
||||
/// runs afterwards and covers the case where the release itself has no
|
||||
/// cover but individual tracks do (e.g. when cover art is embedded in the
|
||||
/// audio file and extracted per-track rather than per-release).
|
||||
///
|
||||
/// For every artist that *still* has no `image_file_id` after the release-
|
||||
/// based backfill, picks the `cover_file_id` of the most recent track
|
||||
/// (by year, then track id) that has one.
|
||||
pub struct ArtistTrackImageBackfillJob;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl Job for ArtistTrackImageBackfillJob {
|
||||
fn name(&self) -> &'static str {
|
||||
"artist_track_image_backfill"
|
||||
}
|
||||
|
||||
fn description(&self) -> &'static str {
|
||||
"Auto-assign artist images from track covers (fallback)"
|
||||
}
|
||||
|
||||
fn default_cron(&self) -> &'static str {
|
||||
// 03:30 daily — after artist_image_backfill at 03:15
|
||||
"0 30 3 * * *"
|
||||
}
|
||||
|
||||
async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
|
||||
let result = sqlx::query(
|
||||
"UPDATE furumusic__artist a \
|
||||
SET image_file_id = ( \
|
||||
SELECT t.cover_file_id \
|
||||
FROM furumusic__track_artist ta \
|
||||
JOIN furumusic__track t ON t.id = ta.track_id \
|
||||
WHERE ta.artist_id = a.id \
|
||||
AND t.cover_file_id IS NOT NULL \
|
||||
AND t.is_hidden = false \
|
||||
ORDER BY t.year DESC NULLS LAST, t.id DESC \
|
||||
LIMIT 1 \
|
||||
), \
|
||||
updated_at = $1 \
|
||||
WHERE a.image_file_id IS NULL \
|
||||
AND a.is_hidden = false \
|
||||
AND EXISTS ( \
|
||||
SELECT 1 FROM furumusic__track_artist ta2 \
|
||||
JOIN furumusic__track t2 ON t2.id = ta2.track_id \
|
||||
WHERE ta2.artist_id = a.id \
|
||||
AND t2.cover_file_id IS NOT NULL \
|
||||
AND t2.is_hidden = false \
|
||||
)",
|
||||
)
|
||||
.bind(chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string())
|
||||
.execute(&ctx.pool)
|
||||
.await?;
|
||||
|
||||
let count = result.rows_affected();
|
||||
if count > 0 {
|
||||
log.info(&format!(
|
||||
"Assigned images to {count} artists from track covers"
|
||||
));
|
||||
} else {
|
||||
log.info("All artists already have images (or no track covers available)");
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,167 +0,0 @@
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use crate::agent::cover_art;
|
||||
use crate::scheduler::{Job, JobContext, JobLog};
|
||||
|
||||
/// One-shot / periodic job that finds releases without cover art and attempts
|
||||
/// to extract or discover covers from their audio files in storage.
|
||||
pub struct CoverBackfillJob;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl Job for CoverBackfillJob {
|
||||
fn name(&self) -> &'static str {
|
||||
"cover_backfill"
|
||||
}
|
||||
|
||||
fn description(&self) -> &'static str {
|
||||
"Backfill cover art for releases missing covers"
|
||||
}
|
||||
|
||||
fn default_cron(&self) -> &'static str {
|
||||
// Once a day at 03:00
|
||||
"0 0 3 * * *"
|
||||
}
|
||||
|
||||
async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
|
||||
let storage_dir = &ctx.config.agent_storage_dir;
|
||||
if storage_dir.is_empty() {
|
||||
log.warn("agent_storage_dir is not configured, skipping cover backfill");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Find all releases without a cover
|
||||
let rows: Vec<(i64, String)> = sqlx::query_as(
|
||||
"SELECT r.id, r.title \
|
||||
FROM furumusic__release r \
|
||||
WHERE r.cover_file_id IS NULL \
|
||||
ORDER BY r.id",
|
||||
)
|
||||
.fetch_all(&ctx.pool)
|
||||
.await?;
|
||||
|
||||
if rows.is_empty() {
|
||||
log.info("All releases already have cover art, nothing to backfill");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
log.info(&format!(
|
||||
"Found {} releases without cover art, starting backfill...",
|
||||
rows.len()
|
||||
));
|
||||
|
||||
let mut assigned = 0u32;
|
||||
let mut failed = 0u32;
|
||||
let mut skipped_no_audio = 0u32;
|
||||
let mut skipped_no_cover = 0u32;
|
||||
let total = rows.len();
|
||||
|
||||
for (i, (release_id, release_title)) in rows.iter().enumerate() {
|
||||
log.info(&format!(
|
||||
"[{}/{}] Processing release {release_id} \"{release_title}\"...",
|
||||
i + 1,
|
||||
total,
|
||||
));
|
||||
|
||||
// Find audio files belonging to this release via tracks → media_file
|
||||
let audio_paths: Vec<(String,)> = sqlx::query_as(
|
||||
"SELECT mf.file_path \
|
||||
FROM furumusic__track t \
|
||||
JOIN furumusic__media_file mf ON mf.id = t.audio_file_id \
|
||||
WHERE t.release_id = $1 AND mf.file_type = 'audio'",
|
||||
)
|
||||
.bind(release_id)
|
||||
.fetch_all(&ctx.pool)
|
||||
.await
|
||||
.unwrap_or_default();
|
||||
|
||||
if audio_paths.is_empty() {
|
||||
log.warn(&format!(
|
||||
"Release {release_id} \"{release_title}\": no audio files found, skipping"
|
||||
));
|
||||
skipped_no_audio += 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
// Determine the folder from the first audio file's path
|
||||
let first_path = Path::new(&audio_paths[0].0);
|
||||
let folder = first_path.parent().unwrap_or(Path::new("."));
|
||||
|
||||
// Collect all audio file paths as PathBuf
|
||||
let audio_files: Vec<PathBuf> =
|
||||
audio_paths.iter().map(|(p,)| PathBuf::from(p)).collect();
|
||||
|
||||
// Try to find cover art
|
||||
let cover = match cover_art::find_best_cover(folder, &audio_files).await {
|
||||
Some(c) => c,
|
||||
None => {
|
||||
log.info(&format!(
|
||||
"Release {release_id} \"{release_title}\": no cover image found in {} audio files, skipping",
|
||||
audio_files.len(),
|
||||
));
|
||||
skipped_no_cover += 1;
|
||||
continue;
|
||||
}
|
||||
};
|
||||
|
||||
let source_desc = match &cover.source {
|
||||
cover_art::CoverSource::FolderFile(p) => format!("folder: {}", p.display()),
|
||||
cover_art::CoverSource::Embedded(p) => format!("embedded: {}", p.display()),
|
||||
};
|
||||
|
||||
// Look up artist name for storage path
|
||||
let artist_name: String = sqlx::query_scalar(
|
||||
"SELECT a.name FROM furumusic__artist a \
|
||||
JOIN furumusic__release_artist ra ON ra.artist_id = a.id \
|
||||
WHERE ra.release_id = $1 \
|
||||
ORDER BY ra.position LIMIT 1",
|
||||
)
|
||||
.bind(release_id)
|
||||
.fetch_optional(&ctx.pool)
|
||||
.await
|
||||
.ok()
|
||||
.flatten()
|
||||
.unwrap_or_else(|| "Unknown Artist".to_string());
|
||||
|
||||
match cover_art::save_cover_to_storage(
|
||||
&ctx.db,
|
||||
&ctx.pool,
|
||||
storage_dir,
|
||||
&artist_name,
|
||||
release_title,
|
||||
&cover,
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(cover_file_id) => {
|
||||
if let Err(e) =
|
||||
cover_art::assign_cover_to_release(&ctx.pool, *release_id, cover_file_id)
|
||||
.await
|
||||
{
|
||||
log.warn(&format!(
|
||||
"Release {release_id} \"{release_title}\": saved cover but failed to assign: {e}"
|
||||
));
|
||||
failed += 1;
|
||||
} else {
|
||||
log.info(&format!(
|
||||
"Release {release_id} \"{release_title}\": assigned cover from {source_desc}"
|
||||
));
|
||||
assigned += 1;
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
log.warn(&format!(
|
||||
"Release {release_id} \"{release_title}\": failed to save cover: {e}"
|
||||
));
|
||||
failed += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
log.info(&format!(
|
||||
"Cover backfill complete: {assigned} assigned, {failed} failed, \
|
||||
{skipped_no_audio} skipped (no audio), {skipped_no_cover} skipped (no cover found)"
|
||||
));
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -75,7 +75,9 @@ impl Job for InboxDiscoverJob {
|
||||
|
||||
for (_folder, files) in &groups {
|
||||
for file_path in files {
|
||||
let input_path_str = file_path.to_string_lossy().to_string();
|
||||
let input_path_str =
|
||||
crate::media_paths::path_for_root(&config.agent_inbox_dir, file_path)
|
||||
.unwrap_or_else(|| file_path.to_string_lossy().to_string());
|
||||
|
||||
// Skip if a PendingReview already exists for this path
|
||||
match PendingReview::exists_for_path(&ctx.db, &input_path_str).await {
|
||||
|
||||
+42
-19
@@ -225,14 +225,13 @@ fn group_reviews_by_folder(
|
||||
reviews: &[PendingReview],
|
||||
inbox_dir: &str,
|
||||
) -> Vec<(String, Vec<PendingReview>)> {
|
||||
let inbox = Path::new(inbox_dir);
|
||||
let mut map: HashMap<String, Vec<PendingReview>> = HashMap::new();
|
||||
|
||||
for r in reviews {
|
||||
let path = Path::new(r.input_path_str());
|
||||
let folder = path.parent().unwrap_or(path);
|
||||
let rel = folder.strip_prefix(inbox).unwrap_or(folder);
|
||||
let key = rel.to_string_lossy().to_string();
|
||||
let path = crate::media_paths::resolve_path_from_root(inbox_dir, r.input_path_str());
|
||||
let folder = path.parent().unwrap_or(path.as_path());
|
||||
let key = crate::media_paths::path_for_root(inbox_dir, folder)
|
||||
.unwrap_or_else(|| folder.to_string_lossy().to_string());
|
||||
map.entry(key).or_default().push(r.clone());
|
||||
}
|
||||
|
||||
@@ -287,8 +286,9 @@ async fn process_folder_batch(
|
||||
let mut failed_reviews: Vec<PendingReview> = Vec::new();
|
||||
|
||||
for mut review in reviews {
|
||||
let input_path_str = review.input_path_str().to_owned();
|
||||
let file_path = Path::new(&input_path_str);
|
||||
let stored_input_path = review.input_path_str().to_owned();
|
||||
let file_path =
|
||||
crate::media_paths::resolve_path_from_root(&config.agent_inbox_dir, &stored_input_path);
|
||||
let filename = file_path
|
||||
.file_name()
|
||||
.and_then(|n| n.to_str())
|
||||
@@ -336,7 +336,7 @@ async fn process_folder_batch(
|
||||
};
|
||||
|
||||
// Parse path hints
|
||||
let relative = file_path.strip_prefix(inbox_path).unwrap_or(file_path);
|
||||
let relative = file_path.strip_prefix(inbox_path).unwrap_or(&file_path);
|
||||
let uploader = crate::jobs::uploader_from_relative_path(pool, relative).await;
|
||||
let hinted_relative = crate::jobs::strip_user_upload_prefix(relative);
|
||||
let hints = crate::agent::path_hints::parse(&hinted_relative);
|
||||
@@ -471,8 +471,11 @@ async fn process_folder_batch(
|
||||
|
||||
// Build folder context from the first file's folder
|
||||
let folder_ctx = {
|
||||
let first_path = Path::new(prepared[0].review.input_path_str());
|
||||
let folder = first_path.parent().unwrap_or(first_path);
|
||||
let first_path = crate::media_paths::resolve_path_from_root(
|
||||
&config.agent_inbox_dir,
|
||||
prepared[0].review.input_path_str(),
|
||||
);
|
||||
let folder = first_path.parent().unwrap_or(first_path.as_path());
|
||||
let mut folder_files: Vec<String> = std::fs::read_dir(folder)
|
||||
.ok()
|
||||
.map(|rd| {
|
||||
@@ -631,7 +634,11 @@ async fn process_folder_batch(
|
||||
p.review.result_json = Some(result_json);
|
||||
let _ = p.review.save(db).await;
|
||||
|
||||
let input_path_str = p.review.input_path_str().to_owned();
|
||||
let input_path = crate::media_paths::resolve_path_from_root(
|
||||
&config.agent_inbox_dir,
|
||||
p.review.input_path_str(),
|
||||
);
|
||||
let input_path_str = input_path.to_string_lossy().to_string();
|
||||
|
||||
if confidence >= config.agent_confidence_threshold {
|
||||
match finalize_approved(
|
||||
@@ -787,10 +794,10 @@ pub async fn finalize_approved(
|
||||
format!("{}.{}", sanitize_filename(track_title), ext)
|
||||
};
|
||||
|
||||
let storage_dir = Path::new(storage_dir_str);
|
||||
let storage_dir = crate::media_paths::resolve_config_path_buf(storage_dir_str);
|
||||
let storage_path = if source_path.exists() {
|
||||
match mover::move_to_storage(
|
||||
storage_dir,
|
||||
&storage_dir,
|
||||
artist_name,
|
||||
release_title,
|
||||
&dest_filename,
|
||||
@@ -798,16 +805,29 @@ pub async fn finalize_approved(
|
||||
)
|
||||
.await?
|
||||
{
|
||||
mover::MoveOutcome::Moved(p) => p.to_string_lossy().to_string(),
|
||||
mover::MoveOutcome::Merged(p) => p.to_string_lossy().to_string(),
|
||||
mover::MoveOutcome::Moved(p) | mover::MoveOutcome::Merged(p) => {
|
||||
crate::media_paths::media_file_path_for_storage(storage_dir_str, &p).ok_or_else(
|
||||
|| {
|
||||
anyhow::anyhow!(
|
||||
"storage destination is outside agent_storage_dir: {}",
|
||||
p.display()
|
||||
)
|
||||
},
|
||||
)?
|
||||
}
|
||||
}
|
||||
} else {
|
||||
storage_dir
|
||||
let expected_path = storage_dir
|
||||
.join(sanitize_filename(artist_name))
|
||||
.join(sanitize_filename(release_title))
|
||||
.join(&dest_filename)
|
||||
.to_string_lossy()
|
||||
.to_string()
|
||||
.join(&dest_filename);
|
||||
crate::media_paths::media_file_path_for_storage(storage_dir_str, &expected_path)
|
||||
.ok_or_else(|| {
|
||||
anyhow::anyhow!(
|
||||
"storage destination is outside agent_storage_dir: {}",
|
||||
expected_path.display()
|
||||
)
|
||||
})?
|
||||
};
|
||||
|
||||
let media_file = MediaFile::create(
|
||||
@@ -887,6 +907,9 @@ pub async fn finalize_approved(
|
||||
crate::agent::cover_art::CoverSource::Embedded(p) => {
|
||||
format!("embedded in: {}", p.display())
|
||||
}
|
||||
crate::agent::cover_art::CoverSource::Remote(url) => {
|
||||
format!("remote: {url}")
|
||||
}
|
||||
};
|
||||
match crate::agent::cover_art::save_cover_to_storage(
|
||||
db,
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
use crate::lastfm;
|
||||
use crate::scheduler::{Job, JobContext, JobLog};
|
||||
|
||||
pub struct LastfmScrobbleJob;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl Job for LastfmScrobbleJob {
|
||||
fn name(&self) -> &'static str {
|
||||
"lastfm_scrobble"
|
||||
}
|
||||
|
||||
fn description(&self) -> &'static str {
|
||||
"Send queued Last.fm scrobbles for connected users"
|
||||
}
|
||||
|
||||
fn default_cron(&self) -> &'static str {
|
||||
// Every minute.
|
||||
"0 * * * * *"
|
||||
}
|
||||
|
||||
async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
|
||||
if !lastfm::is_configured(&ctx.config) {
|
||||
log.warn("Last.fm API key/shared secret are not configured; skipping scrobble outbox");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let summary = lastfm::process_pending_scrobbles(&ctx.pool, &ctx.config, None, 50).await?;
|
||||
log.info(&format!(
|
||||
"Last.fm scrobble outbox processed: considered={}, sent={}, failed={}, blocked={}, skipped={}",
|
||||
summary.considered, summary.sent, summary.failed, summary.blocked, summary.skipped
|
||||
));
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,3 @@
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use crate::scheduler::{Job, JobContext, JobLog};
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
@@ -104,11 +102,15 @@ pub async fn run_with_options(
|
||||
|
||||
for row in rows {
|
||||
scanned += 1;
|
||||
let Some(path) = resolve_media_path(&row.file_path, &ctx.config.agent_storage_dir) else {
|
||||
let path = crate::media_paths::resolve_media_file_path(
|
||||
&ctx.config.agent_storage_dir,
|
||||
&row.file_path,
|
||||
);
|
||||
if !path.exists() {
|
||||
missing += 1;
|
||||
log.warn(&format!("missing file: {}", row.file_path));
|
||||
continue;
|
||||
};
|
||||
}
|
||||
|
||||
let extract_path = path.clone();
|
||||
let raw_meta = match tokio::task::spawn_blocking(move || {
|
||||
@@ -218,17 +220,3 @@ fn should_update<T>(current: Option<T>, overwrite: bool) -> bool {
|
||||
fn should_update_duration(current: Option<f64>, overwrite: bool) -> bool {
|
||||
overwrite || current.unwrap_or(0.0) <= 0.0
|
||||
}
|
||||
|
||||
fn resolve_media_path(file_path: &str, storage_dir: &str) -> Option<PathBuf> {
|
||||
let path = Path::new(file_path);
|
||||
if path.exists() {
|
||||
return Some(path.to_path_buf());
|
||||
}
|
||||
if path.is_relative() && !storage_dir.is_empty() {
|
||||
let joined = Path::new(storage_dir).join(path);
|
||||
if joined.exists() {
|
||||
return Some(joined);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
+2
-3
@@ -1,9 +1,8 @@
|
||||
pub mod artist_image_backfill;
|
||||
pub mod artist_track_image_backfill;
|
||||
pub mod cover_backfill;
|
||||
pub mod artwork_backfill;
|
||||
pub mod inbox_discover;
|
||||
pub mod inbox_process;
|
||||
pub mod lastfm_popularity;
|
||||
pub mod lastfm_scrobble;
|
||||
pub mod metadata_backfill;
|
||||
|
||||
use std::path::{Component, Path, PathBuf};
|
||||
|
||||
+619
@@ -0,0 +1,619 @@
|
||||
use std::collections::BTreeMap;
|
||||
use std::time::Duration;
|
||||
|
||||
use anyhow::Context;
|
||||
use md5::{Digest, Md5};
|
||||
use reqwest::Client;
|
||||
use serde::Deserialize;
|
||||
use sqlx::PgPool;
|
||||
|
||||
use crate::config::AppConfig;
|
||||
|
||||
const LASTFM_API_URL: &str = "https://ws.audioscrobbler.com/2.0/";
|
||||
const MAX_BATCH_SIZE: i64 = 50;
|
||||
const MAX_ATTEMPTS: i32 = 8;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct LastfmCredentials {
|
||||
api_key: String,
|
||||
shared_secret: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct LastfmSession {
|
||||
pub username: String,
|
||||
pub session_key: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct LastfmTrackPayload {
|
||||
pub artist: String,
|
||||
pub track: String,
|
||||
pub album: Option<String>,
|
||||
pub album_artist: Option<String>,
|
||||
pub track_number: Option<i32>,
|
||||
pub duration_seconds: Option<i32>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct LastfmScrobblePayload {
|
||||
pub track: LastfmTrackPayload,
|
||||
pub timestamp: i64,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct LastfmApiError {
|
||||
pub code: Option<i32>,
|
||||
pub message: String,
|
||||
}
|
||||
|
||||
impl std::fmt::Display for LastfmApiError {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self.code {
|
||||
Some(code) => write!(f, "Last.fm API error {code}: {}", self.message),
|
||||
None => write!(f, "Last.fm API error: {}", self.message),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for LastfmApiError {}
|
||||
|
||||
impl LastfmApiError {
|
||||
fn new(code: Option<i32>, message: impl Into<String>) -> Self {
|
||||
Self {
|
||||
code,
|
||||
message: message.into(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_invalid_session(&self) -> bool {
|
||||
self.code == Some(9)
|
||||
}
|
||||
|
||||
pub fn is_retryable(&self) -> bool {
|
||||
matches!(self.code, Some(11 | 16 | 29) | None)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
pub struct ScrobbleProcessSummary {
|
||||
pub considered: u64,
|
||||
pub sent: u64,
|
||||
pub failed: u64,
|
||||
pub blocked: u64,
|
||||
pub skipped: u64,
|
||||
}
|
||||
|
||||
pub fn is_configured(config: &AppConfig) -> bool {
|
||||
!config.lastfm_api_key.trim().is_empty() && !config.lastfm_shared_secret.trim().is_empty()
|
||||
}
|
||||
|
||||
impl LastfmCredentials {
|
||||
pub fn from_config(config: &AppConfig) -> Option<Self> {
|
||||
let api_key = config.lastfm_api_key.trim();
|
||||
let shared_secret = config.lastfm_shared_secret.trim();
|
||||
if api_key.is_empty() || shared_secret.is_empty() {
|
||||
return None;
|
||||
}
|
||||
Some(Self {
|
||||
api_key: api_key.to_owned(),
|
||||
shared_secret: shared_secret.to_owned(),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn api_key(&self) -> &str {
|
||||
&self.api_key
|
||||
}
|
||||
}
|
||||
|
||||
pub struct LastfmClient {
|
||||
client: Client,
|
||||
credentials: LastfmCredentials,
|
||||
}
|
||||
|
||||
impl LastfmClient {
|
||||
pub fn new(credentials: LastfmCredentials) -> anyhow::Result<Self> {
|
||||
let client = Client::builder()
|
||||
.user_agent(format!(
|
||||
"furumusic-lastfm-scrobbler/{}",
|
||||
env!("CARGO_PKG_VERSION")
|
||||
))
|
||||
.timeout(Duration::from_secs(15))
|
||||
.build()
|
||||
.context("failed to build Last.fm HTTP client")?;
|
||||
Ok(Self {
|
||||
client,
|
||||
credentials,
|
||||
})
|
||||
}
|
||||
|
||||
pub async fn get_session(&self, token: &str) -> Result<LastfmSession, LastfmApiError> {
|
||||
let params = self.signed_params(
|
||||
"auth.getSession",
|
||||
None,
|
||||
vec![("token".to_string(), token.to_string())],
|
||||
);
|
||||
let body = self.post(params).await?;
|
||||
let response: AuthSessionResponse = serde_json::from_str(&body)
|
||||
.map_err(|err| LastfmApiError::new(None, err.to_string()))?;
|
||||
if let Some(code) = response.error {
|
||||
return Err(LastfmApiError::new(
|
||||
Some(code),
|
||||
response
|
||||
.message
|
||||
.unwrap_or_else(|| "authentication failed".to_string()),
|
||||
));
|
||||
}
|
||||
let Some(session) = response.session else {
|
||||
return Err(LastfmApiError::new(
|
||||
None,
|
||||
"Last.fm auth response did not include a session",
|
||||
));
|
||||
};
|
||||
Ok(LastfmSession {
|
||||
username: session.name,
|
||||
session_key: session.key,
|
||||
})
|
||||
}
|
||||
|
||||
pub async fn update_now_playing(
|
||||
&self,
|
||||
session_key: &str,
|
||||
track: &LastfmTrackPayload,
|
||||
) -> Result<(), LastfmApiError> {
|
||||
let mut extra = vec![
|
||||
("artist".to_string(), track.artist.clone()),
|
||||
("track".to_string(), track.track.clone()),
|
||||
];
|
||||
push_optional(&mut extra, "album", track.album.as_deref());
|
||||
push_optional(&mut extra, "albumArtist", track.album_artist.as_deref());
|
||||
push_optional_i32(&mut extra, "trackNumber", track.track_number);
|
||||
push_optional_i32(&mut extra, "duration", track.duration_seconds);
|
||||
|
||||
let params = self.signed_params("track.updateNowPlaying", Some(session_key), extra);
|
||||
let body = self.post(params).await?;
|
||||
check_lastfm_error(&body)
|
||||
}
|
||||
|
||||
pub async fn scrobble_batch(
|
||||
&self,
|
||||
session_key: &str,
|
||||
scrobbles: &[LastfmScrobblePayload],
|
||||
) -> Result<(), LastfmApiError> {
|
||||
let mut extra = Vec::new();
|
||||
for (index, scrobble) in scrobbles.iter().take(MAX_BATCH_SIZE as usize).enumerate() {
|
||||
let suffix = format!("[{index}]");
|
||||
extra.push((format!("artist{suffix}"), scrobble.track.artist.clone()));
|
||||
extra.push((format!("track{suffix}"), scrobble.track.track.clone()));
|
||||
extra.push((format!("timestamp{suffix}"), scrobble.timestamp.to_string()));
|
||||
push_optional(
|
||||
&mut extra,
|
||||
&format!("album{suffix}"),
|
||||
scrobble.track.album.as_deref(),
|
||||
);
|
||||
push_optional(
|
||||
&mut extra,
|
||||
&format!("albumArtist{suffix}"),
|
||||
scrobble.track.album_artist.as_deref(),
|
||||
);
|
||||
push_optional_i32(
|
||||
&mut extra,
|
||||
&format!("trackNumber{suffix}"),
|
||||
scrobble.track.track_number,
|
||||
);
|
||||
push_optional_i32(
|
||||
&mut extra,
|
||||
&format!("duration{suffix}"),
|
||||
scrobble.track.duration_seconds,
|
||||
);
|
||||
}
|
||||
|
||||
let params = self.signed_params("track.scrobble", Some(session_key), extra);
|
||||
let body = self.post(params).await?;
|
||||
check_lastfm_error(&body)
|
||||
}
|
||||
|
||||
fn signed_params(
|
||||
&self,
|
||||
method: &str,
|
||||
session_key: Option<&str>,
|
||||
extra: Vec<(String, String)>,
|
||||
) -> Vec<(String, String)> {
|
||||
let mut params = BTreeMap::new();
|
||||
params.insert("api_key".to_string(), self.credentials.api_key.clone());
|
||||
params.insert("method".to_string(), method.to_string());
|
||||
if let Some(session_key) = session_key {
|
||||
params.insert("sk".to_string(), session_key.to_string());
|
||||
}
|
||||
for (key, value) in extra {
|
||||
params.insert(key, value);
|
||||
}
|
||||
|
||||
let mut signature_input = String::new();
|
||||
for (key, value) in ¶ms {
|
||||
signature_input.push_str(key);
|
||||
signature_input.push_str(value);
|
||||
}
|
||||
signature_input.push_str(&self.credentials.shared_secret);
|
||||
let digest = Md5::digest(signature_input.as_bytes());
|
||||
let api_sig = format!("{digest:x}");
|
||||
|
||||
let mut out = params.into_iter().collect::<Vec<_>>();
|
||||
out.push(("api_sig".to_string(), api_sig));
|
||||
out.push(("format".to_string(), "json".to_string()));
|
||||
out
|
||||
}
|
||||
|
||||
async fn post(&self, params: Vec<(String, String)>) -> Result<String, LastfmApiError> {
|
||||
let response = self
|
||||
.client
|
||||
.post(LASTFM_API_URL)
|
||||
.form(¶ms)
|
||||
.send()
|
||||
.await
|
||||
.map_err(|err| LastfmApiError::new(None, err.to_string()))?;
|
||||
let status = response.status();
|
||||
let body = response
|
||||
.text()
|
||||
.await
|
||||
.map_err(|err| LastfmApiError::new(None, err.to_string()))?;
|
||||
if !status.is_success() {
|
||||
if let Some(err) = parse_error(&body) {
|
||||
return Err(err);
|
||||
}
|
||||
return Err(LastfmApiError::new(None, format!("HTTP {status}: {body}")));
|
||||
}
|
||||
Ok(body)
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn process_pending_scrobbles(
|
||||
pool: &PgPool,
|
||||
config: &AppConfig,
|
||||
user_id: Option<i64>,
|
||||
limit_per_user: i64,
|
||||
) -> anyhow::Result<ScrobbleProcessSummary> {
|
||||
let Some(credentials) = LastfmCredentials::from_config(config) else {
|
||||
return Ok(ScrobbleProcessSummary::default());
|
||||
};
|
||||
let client = LastfmClient::new(credentials)?;
|
||||
let user_ids = pending_user_ids(pool, user_id).await?;
|
||||
let mut summary = ScrobbleProcessSummary::default();
|
||||
|
||||
for uid in user_ids {
|
||||
let rows = fetch_pending_scrobbles(pool, uid, limit_per_user.min(MAX_BATCH_SIZE)).await?;
|
||||
if rows.is_empty() {
|
||||
continue;
|
||||
}
|
||||
summary.considered += rows.len() as u64;
|
||||
|
||||
let mut ids = Vec::new();
|
||||
let mut attempt_rows = Vec::new();
|
||||
let mut payloads = Vec::new();
|
||||
for row in &rows {
|
||||
match row.payload() {
|
||||
Some(payload) => {
|
||||
ids.push(row.id);
|
||||
attempt_rows.push((row.id, row.attempt_count));
|
||||
payloads.push(payload);
|
||||
}
|
||||
None => {
|
||||
mark_row_failed(pool, row.id, "track has no primary Last.fm artist").await?;
|
||||
summary.skipped += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
if ids.is_empty() {
|
||||
continue;
|
||||
}
|
||||
|
||||
match client.scrobble_batch(&rows[0].session_key, &payloads).await {
|
||||
Ok(()) => {
|
||||
mark_rows_sent(pool, &ids).await?;
|
||||
clear_account_error(pool, uid).await?;
|
||||
summary.sent += ids.len() as u64;
|
||||
}
|
||||
Err(err) if err.is_invalid_session() => {
|
||||
mark_account_reauth_required(pool, uid, &err.to_string()).await?;
|
||||
mark_rows_blocked(pool, &ids, &err.to_string()).await?;
|
||||
summary.blocked += ids.len() as u64;
|
||||
}
|
||||
Err(err) => {
|
||||
mark_rows_retry_or_failed(pool, &attempt_rows, &err).await?;
|
||||
summary.failed += ids.len() as u64;
|
||||
if err.code == Some(29) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(summary)
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct AuthSessionResponse {
|
||||
session: Option<AuthSession>,
|
||||
error: Option<i32>,
|
||||
message: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct AuthSession {
|
||||
name: String,
|
||||
key: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct ErrorEnvelope {
|
||||
error: Option<i32>,
|
||||
message: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, sqlx::FromRow)]
|
||||
struct PendingScrobbleRow {
|
||||
id: i64,
|
||||
started_at: i64,
|
||||
duration_seconds: i32,
|
||||
attempt_count: i32,
|
||||
session_key: String,
|
||||
title: String,
|
||||
artist_name: Option<String>,
|
||||
album_title: Option<String>,
|
||||
album_artist_name: Option<String>,
|
||||
track_number: Option<i32>,
|
||||
}
|
||||
|
||||
impl PendingScrobbleRow {
|
||||
fn payload(&self) -> Option<LastfmScrobblePayload> {
|
||||
let artist = self
|
||||
.artist_name
|
||||
.as_deref()
|
||||
.map(str::trim)
|
||||
.filter(|value| !value.is_empty())?
|
||||
.to_string();
|
||||
Some(LastfmScrobblePayload {
|
||||
track: LastfmTrackPayload {
|
||||
artist,
|
||||
track: self.title.clone(),
|
||||
album: non_empty(self.album_title.as_deref()),
|
||||
album_artist: non_empty(self.album_artist_name.as_deref()),
|
||||
track_number: self.track_number,
|
||||
duration_seconds: Some(self.duration_seconds),
|
||||
},
|
||||
timestamp: self.started_at,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn non_empty(value: Option<&str>) -> Option<String> {
|
||||
value
|
||||
.map(str::trim)
|
||||
.filter(|value| !value.is_empty())
|
||||
.map(ToOwned::to_owned)
|
||||
}
|
||||
|
||||
fn push_optional(params: &mut Vec<(String, String)>, key: &str, value: Option<&str>) {
|
||||
if let Some(value) = value.map(str::trim).filter(|value| !value.is_empty()) {
|
||||
params.push((key.to_string(), value.to_string()));
|
||||
}
|
||||
}
|
||||
|
||||
fn push_optional_i32(params: &mut Vec<(String, String)>, key: &str, value: Option<i32>) {
|
||||
if let Some(value) = value {
|
||||
params.push((key.to_string(), value.to_string()));
|
||||
}
|
||||
}
|
||||
|
||||
fn check_lastfm_error(body: &str) -> Result<(), LastfmApiError> {
|
||||
if let Some(err) = parse_error(body) {
|
||||
return Err(err);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn parse_error(body: &str) -> Option<LastfmApiError> {
|
||||
let envelope: ErrorEnvelope = serde_json::from_str(body).ok()?;
|
||||
envelope
|
||||
.error
|
||||
.map(|code| LastfmApiError::new(Some(code), envelope.message.unwrap_or_default()))
|
||||
}
|
||||
|
||||
async fn pending_user_ids(pool: &PgPool, user_id: Option<i64>) -> anyhow::Result<Vec<i64>> {
|
||||
if let Some(user_id) = user_id {
|
||||
return Ok(vec![user_id]);
|
||||
}
|
||||
let rows = sqlx::query_scalar::<_, i64>(
|
||||
r#"SELECT DISTINCT o.user_id
|
||||
FROM furumusic__lastfm_scrobble_outbox o
|
||||
JOIN furumusic__lastfm_account a ON a.user_id = o.user_id
|
||||
WHERE o.status IN ('pending', 'retry')
|
||||
AND a.reauth_required = false
|
||||
ORDER BY o.user_id"#,
|
||||
)
|
||||
.fetch_all(pool)
|
||||
.await?;
|
||||
Ok(rows)
|
||||
}
|
||||
|
||||
async fn fetch_pending_scrobbles(
|
||||
pool: &PgPool,
|
||||
user_id: i64,
|
||||
limit: i64,
|
||||
) -> anyhow::Result<Vec<PendingScrobbleRow>> {
|
||||
let rows = sqlx::query_as::<_, PendingScrobbleRow>(
|
||||
r#"SELECT o.id,
|
||||
o.started_at,
|
||||
o.duration_seconds,
|
||||
o.attempt_count,
|
||||
a.session_key::text AS session_key,
|
||||
t.title::text AS title,
|
||||
r.title::text AS album_title,
|
||||
t.track_number,
|
||||
(
|
||||
SELECT ar.name::text
|
||||
FROM furumusic__track_artist ta
|
||||
JOIN furumusic__artist ar ON ar.id = ta.artist_id
|
||||
WHERE ta.track_id = t.id AND ta.role <> 'featuring'
|
||||
ORDER BY ta.position
|
||||
LIMIT 1
|
||||
) AS artist_name,
|
||||
(
|
||||
SELECT ar.name::text
|
||||
FROM furumusic__release_artist ra
|
||||
JOIN furumusic__artist ar ON ar.id = ra.artist_id
|
||||
WHERE ra.release_id = r.id
|
||||
ORDER BY ra.position
|
||||
LIMIT 1
|
||||
) AS album_artist_name
|
||||
FROM furumusic__lastfm_scrobble_outbox o
|
||||
JOIN furumusic__lastfm_account a ON a.user_id = o.user_id
|
||||
JOIN furumusic__track t ON t.id = o.track_id
|
||||
LEFT JOIN furumusic__release r ON r.id = t.release_id
|
||||
WHERE o.user_id = $1
|
||||
AND o.status IN ('pending', 'retry')
|
||||
AND a.reauth_required = false
|
||||
ORDER BY o.created_at, o.id
|
||||
LIMIT $2"#,
|
||||
)
|
||||
.bind(user_id)
|
||||
.bind(limit)
|
||||
.fetch_all(pool)
|
||||
.await?;
|
||||
Ok(rows)
|
||||
}
|
||||
|
||||
async fn clear_account_error(pool: &PgPool, user_id: i64) -> anyhow::Result<()> {
|
||||
sqlx::query(
|
||||
r#"UPDATE furumusic__lastfm_account
|
||||
SET last_error = NULL,
|
||||
reauth_required = false,
|
||||
updated_at = $2
|
||||
WHERE user_id = $1"#,
|
||||
)
|
||||
.bind(user_id)
|
||||
.bind(now_iso())
|
||||
.execute(pool)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn mark_account_reauth_required(
|
||||
pool: &PgPool,
|
||||
user_id: i64,
|
||||
error: &str,
|
||||
) -> anyhow::Result<()> {
|
||||
sqlx::query(
|
||||
r#"UPDATE furumusic__lastfm_account
|
||||
SET reauth_required = true,
|
||||
last_error = $2,
|
||||
updated_at = $3
|
||||
WHERE user_id = $1"#,
|
||||
)
|
||||
.bind(user_id)
|
||||
.bind(error)
|
||||
.bind(now_iso())
|
||||
.execute(pool)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn mark_rows_sent(pool: &PgPool, ids: &[i64]) -> anyhow::Result<()> {
|
||||
if ids.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
let now = now_iso();
|
||||
sqlx::query(
|
||||
r#"UPDATE furumusic__lastfm_scrobble_outbox
|
||||
SET status = 'sent',
|
||||
updated_at = $2,
|
||||
scrobbled_at = $2,
|
||||
last_error = NULL
|
||||
WHERE id = ANY($1)"#,
|
||||
)
|
||||
.bind(ids)
|
||||
.bind(now)
|
||||
.execute(pool)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn mark_row_failed(pool: &PgPool, id: i64, error: &str) -> anyhow::Result<()> {
|
||||
sqlx::query(
|
||||
r#"UPDATE furumusic__lastfm_scrobble_outbox
|
||||
SET status = 'failed',
|
||||
attempt_count = attempt_count + 1,
|
||||
last_error = $2,
|
||||
updated_at = $3
|
||||
WHERE id = $1"#,
|
||||
)
|
||||
.bind(id)
|
||||
.bind(error)
|
||||
.bind(now_iso())
|
||||
.execute(pool)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn mark_rows_blocked(pool: &PgPool, ids: &[i64], error: &str) -> anyhow::Result<()> {
|
||||
if ids.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
sqlx::query(
|
||||
r#"UPDATE furumusic__lastfm_scrobble_outbox
|
||||
SET status = 'blocked',
|
||||
attempt_count = attempt_count + 1,
|
||||
last_error = $2,
|
||||
updated_at = $3
|
||||
WHERE id = ANY($1)"#,
|
||||
)
|
||||
.bind(ids)
|
||||
.bind(error)
|
||||
.bind(now_iso())
|
||||
.execute(pool)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn mark_rows_retry_or_failed(
|
||||
pool: &PgPool,
|
||||
rows: &[(i64, i32)],
|
||||
error: &LastfmApiError,
|
||||
) -> anyhow::Result<()> {
|
||||
if rows.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
let ids: Vec<i64> = rows.iter().map(|(id, _)| *id).collect();
|
||||
let next_status = if error.is_retryable()
|
||||
&& rows
|
||||
.iter()
|
||||
.any(|(_, attempt_count)| attempt_count + 1 < MAX_ATTEMPTS)
|
||||
{
|
||||
"retry"
|
||||
} else {
|
||||
"failed"
|
||||
};
|
||||
sqlx::query(
|
||||
r#"UPDATE furumusic__lastfm_scrobble_outbox
|
||||
SET status = CASE
|
||||
WHEN attempt_count + 1 >= $2 THEN 'failed'
|
||||
ELSE $3
|
||||
END,
|
||||
attempt_count = attempt_count + 1,
|
||||
last_error = $4,
|
||||
updated_at = $5
|
||||
WHERE id = ANY($1)"#,
|
||||
)
|
||||
.bind(&ids)
|
||||
.bind(MAX_ATTEMPTS)
|
||||
.bind(next_status)
|
||||
.bind(error.to_string())
|
||||
.bind(now_iso())
|
||||
.execute(pool)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn now_iso() -> String {
|
||||
chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string()
|
||||
}
|
||||
+4
-3
@@ -5,6 +5,8 @@ mod auth;
|
||||
mod config;
|
||||
mod i18n;
|
||||
mod jobs;
|
||||
mod lastfm;
|
||||
mod media_paths;
|
||||
mod music;
|
||||
mod oidc;
|
||||
mod player;
|
||||
@@ -49,11 +51,10 @@ fn build_registry() -> Arc<JobRegistry> {
|
||||
registry.register(jobs::inbox_discover::InboxDiscoverJob);
|
||||
registry.register(jobs::inbox_process::InboxProcessJob);
|
||||
registry.register(jobs::inbox_process::FileProcessJob);
|
||||
registry.register(jobs::cover_backfill::CoverBackfillJob);
|
||||
registry.register(jobs::artist_image_backfill::ArtistImageBackfillJob);
|
||||
registry.register(jobs::artist_track_image_backfill::ArtistTrackImageBackfillJob);
|
||||
registry.register(jobs::artwork_backfill::ArtworkBackfillJob);
|
||||
registry.register(jobs::metadata_backfill::MetadataBackfillJob);
|
||||
registry.register(jobs::lastfm_popularity::LastfmPopularityJob);
|
||||
registry.register(jobs::lastfm_scrobble::LastfmScrobbleJob);
|
||||
Arc::new(registry)
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,256 @@
|
||||
use std::path::{Component, Path, PathBuf};
|
||||
|
||||
pub fn resolve_config_path(value: &str) -> String {
|
||||
let path = resolve_config_path_buf(value);
|
||||
if path.as_os_str().is_empty() {
|
||||
String::new()
|
||||
} else {
|
||||
path.to_string_lossy().to_string()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn resolve_config_path_buf(value: &str) -> PathBuf {
|
||||
let trimmed = value.trim();
|
||||
if trimmed.is_empty() {
|
||||
return PathBuf::new();
|
||||
}
|
||||
|
||||
let normalized = normalize_slashes(trimmed);
|
||||
if is_absolute_path(&normalized) {
|
||||
PathBuf::from(normalized)
|
||||
} else {
|
||||
app_root().join(slash_path(&normalized))
|
||||
}
|
||||
}
|
||||
|
||||
pub fn resolve_media_file_path(storage_dir: &str, file_path: &str) -> PathBuf {
|
||||
resolve_path_from_root(storage_dir, file_path)
|
||||
}
|
||||
|
||||
pub fn media_file_path_for_storage(storage_dir: &str, path: &Path) -> Option<String> {
|
||||
path_for_root(storage_dir, path)
|
||||
}
|
||||
|
||||
pub fn resolve_path_from_root(root_dir: &str, stored_path: &str) -> PathBuf {
|
||||
let normalized = normalize_slashes(stored_path.trim());
|
||||
if is_absolute_path(&normalized) {
|
||||
PathBuf::from(normalized)
|
||||
} else {
|
||||
resolve_config_path_buf(root_dir).join(slash_path(&normalized))
|
||||
}
|
||||
}
|
||||
|
||||
pub fn path_for_root(root_dir: &str, path: &Path) -> Option<String> {
|
||||
let root = resolve_config_path_buf(root_dir);
|
||||
let normalized = normalize_slashes(&path.to_string_lossy());
|
||||
if is_absolute_path(&normalized) {
|
||||
return strip_root_prefix(&root, &normalized);
|
||||
}
|
||||
|
||||
relative_path_string(path)
|
||||
}
|
||||
|
||||
pub async fn normalize_media_file_paths(
|
||||
pool: &sqlx::PgPool,
|
||||
storage_dir: &str,
|
||||
) -> anyhow::Result<u64> {
|
||||
normalize_table_paths(pool, "furumusic__media_file", "file_path", storage_dir).await
|
||||
}
|
||||
|
||||
pub async fn normalize_pending_review_paths(
|
||||
pool: &sqlx::PgPool,
|
||||
inbox_dir: &str,
|
||||
) -> anyhow::Result<u64> {
|
||||
normalize_table_paths(pool, "furumusic__pending_review", "input_path", inbox_dir).await
|
||||
}
|
||||
|
||||
async fn normalize_table_paths(
|
||||
pool: &sqlx::PgPool,
|
||||
table: &str,
|
||||
column: &str,
|
||||
root_dir: &str,
|
||||
) -> anyhow::Result<u64> {
|
||||
let sql = format!("SELECT id, {column} FROM {table} WHERE {column} IS NOT NULL ORDER BY id");
|
||||
let rows: Vec<(i64, String)> = sqlx::query_as(&sql).fetch_all(pool).await?;
|
||||
|
||||
let mut updated = 0;
|
||||
for (id, stored_path) in rows {
|
||||
let Some(normalized) = normalize_stored_path(root_dir, &stored_path) else {
|
||||
continue;
|
||||
};
|
||||
if normalized == stored_path {
|
||||
continue;
|
||||
}
|
||||
|
||||
let sql = format!("UPDATE {table} SET {column} = $1 WHERE id = $2");
|
||||
sqlx::query(&sql)
|
||||
.bind(&normalized)
|
||||
.bind(id)
|
||||
.execute(pool)
|
||||
.await?;
|
||||
updated += 1;
|
||||
}
|
||||
|
||||
Ok(updated)
|
||||
}
|
||||
|
||||
fn normalize_stored_path(root_dir: &str, stored_path: &str) -> Option<String> {
|
||||
let normalized = normalize_slashes(stored_path);
|
||||
if normalized.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
if is_absolute_path(&normalized) {
|
||||
strip_root_prefix(&resolve_config_path_buf(root_dir), &normalized)
|
||||
} else {
|
||||
normalize_relative_path(&normalized)
|
||||
}
|
||||
}
|
||||
|
||||
fn app_root() -> PathBuf {
|
||||
std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
|
||||
}
|
||||
|
||||
fn normalize_slashes(value: &str) -> String {
|
||||
value.trim().replace('\\', "/")
|
||||
}
|
||||
|
||||
fn is_absolute_path(value: &str) -> bool {
|
||||
value.starts_with('/') || Path::new(value).is_absolute() || looks_like_windows_absolute(value)
|
||||
}
|
||||
|
||||
fn looks_like_windows_absolute(value: &str) -> bool {
|
||||
let bytes = value.as_bytes();
|
||||
bytes.len() >= 3 && bytes[1] == b':' && bytes[2] == b'/' && bytes[0].is_ascii_alphabetic()
|
||||
}
|
||||
|
||||
fn slash_path(value: &str) -> PathBuf {
|
||||
value
|
||||
.split('/')
|
||||
.filter(|part| !part.is_empty() && *part != ".")
|
||||
.fold(PathBuf::new(), |mut path, part| {
|
||||
path.push(part);
|
||||
path
|
||||
})
|
||||
}
|
||||
|
||||
fn normalize_relative_path(value: &str) -> Option<String> {
|
||||
let parts: Vec<&str> = value
|
||||
.split('/')
|
||||
.filter(|part| !part.is_empty() && *part != ".")
|
||||
.collect();
|
||||
if parts.is_empty() || parts.iter().any(|part| *part == "..") {
|
||||
return None;
|
||||
}
|
||||
Some(parts.join("/"))
|
||||
}
|
||||
|
||||
fn strip_root_prefix(root: &Path, normalized_path: &str) -> Option<String> {
|
||||
let root_string = normalize_slashes(&root.to_string_lossy());
|
||||
let root_trimmed = root_string.trim_end_matches('/');
|
||||
let path_trimmed = normalized_path.trim();
|
||||
|
||||
let root_cmp = comparable_path(root_trimmed);
|
||||
let path_cmp = comparable_path(path_trimmed);
|
||||
if path_cmp == root_cmp {
|
||||
return None;
|
||||
}
|
||||
|
||||
let prefix = format!("{root_cmp}/");
|
||||
if path_cmp.starts_with(&prefix) {
|
||||
let tail = &path_trimmed[root_trimmed.len() + 1..];
|
||||
return normalize_relative_path(tail);
|
||||
}
|
||||
|
||||
None
|
||||
}
|
||||
|
||||
fn comparable_path(value: &str) -> String {
|
||||
let normalized = normalize_slashes(value).trim_end_matches('/').to_owned();
|
||||
if cfg!(windows) || looks_like_windows_absolute(&normalized) {
|
||||
normalized.to_ascii_lowercase()
|
||||
} else {
|
||||
normalized
|
||||
}
|
||||
}
|
||||
|
||||
fn relative_path_string(path: &Path) -> Option<String> {
|
||||
let mut parts = Vec::new();
|
||||
for component in path.components() {
|
||||
match component {
|
||||
Component::Normal(value) => parts.push(value.to_string_lossy().to_string()),
|
||||
Component::CurDir => {}
|
||||
_ => return None,
|
||||
}
|
||||
}
|
||||
if parts.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(parts.join("/"))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn resolves_relative_config_path_from_app_root() {
|
||||
let expected = app_root().join("media").join("library");
|
||||
assert_eq!(resolve_config_path_buf("media/library"), expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn keeps_absolute_config_path() {
|
||||
assert_eq!(resolve_config_path_buf("/media"), PathBuf::from("/media"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resolves_relative_media_file_under_storage_root() {
|
||||
assert_eq!(
|
||||
resolve_media_file_path("/media", "Buckethead/Pike/cover.jpg"),
|
||||
PathBuf::from("/media")
|
||||
.join("Buckethead")
|
||||
.join("Pike")
|
||||
.join("cover.jpg")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn keeps_absolute_media_file_path() {
|
||||
assert_eq!(
|
||||
resolve_media_file_path("/media", "/media/Buckethead/Pike/cover.jpg"),
|
||||
PathBuf::from("/media/Buckethead/Pike/cover.jpg")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stores_path_relative_to_storage_root() {
|
||||
let storage = app_root().join("media").join("library");
|
||||
let path = storage.join("Artist").join("Album").join("track.flac");
|
||||
assert_eq!(
|
||||
media_file_path_for_storage(&storage.to_string_lossy(), &path).as_deref(),
|
||||
Some("Artist/Album/track.flac")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stores_windows_path_relative_to_windows_storage_root() {
|
||||
assert_eq!(
|
||||
path_for_root(
|
||||
r"C:\Users\ab\repos\furumusic\library",
|
||||
Path::new(r"C:\Users\ab\repos\furumusic\library\Artist\Album\track.mp3"),
|
||||
)
|
||||
.as_deref(),
|
||||
Some("Artist/Album/track.mp3")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn normalizes_relative_backslashes() {
|
||||
assert_eq!(
|
||||
normalize_stored_path("/media", r"Artist\Album\track.mp3").as_deref(),
|
||||
Some("Artist/Album/track.mp3")
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1692,6 +1692,129 @@ pub mod db_migrations {
|
||||
&[Operation::custom(create_lastfm_track_popularity).build()];
|
||||
}
|
||||
|
||||
// -- M0033: Last.fm scrobbling -----------------------------------------
|
||||
|
||||
#[cot::db::migrations::migration_op]
|
||||
async fn create_lastfm_scrobbling(
|
||||
ctx: migrations::MigrationContext<'_>,
|
||||
) -> cot::db::Result<()> {
|
||||
ctx.db
|
||||
.raw(
|
||||
"CREATE TABLE IF NOT EXISTS furumusic__lastfm_account (
|
||||
user_id BIGINT PRIMARY KEY,
|
||||
lastfm_username VARCHAR(255) NOT NULL,
|
||||
session_key TEXT NOT NULL,
|
||||
connected_at VARCHAR(32) NOT NULL,
|
||||
updated_at VARCHAR(32) NOT NULL,
|
||||
last_error TEXT,
|
||||
reauth_required BOOLEAN NOT NULL DEFAULT FALSE
|
||||
)",
|
||||
)
|
||||
.await?;
|
||||
ctx.db
|
||||
.raw(
|
||||
"CREATE TABLE IF NOT EXISTS furumusic__lastfm_auth_state (
|
||||
state VARCHAR(64) PRIMARY KEY,
|
||||
user_id BIGINT NOT NULL,
|
||||
created_at VARCHAR(32) NOT NULL
|
||||
)",
|
||||
)
|
||||
.await?;
|
||||
ctx.db
|
||||
.raw(
|
||||
"CREATE TABLE IF NOT EXISTS furumusic__lastfm_scrobble_outbox (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
user_id BIGINT NOT NULL,
|
||||
track_id BIGINT NOT NULL,
|
||||
started_at BIGINT NOT NULL,
|
||||
listened_seconds INTEGER NOT NULL,
|
||||
duration_seconds INTEGER NOT NULL,
|
||||
status VARCHAR(32) NOT NULL,
|
||||
attempt_count INTEGER NOT NULL DEFAULT 0,
|
||||
last_error TEXT,
|
||||
created_at VARCHAR(32) NOT NULL,
|
||||
updated_at VARCHAR(32) NOT NULL,
|
||||
scrobbled_at VARCHAR(32),
|
||||
dedupe_key VARCHAR(128) NOT NULL UNIQUE
|
||||
)",
|
||||
)
|
||||
.await?;
|
||||
ctx.db
|
||||
.raw(
|
||||
"CREATE INDEX IF NOT EXISTS idx_lastfm_scrobble_outbox_status
|
||||
ON furumusic__lastfm_scrobble_outbox (status, created_at, id)",
|
||||
)
|
||||
.await?;
|
||||
ctx.db
|
||||
.raw(
|
||||
"CREATE INDEX IF NOT EXISTS idx_lastfm_scrobble_outbox_user
|
||||
ON furumusic__lastfm_scrobble_outbox (user_id, status, created_at)",
|
||||
)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub struct M0033CreateLastfmScrobbling;
|
||||
|
||||
impl migrations::Migration for M0033CreateLastfmScrobbling {
|
||||
const APP_NAME: &'static str = "furumusic";
|
||||
const MIGRATION_NAME: &'static str = "m_0033_create_lastfm_scrobbling";
|
||||
const DEPENDENCIES: &'static [migrations::MigrationDependency] =
|
||||
&[migrations::MigrationDependency::migration(
|
||||
"furumusic",
|
||||
"m_0032_create_lastfm_track_popularity",
|
||||
)];
|
||||
const OPERATIONS: &'static [Operation] =
|
||||
&[Operation::custom(create_lastfm_scrobbling).build()];
|
||||
}
|
||||
|
||||
// -- M0034: Artwork lookup state --------------------------------------
|
||||
|
||||
#[cot::db::migrations::migration_op]
|
||||
async fn create_artwork_lookup_state(
|
||||
ctx: migrations::MigrationContext<'_>,
|
||||
) -> cot::db::Result<()> {
|
||||
ctx.db
|
||||
.raw(
|
||||
"CREATE TABLE IF NOT EXISTS furumusic__artwork_lookup_state (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
entity_kind VARCHAR(32) NOT NULL,
|
||||
entity_id BIGINT NOT NULL,
|
||||
source VARCHAR(32) NOT NULL,
|
||||
status VARCHAR(32) NOT NULL,
|
||||
attempt_count INTEGER NOT NULL DEFAULT 0,
|
||||
last_attempt_at VARCHAR(32) NOT NULL,
|
||||
last_error TEXT,
|
||||
source_url TEXT,
|
||||
UNIQUE(entity_kind, entity_id, source)
|
||||
)",
|
||||
)
|
||||
.await?;
|
||||
ctx.db
|
||||
.raw(
|
||||
"CREATE INDEX IF NOT EXISTS idx_artwork_lookup_state_retry
|
||||
ON furumusic__artwork_lookup_state (entity_kind, source, status, last_attempt_at)",
|
||||
)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub struct M0034CreateArtworkLookupState;
|
||||
|
||||
impl migrations::Migration for M0034CreateArtworkLookupState {
|
||||
const APP_NAME: &'static str = "furumusic";
|
||||
const MIGRATION_NAME: &'static str = "m_0034_create_artwork_lookup_state";
|
||||
const DEPENDENCIES: &'static [migrations::MigrationDependency] =
|
||||
&[migrations::MigrationDependency::migration(
|
||||
"furumusic",
|
||||
"m_0033_create_lastfm_scrobbling",
|
||||
)];
|
||||
const OPERATIONS: &'static [Operation] =
|
||||
&[Operation::custom(create_artwork_lookup_state).build()];
|
||||
}
|
||||
|
||||
pub const MIGRATIONS: &[&SyncDynMigration] = &[
|
||||
&M0006CreateMediaFile,
|
||||
&M0007CreateArtist,
|
||||
@@ -1715,5 +1838,7 @@ pub mod db_migrations {
|
||||
&M0030AddMediaFileUploader,
|
||||
&M0031CreateTorrentSession,
|
||||
&M0032CreateLastfmTrackPopularity,
|
||||
&M0033CreateLastfmScrobbling,
|
||||
&M0034CreateArtworkLookupState,
|
||||
];
|
||||
}
|
||||
|
||||
+264
-2
@@ -40,13 +40,13 @@ pub(super) struct ArtistDetail {
|
||||
pub(super) featured_tracks: Vec<ArtistAppearanceTrack>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
#[derive(Debug, Clone, Serialize, JsonSchema)]
|
||||
pub(super) struct ArtistRef {
|
||||
pub(super) id: i64,
|
||||
pub(super) name: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
#[derive(Debug, Clone, Serialize, JsonSchema)]
|
||||
pub(super) struct TrackItem {
|
||||
pub(super) id: i64,
|
||||
pub(super) title: String,
|
||||
@@ -55,6 +55,8 @@ pub(super) struct TrackItem {
|
||||
pub(super) duration_seconds: f64,
|
||||
pub(super) artists: Vec<ArtistRef>,
|
||||
pub(super) featured_artists: Vec<ArtistRef>,
|
||||
pub(super) release_id: i64,
|
||||
pub(super) release_title: String,
|
||||
pub(super) release_year: Option<i32>,
|
||||
pub(super) cover_url: Option<String>,
|
||||
pub(super) stream_url: String,
|
||||
@@ -135,6 +137,125 @@ pub(super) struct PlaybackStateDto {
|
||||
pub(super) volume: f64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, JsonSchema)]
|
||||
pub(super) struct DeviceHeartbeatRequest {
|
||||
pub(super) device_id: String,
|
||||
pub(super) user_agent: Option<String>,
|
||||
pub(super) current_jam_id: Option<String>,
|
||||
pub(super) playback_state: Option<PlayerDevicePlaybackStateDto>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, JsonSchema)]
|
||||
pub(super) struct DeviceSelectRequest {
|
||||
pub(super) device_id: String,
|
||||
pub(super) current_device_id: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, JsonSchema)]
|
||||
pub(super) struct DeviceCommandRequest {
|
||||
pub(super) target_device_id: Option<String>,
|
||||
pub(super) jam_id: Option<String>,
|
||||
pub(super) command: String,
|
||||
#[serde(default)]
|
||||
pub(super) payload: serde_json::Value,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct PlayerDeviceDto {
|
||||
pub(super) id: String,
|
||||
pub(super) name: String,
|
||||
pub(super) kind: String,
|
||||
pub(super) is_current: bool,
|
||||
pub(super) is_active: bool,
|
||||
pub(super) last_seen_ms: i64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct PlayerJamDto {
|
||||
pub(super) id: String,
|
||||
pub(super) name: String,
|
||||
pub(super) host_user_id: i64,
|
||||
pub(super) host_name: String,
|
||||
pub(super) is_owner: bool,
|
||||
pub(super) is_member: bool,
|
||||
pub(super) is_pending: bool,
|
||||
pub(super) is_active: bool,
|
||||
pub(super) member_count: i64,
|
||||
pub(super) host_last_seen_ms: i64,
|
||||
pub(super) host_device_online: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, JsonSchema)]
|
||||
pub(super) struct PlayerJamCreateRequest {
|
||||
pub(super) device_id: String,
|
||||
#[serde(default)]
|
||||
pub(super) invitee_user_ids: Vec<i64>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, JsonSchema)]
|
||||
pub(super) struct PlayerJamJoinRequest {
|
||||
pub(super) jam_id: String,
|
||||
pub(super) device_id: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, JsonSchema)]
|
||||
pub(super) struct PlayerJamLeaveRequest {
|
||||
pub(super) jam_id: String,
|
||||
pub(super) device_id: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct PlayerJamUserDto {
|
||||
pub(super) id: i64,
|
||||
pub(super) username: String,
|
||||
pub(super) display_name: Option<String>,
|
||||
pub(super) email: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct PlayerDeviceCommandDto {
|
||||
pub(super) id: String,
|
||||
pub(super) command: String,
|
||||
pub(super) payload: serde_json::Value,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
|
||||
pub(super) struct PlayerDevicePlaybackStateDto {
|
||||
pub(super) track: Option<serde_json::Value>,
|
||||
#[serde(default)]
|
||||
pub(super) tracks: Vec<serde_json::Value>,
|
||||
pub(super) index: i32,
|
||||
pub(super) position_seconds: f64,
|
||||
pub(super) duration_seconds: f64,
|
||||
pub(super) paused: bool,
|
||||
pub(super) shuffle: bool,
|
||||
pub(super) repeat_mode: String,
|
||||
pub(super) volume: f64,
|
||||
#[serde(default)]
|
||||
pub(super) updated_at_ms: i64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct PlayerDevicesResponse {
|
||||
pub(super) device_id: String,
|
||||
pub(super) active_device_id: Option<String>,
|
||||
pub(super) devices: Vec<PlayerDeviceDto>,
|
||||
pub(super) jams: Vec<PlayerJamDto>,
|
||||
pub(super) current_jam_id: Option<String>,
|
||||
pub(super) playback_state: Option<PlayerDevicePlaybackStateDto>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct PlayerDevicePollResponse {
|
||||
pub(super) device_id: String,
|
||||
pub(super) active_device_id: Option<String>,
|
||||
pub(super) devices: Vec<PlayerDeviceDto>,
|
||||
pub(super) jams: Vec<PlayerJamDto>,
|
||||
pub(super) current_jam_id: Option<String>,
|
||||
pub(super) commands: Vec<PlayerDeviceCommandDto>,
|
||||
pub(super) playback_state: Option<PlayerDevicePlaybackStateDto>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct PlaylistDetail {
|
||||
pub(super) id: i64,
|
||||
@@ -170,12 +291,153 @@ pub(super) struct UserProfile {
|
||||
pub(super) stats: UserStats,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct LastfmStatus {
|
||||
pub(super) configured: bool,
|
||||
pub(super) connected: bool,
|
||||
pub(super) username: Option<String>,
|
||||
pub(super) reauth_required: bool,
|
||||
pub(super) last_error: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct LastfmActionResponse {
|
||||
pub(super) ok: bool,
|
||||
pub(super) queued: bool,
|
||||
pub(super) sent: bool,
|
||||
pub(super) message: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, JsonSchema)]
|
||||
pub(super) struct LastfmNowPlayingRequest {
|
||||
pub(super) track_id: i64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, JsonSchema)]
|
||||
pub(super) struct LastfmScrobbleRequest {
|
||||
pub(super) track_id: i64,
|
||||
pub(super) started_at: Option<i64>,
|
||||
pub(super) listened_seconds: i32,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct AgentQueueStatus {
|
||||
pub(super) queued_count: i64,
|
||||
pub(super) processing_count: i64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, JsonSchema)]
|
||||
pub(super) struct UserUploadTrack {
|
||||
pub(super) track: TrackItem,
|
||||
pub(super) media_file_id: i64,
|
||||
pub(super) is_hidden: bool,
|
||||
pub(super) release_is_hidden: bool,
|
||||
pub(super) release_type: String,
|
||||
pub(super) year: Option<i32>,
|
||||
pub(super) uploaded_at: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct UserUploadRelease {
|
||||
pub(super) id: i64,
|
||||
pub(super) title: String,
|
||||
pub(super) release_type: String,
|
||||
pub(super) year: Option<i32>,
|
||||
pub(super) is_hidden: bool,
|
||||
pub(super) artists: Vec<ArtistRef>,
|
||||
pub(super) tracks: Vec<UserUploadTrack>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct UserUploadReviewFields {
|
||||
pub(super) title: String,
|
||||
pub(super) artist: String,
|
||||
pub(super) album: String,
|
||||
pub(super) year: String,
|
||||
pub(super) track_number: String,
|
||||
pub(super) genre: String,
|
||||
pub(super) featured_artists: Vec<String>,
|
||||
pub(super) release_type: String,
|
||||
pub(super) notes: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct UserUploadReviewItem {
|
||||
pub(super) id: i64,
|
||||
pub(super) status: String,
|
||||
pub(super) filename: String,
|
||||
pub(super) created_at: String,
|
||||
pub(super) updated_at: String,
|
||||
pub(super) error_message: Option<String>,
|
||||
pub(super) fields: UserUploadReviewFields,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct UserUploadQueueItem {
|
||||
pub(super) id: i64,
|
||||
pub(super) status: String,
|
||||
pub(super) filename: String,
|
||||
pub(super) created_at: String,
|
||||
pub(super) updated_at: String,
|
||||
pub(super) error_message: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct UserUploadsPage {
|
||||
pub(super) tracks: Vec<UserUploadTrack>,
|
||||
pub(super) releases: Vec<UserUploadRelease>,
|
||||
pub(super) pending: Vec<UserUploadReviewItem>,
|
||||
pub(super) queued: Vec<UserUploadQueueItem>,
|
||||
pub(super) pending_total: i64,
|
||||
pub(super) queued_total: i64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, JsonSchema)]
|
||||
pub(super) struct UserUploadTrackUpdateRequest {
|
||||
pub(super) title: Option<String>,
|
||||
pub(super) artist_names: Option<Vec<String>>,
|
||||
pub(super) featured_artist_names: Option<Vec<String>>,
|
||||
pub(super) release_title: Option<String>,
|
||||
pub(super) release_type: Option<String>,
|
||||
pub(super) release_year: Option<String>,
|
||||
pub(super) track_number: Option<String>,
|
||||
pub(super) disc_number: Option<String>,
|
||||
pub(super) is_hidden: Option<bool>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, JsonSchema)]
|
||||
pub(super) struct UserUploadReleaseUpdateRequest {
|
||||
pub(super) title: Option<String>,
|
||||
pub(super) artist_names: Option<Vec<String>>,
|
||||
pub(super) release_type: Option<String>,
|
||||
pub(super) year: Option<String>,
|
||||
pub(super) is_hidden: Option<bool>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, JsonSchema)]
|
||||
pub(super) struct UserUploadBulkTrackUpdateRequest {
|
||||
pub(super) track_ids: Vec<i64>,
|
||||
pub(super) artist_names: Option<Vec<String>>,
|
||||
pub(super) featured_artist_names: Option<Vec<String>>,
|
||||
pub(super) release_title: Option<String>,
|
||||
pub(super) release_type: Option<String>,
|
||||
pub(super) release_year: Option<String>,
|
||||
pub(super) is_hidden: Option<bool>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, JsonSchema)]
|
||||
pub(super) struct UserUploadReviewUpdateRequest {
|
||||
pub(super) title: Option<String>,
|
||||
pub(super) artist: Option<String>,
|
||||
pub(super) album: Option<String>,
|
||||
pub(super) year: Option<String>,
|
||||
pub(super) track_number: Option<String>,
|
||||
pub(super) genre: Option<String>,
|
||||
pub(super) featured_artists: Option<Vec<String>>,
|
||||
pub(super) release_type: Option<String>,
|
||||
pub(super) notes: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub(super) struct PlayHistoryItem {
|
||||
pub(super) id: i64,
|
||||
|
||||
@@ -1,15 +1,16 @@
|
||||
use crate::player::dto::UploaderSummary;
|
||||
use crate::player::rows::ReleaseUploaderRow;
|
||||
|
||||
pub(super) fn cover_url(file_id: Option<i64>) -> Option<String> {
|
||||
file_id.map(|id| format!("/api/player/cover/{id}"))
|
||||
pub(super) fn cover_variant_url(file_id: Option<i64>, variant: &str) -> Option<String> {
|
||||
file_id.map(|id| format!("/api/player/cover/{id}/{variant}"))
|
||||
}
|
||||
|
||||
pub(super) fn track_cover_url(
|
||||
pub(super) fn track_cover_variant_url(
|
||||
track_cover: Option<i64>,
|
||||
release_cover: Option<i64>,
|
||||
variant: &str,
|
||||
) -> Option<String> {
|
||||
cover_url(track_cover.or(release_cover))
|
||||
cover_variant_url(track_cover.or(release_cover), variant)
|
||||
}
|
||||
|
||||
pub(super) async fn load_release_uploaders(
|
||||
|
||||
+3458
-34
File diff suppressed because it is too large
Load Diff
@@ -3,6 +3,7 @@ use serde::Deserialize;
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub(super) struct HistoryEntry {
|
||||
pub(super) track_id: i64,
|
||||
pub(super) started_at: Option<i64>,
|
||||
pub(super) duration_listened: Option<i32>,
|
||||
pub(super) completed: bool,
|
||||
}
|
||||
@@ -18,6 +19,11 @@ pub(super) struct TracksByIdsRequest {
|
||||
pub(super) ids: Vec<i64>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub(super) struct UserUploadsQuery {
|
||||
pub(super) limit: Option<i32>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub(super) struct CreatePlaylistRequest {
|
||||
pub(super) title: String,
|
||||
@@ -61,6 +67,12 @@ pub(super) struct SearchQuery {
|
||||
pub(super) limit: Option<i32>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub(super) struct JamUserSearchQuery {
|
||||
pub(super) q: Option<String>,
|
||||
pub(super) limit: Option<i32>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub(super) struct PathTrackId {
|
||||
pub(super) track_id: i64,
|
||||
@@ -70,3 +82,9 @@ pub(super) struct PathTrackId {
|
||||
pub(super) struct PathMediaFileId {
|
||||
pub(super) media_file_id: i64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub(super) struct PathMediaFileVariant {
|
||||
pub(super) media_file_id: i64,
|
||||
pub(super) variant: String,
|
||||
}
|
||||
|
||||
@@ -12,6 +12,14 @@ pub(super) struct CountRow {
|
||||
pub(super) count: i64,
|
||||
}
|
||||
|
||||
#[derive(sqlx::FromRow)]
|
||||
pub(super) struct PlayerJamUserRow {
|
||||
pub(super) id: i64,
|
||||
pub(super) username: String,
|
||||
pub(super) display_name: Option<String>,
|
||||
pub(super) email: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(sqlx::FromRow)]
|
||||
pub(super) struct ReleaseRow {
|
||||
pub(super) id: i64,
|
||||
@@ -37,6 +45,8 @@ pub(super) struct TrackRow {
|
||||
pub(super) duration_seconds: f64,
|
||||
pub(super) cover_file_id: Option<i64>,
|
||||
pub(super) release_cover_file_id: Option<i64>,
|
||||
pub(super) release_id: i64,
|
||||
pub(super) release_title: String,
|
||||
pub(super) release_year: Option<i32>,
|
||||
pub(super) uploader_name: String,
|
||||
pub(super) audio_format: Option<String>,
|
||||
@@ -58,6 +68,13 @@ pub(super) struct TrackArtistRow {
|
||||
pub(super) role: String,
|
||||
}
|
||||
|
||||
#[derive(sqlx::FromRow)]
|
||||
pub(super) struct ReleaseArtistRefRow {
|
||||
pub(super) release_id: i64,
|
||||
pub(super) artist_id: i64,
|
||||
pub(super) artist_name: String,
|
||||
}
|
||||
|
||||
#[derive(sqlx::FromRow)]
|
||||
pub(super) struct MediaFileRow {
|
||||
pub(super) file_path: String,
|
||||
@@ -107,6 +124,8 @@ pub(super) struct PlaylistTrackRow {
|
||||
pub(super) duration_seconds: f64,
|
||||
pub(super) cover_file_id: Option<i64>,
|
||||
pub(super) release_cover_file_id: Option<i64>,
|
||||
pub(super) release_id: i64,
|
||||
pub(super) release_title: String,
|
||||
pub(super) release_year: Option<i32>,
|
||||
pub(super) uploader_name: String,
|
||||
pub(super) audio_format: Option<String>,
|
||||
@@ -120,6 +139,70 @@ pub(super) struct PlaylistTrackRow {
|
||||
pub(super) lastfm_updated_at: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(sqlx::FromRow)]
|
||||
pub(super) struct UploadedTrackRow {
|
||||
pub(super) id: i64,
|
||||
pub(super) title: String,
|
||||
pub(super) track_number: Option<i32>,
|
||||
pub(super) disc_number: Option<i32>,
|
||||
pub(super) duration_seconds: f64,
|
||||
pub(super) cover_file_id: Option<i64>,
|
||||
pub(super) release_cover_file_id: Option<i64>,
|
||||
pub(super) release_id: i64,
|
||||
pub(super) release_title: String,
|
||||
pub(super) release_type: String,
|
||||
pub(super) release_year: Option<i32>,
|
||||
pub(super) release_is_hidden: bool,
|
||||
pub(super) uploader_name: String,
|
||||
pub(super) audio_format: Option<String>,
|
||||
pub(super) audio_bitrate: Option<i32>,
|
||||
pub(super) audio_sample_rate: Option<i32>,
|
||||
pub(super) audio_bit_depth: Option<i32>,
|
||||
pub(super) file_size_bytes: Option<i64>,
|
||||
pub(super) lastfm_listeners: Option<i64>,
|
||||
pub(super) lastfm_playcount: Option<i64>,
|
||||
pub(super) lastfm_rating: Option<f64>,
|
||||
pub(super) lastfm_updated_at: Option<String>,
|
||||
pub(super) media_file_id: i64,
|
||||
pub(super) is_hidden: bool,
|
||||
pub(super) year: Option<i32>,
|
||||
pub(super) uploaded_at: String,
|
||||
}
|
||||
|
||||
#[derive(sqlx::FromRow)]
|
||||
pub(super) struct UserUploadQueueRow {
|
||||
pub(super) id: i64,
|
||||
pub(super) status: String,
|
||||
pub(super) input_path: Option<String>,
|
||||
pub(super) created_at: String,
|
||||
pub(super) updated_at: String,
|
||||
pub(super) error_message: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(sqlx::FromRow)]
|
||||
pub(super) struct UserUploadReviewRow {
|
||||
pub(super) id: i64,
|
||||
pub(super) status: String,
|
||||
pub(super) input_path: Option<String>,
|
||||
pub(super) result_json: Option<String>,
|
||||
pub(super) context_json: Option<String>,
|
||||
pub(super) created_at: String,
|
||||
pub(super) updated_at: String,
|
||||
pub(super) error_message: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(sqlx::FromRow)]
|
||||
pub(super) struct UploadTrackEditRow {
|
||||
pub(super) release_id: i64,
|
||||
pub(super) title: String,
|
||||
pub(super) track_number: Option<i32>,
|
||||
pub(super) disc_number: Option<i32>,
|
||||
pub(super) is_hidden: bool,
|
||||
pub(super) release_title: String,
|
||||
pub(super) release_type: String,
|
||||
pub(super) release_year: Option<i32>,
|
||||
}
|
||||
|
||||
#[derive(sqlx::FromRow)]
|
||||
pub(super) struct AppearanceTrackRow {
|
||||
pub(super) id: i64,
|
||||
@@ -170,6 +253,8 @@ pub(super) struct SearchTrackRow {
|
||||
pub(super) duration_seconds: f64,
|
||||
pub(super) cover_file_id: Option<i64>,
|
||||
pub(super) release_cover_file_id: Option<i64>,
|
||||
pub(super) release_id: i64,
|
||||
pub(super) release_title: String,
|
||||
pub(super) release_year: Option<i32>,
|
||||
pub(super) uploader_name: String,
|
||||
pub(super) audio_format: Option<String>,
|
||||
|
||||
+40
-1
@@ -460,6 +460,16 @@ impl PendingReview {
|
||||
self.save(db).await
|
||||
}
|
||||
|
||||
pub async fn set_result_json(
|
||||
&mut self,
|
||||
db: &Database,
|
||||
result_json: String,
|
||||
) -> cot::db::Result<()> {
|
||||
self.result_json = Some(result_json);
|
||||
self.updated_at = now_iso();
|
||||
self.save(db).await
|
||||
}
|
||||
|
||||
pub async fn set_failed(&mut self, db: &Database, error: &str) -> cot::db::Result<()> {
|
||||
self.status = LimitedString::new("failed").unwrap();
|
||||
self.error_message = Some(error.to_owned());
|
||||
@@ -1347,7 +1357,11 @@ async fn run_scheduled_job(
|
||||
|
||||
// Check agent_enabled (re-read from DB every run)
|
||||
let (live_config, _) = AppConfig::load_with_db(db).await;
|
||||
if !live_config.agent_enabled && job_name != "lastfm_popularity" {
|
||||
if !live_config.agent_enabled
|
||||
&& job_name != "lastfm_popularity"
|
||||
&& job_name != "lastfm_scrobble"
|
||||
&& job_name != "artwork_backfill"
|
||||
{
|
||||
tracing::warn!(job = job_name, "Skipping: agent_enabled=false");
|
||||
return;
|
||||
}
|
||||
@@ -1457,6 +1471,31 @@ pub async fn start_scheduler(
|
||||
Err(e) => tracing::error!("Failed to recover stale reviews: {e}"),
|
||||
}
|
||||
|
||||
let (live_config, _) = AppConfig::load_with_db(&db).await;
|
||||
if !live_config.agent_storage_dir.trim().is_empty() {
|
||||
match crate::media_paths::normalize_media_file_paths(&pool, &live_config.agent_storage_dir)
|
||||
.await
|
||||
{
|
||||
Ok(0) => {}
|
||||
Ok(n) => tracing::info!("Normalized {n} media file path(s) to relative storage paths"),
|
||||
Err(e) => tracing::warn!("Failed to normalize media file paths: {e:#}"),
|
||||
}
|
||||
}
|
||||
if !live_config.agent_inbox_dir.trim().is_empty() {
|
||||
match crate::media_paths::normalize_pending_review_paths(
|
||||
&pool,
|
||||
&live_config.agent_inbox_dir,
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(0) => {}
|
||||
Ok(n) => {
|
||||
tracing::info!("Normalized {n} pending review path(s) to relative inbox paths")
|
||||
}
|
||||
Err(e) => tracing::warn!("Failed to normalize pending review paths: {e:#}"),
|
||||
}
|
||||
}
|
||||
|
||||
// Upsert ScheduledJob rows
|
||||
for job in registry.all_jobs() {
|
||||
ScheduledJob::upsert(&db, job.name(), job.description(), job.default_cron())
|
||||
|
||||
+1
-1
@@ -1242,7 +1242,7 @@ fn validate_selection(files: &[TorrentFileDto], selected_files: &[usize]) -> any
|
||||
|
||||
fn validate_inbox_dir(inbox_dir: &str) -> anyhow::Result<PathBuf> {
|
||||
let trimmed = inbox_dir.trim();
|
||||
let path = PathBuf::from(trimmed);
|
||||
let path = crate::media_paths::resolve_config_path_buf(trimmed);
|
||||
if !path.is_absolute() {
|
||||
bail!(
|
||||
"agent_inbox_dir must be an absolute path for this host, got `{}`",
|
||||
|
||||
@@ -25,28 +25,76 @@
|
||||
</div>
|
||||
{% endif %}
|
||||
|
||||
<div style="margin: 1rem 0; display: flex; gap: .5rem;">
|
||||
{% if review.status_str() == "pending" %}
|
||||
<form method="post" action="/admin/reviews/{{ review.id_val() }}/approve" style="display:inline;">
|
||||
<button type="submit" style="padding:.4rem 1rem; background:#28a745; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.reviews_approve }}</button>
|
||||
<h2>{{ t.reviews_result }}</h2>
|
||||
<form method="post" action="/admin/reviews/{{ review.id_val() }}/approve" style="margin: 1rem 0;">
|
||||
<table>
|
||||
<tr>
|
||||
<td><label for="artist">Artist</label></td>
|
||||
<td><input name="artist" id="artist" value="{{ edit.artist }}" style="width:100%"></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><label for="album">Album</label></td>
|
||||
<td><input name="album" id="album" value="{{ edit.album }}" style="width:100%"></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><label for="title">Title</label></td>
|
||||
<td><input name="title" id="title" value="{{ edit.title }}" style="width:100%"></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><label for="year">Year</label></td>
|
||||
<td><input name="year" id="year" type="number" min="0" max="3000" value="{{ edit.year }}" style="width:100%"></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><label for="track_number">Track</label></td>
|
||||
<td><input name="track_number" id="track_number" type="number" min="0" value="{{ edit.track_number }}" style="width:100%"></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><label for="genre">Genre</label></td>
|
||||
<td><input name="genre" id="genre" value="{{ edit.genre }}" style="width:100%"></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><label for="featured_artists">Featured artists</label></td>
|
||||
<td><input name="featured_artists" id="featured_artists" value="{{ edit.featured_artists }}" style="width:100%"></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><label for="release_type">{{ t.releases_type }}</label></td>
|
||||
<td>
|
||||
<select name="release_type" id="release_type" style="width:100%; padding:.4rem;">
|
||||
{% for rt in release_types %}
|
||||
<option value="{{ rt.0 }}"{% if edit.release_type == rt.0 %} selected{% endif %}>{% if lang_code == "ru" %}{{ rt.2 }}{% else %}{{ rt.1 }}{% endif %} ({{ rt.0 }})</option>
|
||||
{% endfor %}
|
||||
</select>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><label for="notes">Notes</label></td>
|
||||
<td><textarea name="notes" id="notes" style="width:100%; min-height:4rem;">{{ edit.notes }}</textarea></td>
|
||||
</tr>
|
||||
</table>
|
||||
<button type="submit" style="margin-top:1rem; padding:.4rem 1rem; background:#28a745; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.reviews_approve }}</button>
|
||||
</form>
|
||||
<div style="margin: 1rem 0; display: flex; gap: .5rem;">
|
||||
<form method="post" action="/admin/reviews/{{ review.id_val() }}/reject" style="display:inline;">
|
||||
<button type="submit" style="padding:.4rem 1rem; background:#dc3545; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.reviews_reject }}</button>
|
||||
</form>
|
||||
{% endif %}
|
||||
</div>
|
||||
{% else %}
|
||||
<div style="margin: 1rem 0; display: flex; gap: .5rem;">
|
||||
{% if review.status_str() == "failed" || review.status_str() == "processing" %}
|
||||
<form method="post" action="/admin/reviews/{{ review.id_val() }}/requeue" style="display:inline;" onsubmit="return confirm('{{ t.reviews_requeue_confirm }}');">
|
||||
<button type="submit" style="padding:.4rem 1rem; background:#17a2b8; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.reviews_requeue }}</button>
|
||||
</form>
|
||||
{% endif %}
|
||||
</div>
|
||||
{% endif %}
|
||||
|
||||
{% if !context_pretty.is_empty() %}
|
||||
<h2>{{ t.reviews_context }}</h2>
|
||||
<pre style="background:#f4f4f4; padding:1rem; border-radius:6px; overflow-x:auto; font-size:.85rem;">{{ context_pretty }}</pre>
|
||||
{% endif %}
|
||||
|
||||
{% if !result_pretty.is_empty() %}
|
||||
{% if !result_pretty.is_empty() && review.status_str() != "pending" %}
|
||||
<h2>{{ t.reviews_result }}</h2>
|
||||
<pre style="background:#f4f4f4; padding:1rem; border-radius:6px; overflow-x:auto; font-size:.85rem;">{{ result_pretty }}</pre>
|
||||
{% endif %}
|
||||
|
||||
@@ -85,6 +85,16 @@
|
||||
<td><input type="checkbox" name="swagger_enabled" id="swagger_enabled" value="on"{% if swagger_enabled %} checked{% endif %}></td>
|
||||
<td><span class="badge badge-{{ swagger_enabled_source }}">{{ swagger_enabled_source }}</span></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><label for="lastfm_api_key">{{ t.settings_lastfm_api_key }}</label><br><span style="font-size:.75rem;color:#999;">{{ t.settings_lastfm_api_key_help }}</span></td>
|
||||
<td><input type="password" name="lastfm_api_key" id="lastfm_api_key" value="{{ lastfm_api_key }}"></td>
|
||||
<td><span class="badge badge-{{ lastfm_api_key_source }}">{{ lastfm_api_key_source }}</span></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><label for="lastfm_shared_secret">{{ t.settings_lastfm_shared_secret }}</label><br><span style="font-size:.75rem;color:#999;">{{ t.settings_lastfm_shared_secret_help }}</span></td>
|
||||
<td><input type="password" name="lastfm_shared_secret" id="lastfm_shared_secret" value="{{ lastfm_shared_secret }}"></td>
|
||||
<td><span class="badge badge-{{ lastfm_shared_secret_source }}">{{ lastfm_shared_secret_source }}</span></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h2>{{ t.settings_agent }}</h2>
|
||||
|
||||
+578
-26
@@ -851,7 +851,8 @@ tbody tr:hover {
|
||||
}
|
||||
|
||||
.field input,
|
||||
.field textarea {
|
||||
.field textarea,
|
||||
.field select {
|
||||
width: 100%;
|
||||
min-height: 34px;
|
||||
padding: 8px 10px;
|
||||
@@ -869,6 +870,165 @@ tbody tr:hover {
|
||||
font-size: 11px;
|
||||
}
|
||||
|
||||
.image-editor {
|
||||
display: grid;
|
||||
grid-template-columns: 150px minmax(0, 1fr);
|
||||
gap: 14px;
|
||||
margin-bottom: 12px;
|
||||
}
|
||||
|
||||
.image-preview {
|
||||
width: 150px;
|
||||
aspect-ratio: 1;
|
||||
border: 1px solid var(--border-color);
|
||||
border-radius: 8px;
|
||||
background: var(--bg-primary);
|
||||
display: grid;
|
||||
place-items: center;
|
||||
overflow: hidden;
|
||||
color: var(--text-subdued);
|
||||
font-size: 12px;
|
||||
}
|
||||
|
||||
.image-preview img {
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
object-fit: cover;
|
||||
}
|
||||
|
||||
.cover-grid {
|
||||
display: grid;
|
||||
grid-template-columns: repeat(auto-fill, minmax(86px, 1fr));
|
||||
gap: 8px;
|
||||
}
|
||||
|
||||
.cover-option {
|
||||
min-width: 0;
|
||||
padding: 6px;
|
||||
border: 1px solid var(--border-color);
|
||||
border-radius: 8px;
|
||||
background: var(--bg-primary);
|
||||
color: var(--text-secondary);
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
.cover-option:hover {
|
||||
border-color: rgba(29, 185, 84, 0.55);
|
||||
color: var(--text-primary);
|
||||
}
|
||||
|
||||
.cover-option img {
|
||||
width: 100%;
|
||||
aspect-ratio: 1;
|
||||
object-fit: cover;
|
||||
border-radius: 5px;
|
||||
display: block;
|
||||
}
|
||||
|
||||
.cover-option span {
|
||||
display: block;
|
||||
margin-top: 5px;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
font-size: 10px;
|
||||
}
|
||||
|
||||
.artist-tags {
|
||||
display: flex;
|
||||
gap: 6px;
|
||||
flex-wrap: wrap;
|
||||
margin-bottom: 8px;
|
||||
}
|
||||
|
||||
.artist-picker {
|
||||
position: relative;
|
||||
}
|
||||
|
||||
.artist-picker input {
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
.artist-results {
|
||||
position: absolute;
|
||||
left: 0;
|
||||
right: 0;
|
||||
top: calc(100% + 5px);
|
||||
z-index: 5;
|
||||
max-height: 242px;
|
||||
overflow: auto;
|
||||
border: 1px solid var(--border-color);
|
||||
border-radius: 8px;
|
||||
background: var(--bg-elevated);
|
||||
box-shadow: 0 14px 34px rgba(0, 0, 0, 0.38);
|
||||
}
|
||||
|
||||
.artist-result {
|
||||
width: 100%;
|
||||
min-height: 34px;
|
||||
padding: 8px 10px;
|
||||
border: 0;
|
||||
border-bottom: 1px solid rgba(255, 255, 255, 0.06);
|
||||
background: transparent;
|
||||
color: var(--text-secondary);
|
||||
text-align: left;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
.artist-result:hover,
|
||||
.artist-result:focus {
|
||||
background: var(--bg-hover);
|
||||
color: var(--text-primary);
|
||||
}
|
||||
|
||||
.artist-result:last-child {
|
||||
border-bottom: 0;
|
||||
}
|
||||
|
||||
.tag button {
|
||||
width: 16px;
|
||||
height: 16px;
|
||||
margin-left: 5px;
|
||||
border: 0;
|
||||
border-radius: 999px;
|
||||
background: rgba(255, 255, 255, 0.14);
|
||||
color: inherit;
|
||||
cursor: pointer;
|
||||
line-height: 1;
|
||||
}
|
||||
|
||||
.tag button:hover {
|
||||
background: rgba(255, 255, 255, 0.24);
|
||||
}
|
||||
|
||||
.editor-grid {
|
||||
display: grid;
|
||||
grid-template-columns: repeat(2, minmax(0, 1fr));
|
||||
gap: 12px;
|
||||
}
|
||||
|
||||
.image-actions {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 8px;
|
||||
flex-wrap: wrap;
|
||||
margin-bottom: 10px;
|
||||
}
|
||||
|
||||
.file-name {
|
||||
max-width: 280px;
|
||||
color: var(--text-subdued);
|
||||
font-size: 11px;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.cover-option.active {
|
||||
border-color: rgba(29, 185, 84, 0.8);
|
||||
box-shadow: 0 0 0 1px rgba(29, 185, 84, 0.32);
|
||||
}
|
||||
|
||||
.muted {
|
||||
color: var(--text-subdued);
|
||||
}
|
||||
@@ -976,7 +1136,7 @@ tbody tr:hover {
|
||||
<button class="nav-btn" :class="{active: activeView === 'settings'}" @click="openSettings()">
|
||||
<i data-lucide="settings"></i>
|
||||
<span>Settings</span>
|
||||
<span class="nav-count" x-text="settings.lastfm_api_key_configured ? 'ok' : ''"></span>
|
||||
<span class="nav-count" x-text="settings.lastfm_scrobbling_configured ? 'ok' : ''"></span>
|
||||
</button>
|
||||
</div>
|
||||
|
||||
@@ -1574,7 +1734,7 @@ tbody tr:hover {
|
||||
<strong>API</strong>
|
||||
<span>Developer and enrichment integrations</span>
|
||||
</div>
|
||||
<span class="badge" :class="settings.lastfm_api_key_configured ? 'ok' : 'disabled'" x-text="settings.lastfm_api_key_configured ? 'Last.fm configured' : 'Last.fm missing'"></span>
|
||||
<span class="badge" :class="settings.lastfm_scrobbling_configured ? 'ok' : 'disabled'" x-text="settings.lastfm_scrobbling_configured ? 'Last.fm configured' : 'Last.fm missing'"></span>
|
||||
</div>
|
||||
<div class="settings-grid">
|
||||
<div class="setting-toggle">
|
||||
@@ -1590,11 +1750,19 @@ tbody tr:hover {
|
||||
</div>
|
||||
<div class="setting-field">
|
||||
<label>
|
||||
<span>Last.fm API key</span>
|
||||
<span>{{ t.settings_lastfm_api_key }}</span>
|
||||
<span class="source-pill" :class="sourceClass('lastfm_api_key')" x-text="settingSource('lastfm_api_key')"></span>
|
||||
</label>
|
||||
<input type="password" x-model="settingsDraft.lastfm_api_key" autocomplete="off" />
|
||||
<div class="setting-help">Used by the weekly Last.fm popularity task.</div>
|
||||
<div class="setting-help">{{ t.settings_lastfm_api_key_help }}</div>
|
||||
</div>
|
||||
<div class="setting-field">
|
||||
<label>
|
||||
<span>{{ t.settings_lastfm_shared_secret }}</span>
|
||||
<span class="source-pill" :class="sourceClass('lastfm_shared_secret')" x-text="settingSource('lastfm_shared_secret')"></span>
|
||||
</label>
|
||||
<input type="password" x-model="settingsDraft.lastfm_shared_secret" autocomplete="off" />
|
||||
<div class="setting-help">{{ t.settings_lastfm_shared_secret_help }}</div>
|
||||
</div>
|
||||
</div>
|
||||
</section>
|
||||
@@ -1673,7 +1841,60 @@ tbody tr:hover {
|
||||
<label>Error</label>
|
||||
<textarea readonly x-text="activeReview?.error_message || ''"></textarea>
|
||||
</div>
|
||||
<div x-show="activeReview?.status === 'pending'">
|
||||
<div class="field">
|
||||
<label>Artist</label>
|
||||
<input x-model="reviewDraft.artist" />
|
||||
</div>
|
||||
<div class="field">
|
||||
<label>Album</label>
|
||||
<input x-model="reviewDraft.album" />
|
||||
</div>
|
||||
<div class="field">
|
||||
<label>Title</label>
|
||||
<input x-model="reviewDraft.title" />
|
||||
</div>
|
||||
<div style="display:grid; grid-template-columns: 1fr 1fr; gap: 12px;">
|
||||
<div class="field">
|
||||
<label>Year</label>
|
||||
<input type="number" min="0" max="3000" x-model="reviewDraft.year" />
|
||||
</div>
|
||||
<div class="field">
|
||||
<label>Track</label>
|
||||
<input type="number" min="0" x-model="reviewDraft.track_number" />
|
||||
</div>
|
||||
</div>
|
||||
<div class="field">
|
||||
<label>Genre</label>
|
||||
<input x-model="reviewDraft.genre" />
|
||||
</div>
|
||||
<div class="field">
|
||||
<label>Featured artists</label>
|
||||
<input x-model="reviewDraft.featured_artists" />
|
||||
</div>
|
||||
<div class="field">
|
||||
<label>Release type</label>
|
||||
<select x-model="reviewDraft.release_type">
|
||||
<option value="album">Album</option>
|
||||
<option value="single">Single</option>
|
||||
<option value="ep">EP</option>
|
||||
<option value="compilation">Compilation</option>
|
||||
<option value="soundtrack">Soundtrack</option>
|
||||
<option value="live">Live</option>
|
||||
<option value="remix">Remix</option>
|
||||
<option value="unknown">Unknown</option>
|
||||
</select>
|
||||
</div>
|
||||
<div class="field">
|
||||
<label>Notes</label>
|
||||
<textarea x-model="reviewDraft.notes"></textarea>
|
||||
</div>
|
||||
</div>
|
||||
<div class="toolbar">
|
||||
<button class="btn primary" x-show="activeReview?.status === 'pending'" @click="approveActiveReview()">
|
||||
<i data-lucide="check"></i>
|
||||
Approve
|
||||
</button>
|
||||
<button class="btn warn" @click="bulkOneReview('requeue', activeReview)">
|
||||
<i data-lucide="rotate-ccw"></i>
|
||||
Requeue
|
||||
@@ -1699,14 +1920,55 @@ tbody tr:hover {
|
||||
</button>
|
||||
</div>
|
||||
<div class="modal-body" x-show="activeLibraryItem">
|
||||
<div class="empty" x-show="editorLoading">Loading editor...</div>
|
||||
<div x-show="!editorLoading">
|
||||
<div class="field">
|
||||
<label>Title</label>
|
||||
<label x-text="isArtistEditor() ? 'Artist name' : 'Title'"></label>
|
||||
<input x-model="editorDraft.title" />
|
||||
</div>
|
||||
|
||||
<div class="editor-grid" x-show="isReleaseEditor()">
|
||||
<div class="field">
|
||||
<label>Primary Relation Search</label>
|
||||
<input placeholder="Start typing to attach artist, release, or playlist" />
|
||||
<label>Release type</label>
|
||||
<select x-model="editorDraft.release_type">
|
||||
<option value="album">Album</option>
|
||||
<option value="single">Single</option>
|
||||
<option value="ep">EP</option>
|
||||
<option value="compilation">Compilation</option>
|
||||
<option value="soundtrack">Soundtrack</option>
|
||||
<option value="live">Live</option>
|
||||
<option value="remix">Remix</option>
|
||||
<option value="unknown">Unknown</option>
|
||||
</select>
|
||||
</div>
|
||||
<div class="field">
|
||||
<label>Year</label>
|
||||
<input type="number" min="0" max="3000" x-model="editorDraft.year" />
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="field" x-show="isReleaseEditor()">
|
||||
<label>Release artists</label>
|
||||
<div class="artist-tags">
|
||||
<template x-for="artist in selectedEditorArtists()" :key="artist.id">
|
||||
<span class="tag relation">
|
||||
<span x-text="artist.name"></span>
|
||||
<button type="button" @click="removeEditorArtist(artist.id)">x</button>
|
||||
</span>
|
||||
</template>
|
||||
<span class="muted" x-show="selectedEditorArtists().length === 0">No artists attached</span>
|
||||
</div>
|
||||
<div class="artist-picker">
|
||||
<input class="search" placeholder="Search artist" x-model="editorArtistToAdd" @keydown.enter.prevent="addEditorArtist()" @keydown.escape="editorArtistToAdd = ''" />
|
||||
<div class="artist-results" x-show="editorArtistSearchOpen()" x-transition>
|
||||
<template x-for="artist in filteredEditorArtists()" :key="artist.id">
|
||||
<button class="artist-result" type="button" @click="addEditorArtist(artist)" x-text="artist.name"></button>
|
||||
</template>
|
||||
<div class="artist-result muted" x-show="filteredEditorArtists().length === 0">No matching artists</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="field">
|
||||
<label>Visibility</label>
|
||||
<select class="search" style="width:100%" x-model="editorDraft.hidden">
|
||||
@@ -1714,17 +1976,66 @@ tbody tr:hover {
|
||||
<option value="true">Hidden from player</option>
|
||||
</select>
|
||||
</div>
|
||||
<div class="toolbar">
|
||||
<button class="btn primary" @click="saveLibraryItem()">
|
||||
<i data-lucide="save"></i>
|
||||
Save
|
||||
|
||||
<div x-show="canEditLibraryImage()">
|
||||
<label class="muted" style="display:block; margin: 2px 0 8px; font-size: 11px; font-weight: 800; text-transform: uppercase;">Image</label>
|
||||
<div class="image-editor">
|
||||
<div class="image-preview">
|
||||
<template x-if="editorDetail && editorDetail.current_image_url">
|
||||
<img :src="editorDetail.current_image_url" alt="" />
|
||||
</template>
|
||||
<span x-show="!editorDetail || !editorDetail.current_image_url">No image</span>
|
||||
</div>
|
||||
<div>
|
||||
<div class="image-actions">
|
||||
<input type="file" accept="image/*" x-ref="libraryImageInput" style="display:none" @change="setEditorImageFile($event)" />
|
||||
<button class="btn" type="button" @click="$refs.libraryImageInput.click()">
|
||||
<i data-lucide="image-plus"></i>
|
||||
Choose image
|
||||
</button>
|
||||
<button class="btn danger" @click="deleteLibraryItem(activeLibraryItem)">
|
||||
<button class="btn primary" type="button" @click="uploadLibraryImage()" :disabled="!editorImageFile || editorImageUploading">
|
||||
<i :data-lucide="editorImageUploading ? 'loader-circle' : 'upload'"></i>
|
||||
<span x-text="editorImageUploading ? 'Uploading...' : 'Upload'"></span>
|
||||
</button>
|
||||
<button class="btn danger" type="button" @click="removeLibraryImage()" :disabled="!editorDetail || !editorDetail.current_image_url || editorImageUploading">
|
||||
<i data-lucide="trash-2"></i>
|
||||
Remove
|
||||
</button>
|
||||
<span class="file-name" x-show="editorImageFile" x-text="editorImageFile ? editorImageFile.name : ''"></span>
|
||||
</div>
|
||||
<p class="muted" x-show="isReleaseEditor()">Release covers are uploaded manually here.</p>
|
||||
<p class="muted" x-show="isArtistEditor()">Pick an image from releases where this artist appears, or upload one manually.</p>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div x-show="isArtistEditor()">
|
||||
<div class="field" style="margin-bottom:8px">
|
||||
<label>Available release images</label>
|
||||
</div>
|
||||
<div class="cover-grid" x-show="editorDetail && editorDetail.available_covers && editorDetail.available_covers.length">
|
||||
<template x-for="cover in editorDetail.available_covers" :key="cover.media_file_id">
|
||||
<button class="cover-option" type="button" :class="{active: editorDetail.current_image_url && editorDetail.current_image_url.includes('/cover/' + cover.media_file_id + '/')}" @click="setLibraryImage(cover.media_file_id)">
|
||||
<img :src="cover.cover_url" alt="" />
|
||||
<span x-text="cover.release_title"></span>
|
||||
</button>
|
||||
</template>
|
||||
</div>
|
||||
<div class="empty" x-show="editorDetail && (!editorDetail.available_covers || editorDetail.available_covers.length === 0)">No release images found for this artist</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="toolbar">
|
||||
<button class="btn primary" @click="saveLibraryItem()" :disabled="!editorCanSave()">
|
||||
<i :data-lucide="editorSaving ? 'loader-circle' : 'save'"></i>
|
||||
<span x-text="editorSaving ? 'Saving...' : 'Save'"></span>
|
||||
</button>
|
||||
<button class="btn danger" @click="deleteLibraryItem(activeLibraryItem)" :disabled="editorSaving || editorImageUploading">
|
||||
<i data-lucide="trash-2"></i>
|
||||
Delete
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</section>
|
||||
</div>
|
||||
|
||||
@@ -1751,6 +2062,17 @@ function adminV2() {
|
||||
selectedReviewIds: {},
|
||||
reviewSelectionScope: 'ids',
|
||||
activeReview: null,
|
||||
reviewDraft: {
|
||||
title: '',
|
||||
artist: '',
|
||||
album: '',
|
||||
year: '',
|
||||
track_number: '',
|
||||
genre: '',
|
||||
featured_artists: '',
|
||||
release_type: 'album',
|
||||
notes: ''
|
||||
},
|
||||
reviewModalOpen: false,
|
||||
reviewStatuses: [
|
||||
{ value: null, label: 'All' },
|
||||
@@ -1772,8 +2094,14 @@ function adminV2() {
|
||||
librarySelectionScope: 'ids',
|
||||
activeLibraryItem: null,
|
||||
editorOpen: false,
|
||||
editorDraft: { title: '', hidden: 'false' },
|
||||
settings: { values: {}, sources: {}, lastfm_api_key_configured: false },
|
||||
editorLoading: false,
|
||||
editorSaving: false,
|
||||
editorImageUploading: false,
|
||||
editorImageFile: null,
|
||||
editorArtistToAdd: '',
|
||||
editorDetail: null,
|
||||
editorDraft: { title: '', hidden: 'false', release_type: 'album', year: '', artist_ids: [] },
|
||||
settings: { values: {}, sources: {}, lastfm_api_key_configured: false, lastfm_shared_secret_configured: false, lastfm_scrobbling_configured: false },
|
||||
settingsDraft: {
|
||||
auth_password_enabled: false,
|
||||
auth_sso_enabled: false,
|
||||
@@ -1785,6 +2113,7 @@ function adminV2() {
|
||||
oidc_user_groups: '',
|
||||
swagger_enabled: false,
|
||||
lastfm_api_key: '',
|
||||
lastfm_shared_secret: '',
|
||||
agent_enabled: false,
|
||||
agent_inbox_dir: '',
|
||||
agent_storage_dir: '',
|
||||
@@ -1859,14 +2188,18 @@ function adminV2() {
|
||||
const parts = raw.split('/').filter(Boolean);
|
||||
const view = parts[0] || 'reviews';
|
||||
if (view === 'reviews') {
|
||||
const nextStatus = parts[1] || null;
|
||||
if (this.reviewFilter.status !== nextStatus) this.clearReviewSelection();
|
||||
this.activeView = 'reviews';
|
||||
this.reviewFilter.status = parts[1] || null;
|
||||
this.reviewFilter.status = nextStatus;
|
||||
} else if (view === 'jobs') {
|
||||
this.activeView = 'jobs';
|
||||
if (parts[1]) this.activeJobName = decodeURIComponent(parts[1]);
|
||||
} else if (view === 'library') {
|
||||
const nextKind = ['artists', 'releases', 'playlists'].includes(parts[1]) ? parts[1] : 'artists';
|
||||
if (this.libraryKind !== nextKind) this.clearLibrarySelection();
|
||||
this.activeView = 'library';
|
||||
this.libraryKind = ['artists', 'releases', 'playlists'].includes(parts[1]) ? parts[1] : 'artists';
|
||||
this.libraryKind = nextKind;
|
||||
} else if (view === 'settings') {
|
||||
this.activeView = 'settings';
|
||||
} else if (view === 'tools') {
|
||||
@@ -1906,6 +2239,7 @@ function adminV2() {
|
||||
},
|
||||
|
||||
openReviews(status = null) {
|
||||
if (this.reviewFilter.status !== status) this.clearReviewSelection();
|
||||
this.activeView = 'reviews';
|
||||
this.reviewFilter.status = status;
|
||||
this.setRoute(status ? `#reviews/${status}` : '#reviews');
|
||||
@@ -1922,7 +2256,9 @@ function adminV2() {
|
||||
|
||||
openLibrary(kind = this.libraryKind) {
|
||||
this.activeView = 'library';
|
||||
this.libraryKind = ['artists', 'releases', 'playlists'].includes(kind) ? kind : 'artists';
|
||||
const nextKind = ['artists', 'releases', 'playlists'].includes(kind) ? kind : 'artists';
|
||||
if (this.libraryKind !== nextKind) this.clearLibrarySelection();
|
||||
this.libraryKind = nextKind;
|
||||
this.setRoute(`#library/${this.libraryKind}`);
|
||||
this.loadLibrary();
|
||||
},
|
||||
@@ -1941,7 +2277,7 @@ function adminV2() {
|
||||
params.set('offset', this.reviews.offset || 0);
|
||||
try {
|
||||
this.reviews = await this.request(`${this.apiBase}/reviews?${params.toString()}`);
|
||||
this.clearReviewSelection();
|
||||
if (resetOffset) this.clearReviewSelection();
|
||||
} catch (error) {
|
||||
this.showToast(error.message);
|
||||
} finally {
|
||||
@@ -1972,7 +2308,7 @@ function adminV2() {
|
||||
if (this.librarySearch) params.set('search', this.librarySearch);
|
||||
try {
|
||||
this.library = await this.request(`${this.apiBase}/library?${params.toString()}`);
|
||||
this.clearLibrarySelection();
|
||||
if (resetOffset) this.clearLibrarySelection();
|
||||
} catch (error) {
|
||||
this.showToast(error.message);
|
||||
} finally {
|
||||
@@ -2072,6 +2408,17 @@ function adminV2() {
|
||||
|
||||
openReview(row) {
|
||||
this.activeReview = row;
|
||||
this.reviewDraft = Object.assign({
|
||||
title: '',
|
||||
artist: '',
|
||||
album: '',
|
||||
year: '',
|
||||
track_number: '',
|
||||
genre: '',
|
||||
featured_artists: '',
|
||||
release_type: 'album',
|
||||
notes: ''
|
||||
}, row.normalized || {});
|
||||
this.activeRunDetail = null;
|
||||
this.reviewModalOpen = true;
|
||||
},
|
||||
@@ -2152,6 +2499,7 @@ function adminV2() {
|
||||
body: JSON.stringify(payload)
|
||||
});
|
||||
this.showToast(`${result.affected} review row(s) updated`);
|
||||
this.clearReviewSelection();
|
||||
await this.loadReviews(false);
|
||||
} catch (error) {
|
||||
this.showToast(error.message);
|
||||
@@ -2165,6 +2513,23 @@ function adminV2() {
|
||||
this.reviewModalOpen = false;
|
||||
},
|
||||
|
||||
async approveActiveReview() {
|
||||
if (!this.activeReview) return;
|
||||
try {
|
||||
await this.request(`${this.apiBase}/reviews/${this.activeReview.id}/approve`, {
|
||||
method: 'POST',
|
||||
body: JSON.stringify(this.reviewDraft)
|
||||
});
|
||||
this.showToast('Review approved');
|
||||
this.reviewModalOpen = false;
|
||||
this.activeReview = null;
|
||||
await this.loadReviews(false);
|
||||
await this.loadLibrary(false);
|
||||
} catch (error) {
|
||||
this.showToast(error.message);
|
||||
}
|
||||
},
|
||||
|
||||
async runJob(job) {
|
||||
job.launching = true;
|
||||
try {
|
||||
@@ -2250,9 +2615,184 @@ function adminV2() {
|
||||
this.activeLibraryItem = item;
|
||||
this.editorDraft = {
|
||||
title: item.title || '',
|
||||
hidden: item.is_hidden ? 'true' : 'false'
|
||||
hidden: item.is_hidden ? 'true' : 'false',
|
||||
release_type: 'album',
|
||||
year: '',
|
||||
artist_ids: []
|
||||
};
|
||||
this.editorDetail = null;
|
||||
this.editorImageFile = null;
|
||||
this.editorArtistToAdd = '';
|
||||
this.editorOpen = true;
|
||||
this.loadEditorDetail(item);
|
||||
},
|
||||
|
||||
async loadEditorDetail(item) {
|
||||
const key = `${item.kind}:${item.id}`;
|
||||
this.editorLoading = true;
|
||||
try {
|
||||
const params = new URLSearchParams({ kind: item.kind, id: item.id });
|
||||
const detail = await this.request(`${this.apiBase}/library/item/detail?${params.toString()}`);
|
||||
if (!this.activeLibraryItem || `${this.activeLibraryItem.kind}:${this.activeLibraryItem.id}` !== key) return;
|
||||
this.editorDetail = detail;
|
||||
this.editorDraft = {
|
||||
title: detail.title || '',
|
||||
hidden: detail.hidden ? 'true' : 'false',
|
||||
release_type: detail.release_type || 'album',
|
||||
year: detail.year || '',
|
||||
artist_ids: Array.isArray(detail.selected_artist_ids) ? detail.selected_artist_ids.slice() : []
|
||||
};
|
||||
this.editorImageFile = null;
|
||||
this.editorArtistToAdd = '';
|
||||
} catch (error) {
|
||||
this.showToast(error.message);
|
||||
} finally {
|
||||
if (this.activeLibraryItem && `${this.activeLibraryItem.kind}:${this.activeLibraryItem.id}` === key) {
|
||||
this.editorLoading = false;
|
||||
}
|
||||
this.icons();
|
||||
}
|
||||
},
|
||||
|
||||
isArtistEditor() {
|
||||
return this.activeLibraryItem && this.activeLibraryItem.kind === 'artists';
|
||||
},
|
||||
|
||||
isReleaseEditor() {
|
||||
return this.activeLibraryItem && this.activeLibraryItem.kind === 'releases';
|
||||
},
|
||||
|
||||
canEditLibraryImage() {
|
||||
return this.isArtistEditor() || this.isReleaseEditor();
|
||||
},
|
||||
|
||||
editorCanSave() {
|
||||
return Boolean(this.activeLibraryItem && this.editorDetail && !this.editorLoading && !this.editorSaving);
|
||||
},
|
||||
|
||||
selectedEditorArtists() {
|
||||
const selected = this.editorDraft.artist_ids || [];
|
||||
const artists = (this.editorDetail && this.editorDetail.artists) || [];
|
||||
return selected.map(id => {
|
||||
const artist = artists.find(row => Number(row.id) === Number(id));
|
||||
return artist || { id, name: `Artist #${id}` };
|
||||
});
|
||||
},
|
||||
|
||||
editorAvailableArtists() {
|
||||
const selected = new Set((this.editorDraft.artist_ids || []).map(id => Number(id)));
|
||||
const artists = (this.editorDetail && this.editorDetail.artists) || [];
|
||||
return artists.filter(artist => !selected.has(Number(artist.id)));
|
||||
},
|
||||
|
||||
normalizedArtistSearch(value) {
|
||||
return String(value || '').trim().toLowerCase();
|
||||
},
|
||||
|
||||
filteredEditorArtists() {
|
||||
const raw = String(this.editorArtistToAdd || '').trim();
|
||||
const query = this.normalizedArtistSearch(raw);
|
||||
const candidates = this.editorAvailableArtists();
|
||||
if (!query) return candidates.slice(0, 12);
|
||||
return candidates
|
||||
.map(artist => {
|
||||
const name = this.normalizedArtistSearch(artist.name);
|
||||
let score = 3;
|
||||
if (name === query) score = 0;
|
||||
else if (name.startsWith(query)) score = 1;
|
||||
else if (name.includes(query)) score = 2;
|
||||
return { artist, score };
|
||||
})
|
||||
.filter(row => row.score < 3)
|
||||
.sort((a, b) => a.score - b.score || a.artist.name.localeCompare(b.artist.name))
|
||||
.slice(0, 12)
|
||||
.map(row => row.artist);
|
||||
},
|
||||
|
||||
editorArtistSearchOpen() {
|
||||
return this.isReleaseEditor() && String(this.editorArtistToAdd || '').trim().length > 0;
|
||||
},
|
||||
|
||||
addEditorArtist(artist = null) {
|
||||
const raw = String(this.editorArtistToAdd || '').trim();
|
||||
const candidates = this.filteredEditorArtists();
|
||||
artist = artist
|
||||
|| candidates.find(row => this.normalizedArtistSearch(row.name) === this.normalizedArtistSearch(raw))
|
||||
|| candidates[0];
|
||||
if (artist && !(this.editorDraft.artist_ids || []).map(Number).includes(Number(artist.id))) {
|
||||
this.editorDraft.artist_ids = (this.editorDraft.artist_ids || []).concat([Number(artist.id)]);
|
||||
}
|
||||
this.editorArtistToAdd = '';
|
||||
},
|
||||
|
||||
removeEditorArtist(id) {
|
||||
this.editorDraft.artist_ids = (this.editorDraft.artist_ids || []).filter(value => Number(value) !== Number(id));
|
||||
},
|
||||
|
||||
setEditorImageFile(event) {
|
||||
this.editorImageFile = event.target.files && event.target.files.length ? event.target.files[0] : null;
|
||||
},
|
||||
|
||||
readFileAsDataUrl(file) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const reader = new FileReader();
|
||||
reader.onload = () => resolve(reader.result);
|
||||
reader.onerror = () => reject(reader.error || new Error('failed to read file'));
|
||||
reader.readAsDataURL(file);
|
||||
});
|
||||
},
|
||||
|
||||
async uploadLibraryImage() {
|
||||
if (!this.activeLibraryItem || !this.editorImageFile || this.editorImageUploading) return;
|
||||
this.editorImageUploading = true;
|
||||
try {
|
||||
const dataUrl = await this.readFileAsDataUrl(this.editorImageFile);
|
||||
const data = String(dataUrl).split(',')[1] || '';
|
||||
await this.request(`${this.apiBase}/library/item/upload-image`, {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({
|
||||
kind: this.activeLibraryItem.kind,
|
||||
id: this.activeLibraryItem.id,
|
||||
filename: this.editorImageFile.name,
|
||||
mime_type: this.editorImageFile.type || 'application/octet-stream',
|
||||
data
|
||||
})
|
||||
});
|
||||
await this.loadEditorDetail(this.activeLibraryItem);
|
||||
this.showToast('Image uploaded');
|
||||
} catch (error) {
|
||||
this.showToast(error.message);
|
||||
} finally {
|
||||
this.editorImageUploading = false;
|
||||
if (this.$refs.libraryImageInput) this.$refs.libraryImageInput.value = '';
|
||||
this.icons();
|
||||
}
|
||||
},
|
||||
|
||||
async setLibraryImage(mediaFileId) {
|
||||
if (!this.activeLibraryItem || this.editorImageUploading) return;
|
||||
this.editorImageUploading = true;
|
||||
try {
|
||||
await this.request(`${this.apiBase}/library/item/image`, {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({
|
||||
kind: this.activeLibraryItem.kind,
|
||||
id: this.activeLibraryItem.id,
|
||||
media_file_id: mediaFileId
|
||||
})
|
||||
});
|
||||
await this.loadEditorDetail(this.activeLibraryItem);
|
||||
this.showToast(mediaFileId ? 'Image selected' : 'Image removed');
|
||||
} catch (error) {
|
||||
this.showToast(error.message);
|
||||
} finally {
|
||||
this.editorImageUploading = false;
|
||||
this.icons();
|
||||
}
|
||||
},
|
||||
|
||||
removeLibraryImage() {
|
||||
this.setLibraryImage(null);
|
||||
},
|
||||
|
||||
toggleLibrary(item) {
|
||||
@@ -2269,14 +2809,18 @@ function adminV2() {
|
||||
|
||||
selectedLibraryCount() {
|
||||
if (this.librarySelectionScope === 'filter') return this.library.total || 0;
|
||||
return Object.keys(this.selectedLibraryIds).length;
|
||||
return this.currentLibrarySelectionKeys().length;
|
||||
},
|
||||
|
||||
currentLibrarySelectionKeys() {
|
||||
return Object.keys(this.selectedLibraryIds).filter(key => key.startsWith(`${this.libraryKind}:`));
|
||||
},
|
||||
|
||||
async bulkLibrary(action) {
|
||||
const count = this.selectedLibraryCount();
|
||||
if (!count) return;
|
||||
if (action === 'delete' && !confirm(`Delete ${count} ${this.libraryKind}?`)) return;
|
||||
const ids = Object.keys(this.selectedLibraryIds)
|
||||
const ids = this.currentLibrarySelectionKeys()
|
||||
.map(key => Number(key.split(':')[1]))
|
||||
.filter(Boolean);
|
||||
try {
|
||||
@@ -2291,6 +2835,7 @@ function adminV2() {
|
||||
})
|
||||
});
|
||||
this.showToast(`${result.affected} ${this.libraryKind} updated`);
|
||||
this.clearLibrarySelection();
|
||||
await this.loadLibrary(false);
|
||||
await this.refreshCountsOnly();
|
||||
} catch (error) {
|
||||
@@ -2299,7 +2844,8 @@ function adminV2() {
|
||||
},
|
||||
|
||||
async saveLibraryItem() {
|
||||
if (!this.activeLibraryItem) return;
|
||||
if (!this.editorCanSave()) return;
|
||||
this.editorSaving = true;
|
||||
try {
|
||||
const updated = await this.request(`${this.apiBase}/library/item`, {
|
||||
method: 'POST',
|
||||
@@ -2307,16 +2853,22 @@ function adminV2() {
|
||||
kind: this.activeLibraryItem.kind,
|
||||
id: this.activeLibraryItem.id,
|
||||
title: this.editorDraft.title,
|
||||
hidden: this.editorDraft.hidden === 'true'
|
||||
hidden: this.editorDraft.hidden === 'true',
|
||||
release_type: this.editorDraft.release_type || null,
|
||||
year: this.editorDraft.year || '',
|
||||
artist_ids: this.editorDraft.artist_ids || []
|
||||
})
|
||||
});
|
||||
this.replaceLibraryItem(updated);
|
||||
this.activeLibraryItem = updated;
|
||||
this.editorOpen = false;
|
||||
if (this.editorDetail) this.editorDetail.item = updated;
|
||||
this.showToast('Saved');
|
||||
await this.refreshCountsOnly();
|
||||
} catch (error) {
|
||||
this.showToast(error.message);
|
||||
} finally {
|
||||
this.editorSaving = false;
|
||||
this.icons();
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
@@ -11,7 +11,32 @@
|
||||
</svg>
|
||||
</button>
|
||||
</div>
|
||||
<pre class="info-modal-body" x-text="$store.info.modal.body"></pre>
|
||||
<div class="info-modal-body">
|
||||
<template x-if="$store.info.modal.rows && $store.info.modal.rows.length">
|
||||
<table class="info-table">
|
||||
<tbody>
|
||||
<template x-for="(row, idx) in $store.info.modal.rows" :key="row.label + '-' + idx">
|
||||
<tr>
|
||||
<th x-text="row.label"></th>
|
||||
<td>
|
||||
<template x-if="row.links && row.links.length">
|
||||
<div class="info-link-list">
|
||||
<template x-for="link in row.links" :key="link.type + '-' + link.id + '-' + link.label">
|
||||
<button class="info-link" type="button" @click="$store.info.navigate(link)" x-text="link.label"></button>
|
||||
</template>
|
||||
</div>
|
||||
</template>
|
||||
<template x-if="!row.links || !row.links.length">
|
||||
<span x-text="row.value"></span>
|
||||
</template>
|
||||
</td>
|
||||
</tr>
|
||||
</template>
|
||||
</tbody>
|
||||
</table>
|
||||
</template>
|
||||
<pre class="info-modal-plain" x-show="!$store.info.modal.rows || !$store.info.modal.rows.length" x-text="$store.info.modal.body"></pre>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
@@ -87,6 +112,21 @@
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="torrent-tabs">
|
||||
<button class="torrent-tab-btn"
|
||||
:class="{ active: $store.torrents.activeTab === 'import' }"
|
||||
@click="$store.torrents.showImportTab()">Import</button>
|
||||
<button class="torrent-tab-btn"
|
||||
:class="{ active: $store.torrents.activeTab === 'uploads' }"
|
||||
@click="$store.torrents.showUploadsTab()">
|
||||
<span>My uploads</span>
|
||||
<span class="torrent-tab-count"
|
||||
x-show="$store.torrents.uploadPendingTotal + $store.torrents.uploadQueuedTotal > 0"
|
||||
x-text="$store.torrents.uploadPendingTotal + $store.torrents.uploadQueuedTotal"></span>
|
||||
</button>
|
||||
</div>
|
||||
|
||||
<template x-if="$store.torrents.activeTab === 'import'">
|
||||
<div class="torrent-manager-layout">
|
||||
<aside class="torrent-manager-sidebar">
|
||||
<div class="torrent-manager-title">
|
||||
@@ -294,6 +334,272 @@
|
||||
</template>
|
||||
</section>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<template x-if="$store.torrents.activeTab === 'uploads'">
|
||||
<section class="upload-manager-panel">
|
||||
<div class="upload-manager-head">
|
||||
<div>
|
||||
<h4>My uploaded tracks</h4>
|
||||
<p x-text="$store.torrents.uploadSummary()"></p>
|
||||
</div>
|
||||
<button class="modal-btn modal-btn-ghost"
|
||||
@click="$store.torrents.loadUploads()"
|
||||
:disabled="$store.torrents.uploadHasEditorOpen()">{{ t.player_refresh }}</button>
|
||||
</div>
|
||||
|
||||
<template x-if="$store.torrents.uploadLoaded && $store.torrents.uploadTracks.length === 0 && $store.torrents.uploadPending.length === 0 && $store.torrents.uploadQueued.length === 0">
|
||||
<div class="empty-state torrent-workspace-empty">
|
||||
<p>No uploaded tracks yet</p>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<div class="upload-manager-grid">
|
||||
<aside class="upload-review-column">
|
||||
<div class="upload-panel-card">
|
||||
<div class="upload-panel-title">Needs approval</div>
|
||||
<p class="upload-panel-subtitle" x-text="$store.torrents.uploadPendingTotal + ' pending or failed'"></p>
|
||||
<template x-if="$store.torrents.uploadPending.length === 0">
|
||||
<div class="upload-mini-empty">No tracks need approval</div>
|
||||
</template>
|
||||
<div class="upload-review-list">
|
||||
<template x-for="item in $store.torrents.uploadPending" :key="item.id">
|
||||
<button class="upload-review-row" :class="{ active: $store.torrents.uploadReviewEditId === item.id, failed: item.status === 'failed' }" @click="$store.torrents.editUploadReview(item)">
|
||||
<span class="torrent-status-badge" :class="'status-' + item.status" x-text="item.status"></span>
|
||||
<span class="upload-review-name" x-text="item.filename"></span>
|
||||
<span class="upload-review-error" x-show="item.error_message" x-text="item.error_message"></span>
|
||||
</button>
|
||||
</template>
|
||||
</div>
|
||||
</div>
|
||||
<template x-if="$store.torrents.uploadQueuedTotal > 0">
|
||||
<div class="upload-panel-card upload-queue-panel">
|
||||
<div class="upload-panel-title">Queued / processing</div>
|
||||
<template x-for="item in $store.torrents.compactQueuedUploads()" :key="item.id">
|
||||
<div class="upload-queue-row">
|
||||
<span class="torrent-status-badge" :class="'status-' + item.status" x-text="item.status"></span>
|
||||
<span class="upload-queue-name" x-text="item.filename"></span>
|
||||
</div>
|
||||
</template>
|
||||
<div class="upload-mini-empty" x-show="$store.torrents.uploadQueuedTotal > $store.torrents.uploadQueued.length" x-text="'Showing ' + $store.torrents.uploadQueued.length + ' of ' + $store.torrents.uploadQueuedTotal"></div>
|
||||
</div>
|
||||
</template>
|
||||
</aside>
|
||||
<section class="upload-library-column">
|
||||
<div class="upload-bulk-bar" x-show="$store.torrents.uploadSelectedCount() > 0">
|
||||
<div class="upload-bulk-title" x-text="$store.torrents.uploadSelectedCount() + ' selected'"></div>
|
||||
<input type="text" placeholder="Artists" x-model="$store.torrents.uploadBulkDraft.artists">
|
||||
<input type="text" placeholder="Featured" x-model="$store.torrents.uploadBulkDraft.featured_artists">
|
||||
<input type="text" placeholder="Album" x-model="$store.torrents.uploadBulkDraft.release_title">
|
||||
<input type="number" placeholder="Year" x-model="$store.torrents.uploadBulkDraft.release_year">
|
||||
<select x-model="$store.torrents.uploadBulkDraft.release_type">
|
||||
<option value="">Type unchanged</option><option value="album">Album</option><option value="single">Single</option><option value="ep">EP</option><option value="compilation">Compilation</option><option value="mixtape">Mixtape</option><option value="live">Live</option><option value="soundtrack">Soundtrack</option><option value="remix">Remix</option><option value="demo">Demo</option>
|
||||
</select>
|
||||
<select x-model="$store.torrents.uploadBulkDraft.hidden">
|
||||
<option value="">Visibility unchanged</option><option value="false">Visible</option><option value="true">Hidden</option>
|
||||
</select>
|
||||
<button class="modal-btn modal-btn-primary" @click="$store.torrents.saveUploadBulkEdit()" :disabled="$store.torrents.uploadBulkSaving">Apply</button>
|
||||
<button class="modal-btn modal-btn-ghost" @click="$store.torrents.clearUploadSelection()">Clear</button>
|
||||
</div>
|
||||
<div class="upload-release-tree">
|
||||
<template x-for="release in $store.torrents.uploadReleases" :key="release.id">
|
||||
<div class="upload-release-node" :class="{ hidden: release.is_hidden }">
|
||||
<div class="upload-release-row">
|
||||
<button class="torrent-tree-check" :class="$store.torrents.uploadReleaseSelectionState(release)" @click="$store.torrents.toggleUploadReleaseSelection(release)">
|
||||
<template x-if="$store.torrents.uploadReleaseSelectionState(release) === 'checked'"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3"><polyline points="20 6 9 17 4 12"/></svg></template>
|
||||
<template x-if="$store.torrents.uploadReleaseSelectionState(release) === 'partial'"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3"><line x1="5" y1="12" x2="19" y2="12"/></svg></template>
|
||||
</button>
|
||||
<button class="torrent-tree-toggle" :class="{ expanded: $store.torrents.uploadReleaseExpanded(release.id) }" @click="$store.torrents.toggleUploadRelease(release.id)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="9 18 15 12 9 6"/></svg></button>
|
||||
<div class="upload-release-main">
|
||||
<div class="upload-release-title"><span x-text="release.title"></span><span class="upload-hidden-pill" x-show="release.is_hidden">hidden</span></div>
|
||||
<div class="upload-track-meta"><span x-text="$store.torrents.uploadReleaseArtistsText(release)"></span><span>-</span><span x-text="release.year || 'no year'"></span><span>-</span><span x-text="release.tracks.length + ' tracks'"></span></div>
|
||||
</div>
|
||||
<button class="modal-btn modal-btn-ghost" @click="$store.torrents.editUploadRelease(release)">Edit release</button>
|
||||
</div>
|
||||
<div class="upload-track-children" x-show="$store.torrents.uploadReleaseExpanded(release.id)">
|
||||
<template x-for="item in release.tracks" :key="item.track.id">
|
||||
<div class="upload-tree-track" :class="{ hidden: item.is_hidden, selected: $store.torrents.selectedUploadTracks.has(item.track.id) }">
|
||||
<button class="torrent-tree-check" :class="{ checked: $store.torrents.selectedUploadTracks.has(item.track.id) }" @click="$store.torrents.toggleUploadTrackSelection(item.track.id)">
|
||||
<template x-if="$store.torrents.selectedUploadTracks.has(item.track.id)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3"><polyline points="20 6 9 17 4 12"/></svg></template>
|
||||
</button>
|
||||
<button class="track-action-btn play-btn" @click="$store.player.play(item.track)" title="{{ t.player_play }}"><svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg></button>
|
||||
<div class="upload-track-main">
|
||||
<div class="upload-track-title"><span x-text="item.track.track_number ? item.track.track_number + '. ' + item.track.title : item.track.title"></span><span class="upload-hidden-pill" x-show="item.is_hidden">hidden</span></div>
|
||||
<div class="upload-track-meta"><span x-text="$store.torrents.uploadArtistsText(item)"></span><span x-show="$store.torrents.uploadFeaturedArtistsText(item)">feat.</span><span x-show="$store.torrents.uploadFeaturedArtistsText(item)" x-text="$store.torrents.uploadFeaturedArtistsText(item)"></span></div>
|
||||
</div>
|
||||
<div class="upload-track-actions">
|
||||
<button class="track-action-btn" @click="$store.queue.addNextInQueue([item.track])" title="{{ t.player_play_next }}"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h8M5 18h14"/><path d="M17 10l4 3-4 3" fill="currentColor" stroke="none"/></svg></button>
|
||||
<button class="modal-btn modal-btn-ghost" @click="$store.torrents.editUpload(item)">Edit</button>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
</div>
|
||||
</section>
|
||||
</div>
|
||||
|
||||
<template x-if="$store.torrents.uploadHasEditorOpen()">
|
||||
<div class="upload-editor-backdrop" @click.self="$store.torrents.closeUploadEditor()">
|
||||
<aside class="upload-editor-drawer">
|
||||
<div class="upload-editor-head">
|
||||
<div>
|
||||
<div class="upload-panel-title" x-text="$store.torrents.uploadEditorKicker()"></div>
|
||||
<h4 x-text="$store.torrents.uploadEditorTitle()"></h4>
|
||||
</div>
|
||||
<button class="track-action-btn" @click="$store.torrents.closeUploadEditor()" title="Close">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4">
|
||||
<path d="M18 6L6 18M6 6l12 12"/>
|
||||
</svg>
|
||||
</button>
|
||||
</div>
|
||||
|
||||
<template x-if="$store.torrents.uploadReviewDraft">
|
||||
<div class="upload-editor-form">
|
||||
<label class="upload-field upload-field-half"><span>Title</span><input type="text" x-model="$store.torrents.uploadReviewDraft.title"></label>
|
||||
<label class="upload-field upload-field-half"><span>Artist</span><input type="text" x-model="$store.torrents.uploadReviewDraft.artist"></label>
|
||||
<label class="upload-field upload-field-half"><span>Album</span><input type="text" x-model="$store.torrents.uploadReviewDraft.album"></label>
|
||||
<label class="upload-field upload-field-half"><span>Featured</span><input type="text" x-model="$store.torrents.uploadReviewDraft.featured_artists" placeholder="Artist, Artist"></label>
|
||||
<label class="upload-field upload-field-compact"><span>Year</span><input type="number" x-model="$store.torrents.uploadReviewDraft.year"></label>
|
||||
<label class="upload-field upload-field-compact"><span>Track #</span><input type="number" min="1" x-model="$store.torrents.uploadReviewDraft.track_number"></label>
|
||||
<label class="upload-field upload-field-compact"><span>Genre</span><input type="text" x-model="$store.torrents.uploadReviewDraft.genre"></label>
|
||||
<label class="upload-field upload-field-compact">
|
||||
<span>Type</span>
|
||||
<select x-model="$store.torrents.uploadReviewDraft.release_type">
|
||||
<option value="album">Album</option><option value="single">Single</option><option value="ep">EP</option><option value="compilation">Compilation</option><option value="mixtape">Mixtape</option><option value="live">Live</option><option value="soundtrack">Soundtrack</option><option value="remix">Remix</option><option value="demo">Demo</option>
|
||||
</select>
|
||||
</label>
|
||||
<label class="upload-field upload-field-wide"><span>Notes</span><textarea rows="4" x-model="$store.torrents.uploadReviewDraft.notes"></textarea></label>
|
||||
<div class="upload-editor-actions">
|
||||
<button class="modal-btn modal-btn-danger" @click="$store.torrents.deleteUploadReview()" :disabled="$store.torrents.uploadReviewSavingId === $store.torrents.uploadReviewEditId">Delete review</button>
|
||||
<button class="modal-btn modal-btn-primary" @click="$store.torrents.approveUploadReview()" :disabled="$store.torrents.uploadReviewSavingId === $store.torrents.uploadReviewEditId">Approve</button>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<template x-if="$store.torrents.uploadReleaseDraft">
|
||||
<div class="upload-editor-form">
|
||||
<label class="upload-field upload-field-wide"><span>Album</span><input type="text" x-model="$store.torrents.uploadReleaseDraft.title"></label>
|
||||
<label class="upload-field upload-field-wide"><span>Album artists</span><input type="text" x-model="$store.torrents.uploadReleaseDraft.artists"></label>
|
||||
<label class="upload-field upload-field-half"><span>Year</span><input type="number" x-model="$store.torrents.uploadReleaseDraft.year"></label>
|
||||
<label class="upload-field upload-field-half"><span>Type</span><select x-model="$store.torrents.uploadReleaseDraft.release_type"><option value="album">Album</option><option value="single">Single</option><option value="ep">EP</option><option value="compilation">Compilation</option><option value="mixtape">Mixtape</option><option value="live">Live</option><option value="soundtrack">Soundtrack</option><option value="remix">Remix</option><option value="demo">Demo</option></select></label>
|
||||
<label class="upload-field upload-field-toggle"><input type="checkbox" x-model="$store.torrents.uploadReleaseDraft.is_hidden"><span>Hidden</span></label>
|
||||
<div class="upload-editor-actions">
|
||||
<button class="modal-btn modal-btn-primary" @click="$store.torrents.saveUploadReleaseEdit()" :disabled="$store.torrents.uploadReleaseSavingId === $store.torrents.uploadReleaseEditId">Save release</button>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<template x-if="$store.torrents.uploadDraft">
|
||||
<div class="upload-editor-form">
|
||||
<label class="upload-field upload-field-wide"><span>Title</span><input type="text" x-model="$store.torrents.uploadDraft.title"></label>
|
||||
<label class="upload-field upload-field-half"><span>Artists</span><input type="text" x-model="$store.torrents.uploadDraft.artists"></label>
|
||||
<label class="upload-field upload-field-half"><span>Featured</span><input type="text" x-model="$store.torrents.uploadDraft.featured_artists"></label>
|
||||
<label class="upload-field upload-field-half"><span>Album</span><input type="text" x-model="$store.torrents.uploadDraft.release_title"></label>
|
||||
<label class="upload-field upload-field-half"><span>Type</span><select x-model="$store.torrents.uploadDraft.release_type"><option value="album">Album</option><option value="single">Single</option><option value="ep">EP</option><option value="compilation">Compilation</option><option value="mixtape">Mixtape</option><option value="live">Live</option><option value="soundtrack">Soundtrack</option><option value="remix">Remix</option><option value="demo">Demo</option></select></label>
|
||||
<label class="upload-field upload-field-compact"><span>Year</span><input type="number" x-model="$store.torrents.uploadDraft.release_year"></label>
|
||||
<label class="upload-field upload-field-compact"><span>Track #</span><input type="number" min="1" x-model="$store.torrents.uploadDraft.track_number"></label>
|
||||
<label class="upload-field upload-field-compact"><span>Disc #</span><input type="number" min="1" x-model="$store.torrents.uploadDraft.disc_number"></label>
|
||||
<label class="upload-field upload-field-toggle"><input type="checkbox" x-model="$store.torrents.uploadDraft.is_hidden"><span>Hidden</span></label>
|
||||
<div class="upload-editor-actions">
|
||||
<button class="modal-btn modal-btn-primary" @click="$store.torrents.saveUploadEdit()" :disabled="$store.torrents.uploadSavingId === $store.torrents.uploadEditId">Save track</button>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
</aside>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<div class="upload-track-list" x-show="false">
|
||||
<template x-for="item in $store.torrents.uploadTracks" :key="item.track.id">
|
||||
<div class="upload-track-card" :class="{ hidden: item.is_hidden }">
|
||||
<template x-if="$store.torrents.uploadEditId !== item.track.id">
|
||||
<div class="upload-track-display">
|
||||
<button class="track-action-btn play-btn"
|
||||
@click="$store.player.play(item.track)"
|
||||
title="{{ t.player_play }}">
|
||||
<svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
|
||||
</button>
|
||||
<div class="upload-track-main">
|
||||
<div class="upload-track-title">
|
||||
<span x-text="item.track.title"></span>
|
||||
<span class="upload-hidden-pill" x-show="item.is_hidden">hidden</span>
|
||||
</div>
|
||||
<div class="upload-track-meta">
|
||||
<span x-text="$store.torrents.uploadArtistsText(item)"></span>
|
||||
<span>·</span>
|
||||
<span x-text="item.track.release_title"></span>
|
||||
<span x-show="item.track.track_number">·</span>
|
||||
<span x-show="item.track.track_number" x-text="'#' + item.track.track_number"></span>
|
||||
</div>
|
||||
</div>
|
||||
<div class="upload-track-actions">
|
||||
<button class="track-action-btn" @click="$store.queue.addNextInQueue([item.track])" title="{{ t.player_play_next }}">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h8M5 18h14"/><path d="M17 10l4 3-4 3" fill="currentColor" stroke="none"/></svg>
|
||||
</button>
|
||||
<button class="modal-btn modal-btn-ghost" @click="$store.torrents.editUpload(item)">Edit</button>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<template x-if="$store.torrents.uploadEditId === item.track.id">
|
||||
<div class="upload-edit-form">
|
||||
<label>
|
||||
<span>Title</span>
|
||||
<input type="text" x-model="$store.torrents.uploadDraft.title">
|
||||
</label>
|
||||
<label>
|
||||
<span>Artists</span>
|
||||
<input type="text" x-model="$store.torrents.uploadDraft.artists" placeholder="Artist, Featured Artist">
|
||||
</label>
|
||||
<label>
|
||||
<span>Release</span>
|
||||
<input type="text" x-model="$store.torrents.uploadDraft.release_title">
|
||||
</label>
|
||||
<label>
|
||||
<span>Type</span>
|
||||
<select x-model="$store.torrents.uploadDraft.release_type">
|
||||
<option value="album">Album</option>
|
||||
<option value="single">Single</option>
|
||||
<option value="ep">EP</option>
|
||||
<option value="compilation">Compilation</option>
|
||||
<option value="mixtape">Mixtape</option>
|
||||
<option value="live">Live</option>
|
||||
<option value="soundtrack">Soundtrack</option>
|
||||
<option value="remix">Remix</option>
|
||||
<option value="demo">Demo</option>
|
||||
</select>
|
||||
</label>
|
||||
<label>
|
||||
<span>Year</span>
|
||||
<input type="number" x-model="$store.torrents.uploadDraft.release_year">
|
||||
</label>
|
||||
<label>
|
||||
<span>Track #</span>
|
||||
<input type="number" min="1" x-model="$store.torrents.uploadDraft.track_number">
|
||||
</label>
|
||||
<label>
|
||||
<span>Disc #</span>
|
||||
<input type="number" min="1" x-model="$store.torrents.uploadDraft.disc_number">
|
||||
</label>
|
||||
<label class="upload-hidden-toggle">
|
||||
<input type="checkbox" x-model="$store.torrents.uploadDraft.is_hidden">
|
||||
<span>Hidden</span>
|
||||
</label>
|
||||
<div class="upload-edit-actions">
|
||||
<button class="modal-btn modal-btn-primary"
|
||||
@click="$store.torrents.saveUploadEdit()"
|
||||
:disabled="$store.torrents.uploadSavingId === item.track.id">Save</button>
|
||||
<button class="modal-btn modal-btn-ghost" @click="$store.torrents.cancelUploadEdit()">Cancel</button>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
</div>
|
||||
</template>
|
||||
</div>
|
||||
</section>
|
||||
</template>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
+1537
-45
File diff suppressed because it is too large
Load Diff
+203
-16
@@ -38,6 +38,19 @@
|
||||
<span class="user-stat-label">{{ t.player_listened }}</span>
|
||||
</div>
|
||||
</div>
|
||||
<button class="lastfm-profile-action"
|
||||
:class="$store.user.lastfmClass()"
|
||||
:disabled="$store.user.lastfmBusy || !$store.user.lastfm?.configured"
|
||||
@click="$store.user.handleLastfm()"
|
||||
:title="$store.user.lastfmLabel()"
|
||||
:aria-label="$store.user.lastfmLabel()">
|
||||
<span class="lastfm-dot"></span>
|
||||
<span class="lastfm-profile-text">
|
||||
<span class="lastfm-profile-brand">{{ t.player_lastfm_profile }}</span>
|
||||
<span class="lastfm-profile-separator">·</span>
|
||||
<span class="lastfm-profile-status" x-text="$store.user.lastfmStatusLabel()"></span>
|
||||
</span>
|
||||
</button>
|
||||
</div>
|
||||
<div class="sidebar-header">
|
||||
<h2>{{ t.player_library }}</h2>
|
||||
@@ -268,6 +281,20 @@
|
||||
<path d="M4 4.5A2.5 2.5 0 016.5 2H20v20H6.5A2.5 2.5 0 014 19.5z"/>
|
||||
</svg>
|
||||
</button>
|
||||
<div class="connection-alert"
|
||||
x-show="$store.connection.disconnected"
|
||||
x-cloak
|
||||
:title="$store.connection.message()"
|
||||
role="status"
|
||||
aria-live="polite">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
||||
<path d="M2 8.82a15 15 0 0120 0"/>
|
||||
<path d="M5 12.86a10 10 0 0114 0"/>
|
||||
<path d="M8.5 16.43a5 5 0 017 0"/>
|
||||
<line x1="2" y1="2" x2="22" y2="22"/>
|
||||
</svg>
|
||||
<span class="connection-alert-text">{{ t.player_connection_lost }}</span>
|
||||
</div>
|
||||
<div class="search-bar">
|
||||
<span class="search-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg></span>
|
||||
<input id="search-input" type="text" placeholder="{{ t.player_search_placeholder }}"
|
||||
@@ -324,6 +351,19 @@
|
||||
<span class="user-stat-label">{{ t.player_listened }}</span>
|
||||
</div>
|
||||
</div>
|
||||
<button class="lastfm-profile-action"
|
||||
:class="$store.user.lastfmClass()"
|
||||
:disabled="$store.user.lastfmBusy || !$store.user.lastfm?.configured"
|
||||
@click="$store.user.handleLastfm()"
|
||||
:title="$store.user.lastfmLabel()"
|
||||
:aria-label="$store.user.lastfmLabel()">
|
||||
<span class="lastfm-dot"></span>
|
||||
<span class="lastfm-profile-text">
|
||||
<span class="lastfm-profile-brand">{{ t.player_lastfm_profile }}</span>
|
||||
<span class="lastfm-profile-separator">·</span>
|
||||
<span class="lastfm-profile-status" x-text="$store.user.lastfmStatusLabel()"></span>
|
||||
</span>
|
||||
</button>
|
||||
<button class="modal-btn modal-btn-primary mobile-account-logout"
|
||||
@click="$store.user.logout()">
|
||||
{{ t.player_log_out }}
|
||||
@@ -391,7 +431,7 @@
|
||||
<template x-if="!release.cover_url">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><rect x="3" y="3" width="18" height="18" rx="2"/><circle cx="12" cy="12" r="4"/></svg>
|
||||
</template>
|
||||
<button class="card-info-btn" @click.stop="$store.info.open('{{ t.player_release_info }}', $store.library.releaseInfo(release))" :title="$store.library.releaseInfo(release)" aria-label="{{ t.player_release_info }}">
|
||||
<button class="card-info-btn" @click.stop="$store.library.openReleaseInfo(release)" :title="$store.library.releaseInfo(release)" aria-label="{{ t.player_release_info }}">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
|
||||
</button>
|
||||
</div>
|
||||
@@ -434,8 +474,14 @@
|
||||
</div>
|
||||
<span></span>
|
||||
<div class="track-actions">
|
||||
<button class="track-action-btn info-btn" @click.stop="$store.info.open('{{ t.player_track_info }}', $store.library.trackInfo(track))" :title="$store.library.trackInfo(track)" aria-label="{{ t.player_track_info }}">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
|
||||
<button class="track-action-btn info-btn popularity-info-btn"
|
||||
:class="{ 'has-popularity': $store.library.hasPopularity(track), 'no-popularity': !$store.library.hasPopularity(track) }"
|
||||
:style="$store.library.popularityStyle(track)"
|
||||
@click.stop="$store.library.openTrackInfo(track)"
|
||||
:title="$store.library.trackInfoTitle(track)"
|
||||
aria-label="{{ t.player_track_info }}">
|
||||
<span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
|
||||
<span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
|
||||
</button>
|
||||
<button class="track-action-btn play-btn" @click.stop="$store.library.playSearchTrack(idx)" title="{{ t.player_play }}">
|
||||
<svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
|
||||
@@ -556,7 +602,7 @@
|
||||
<template x-if="!release.cover_url">
|
||||
<span class="placeholder-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><rect x="3" y="3" width="18" height="18" rx="2"/><circle cx="12" cy="12" r="4"/></svg></span>
|
||||
</template>
|
||||
<button class="card-info-btn" @click.stop="$store.info.open('{{ t.player_release_info }}', $store.library.releaseInfo(release))" :title="$store.library.releaseInfo(release)" aria-label="{{ t.player_release_info }}">
|
||||
<button class="card-info-btn" @click.stop="$store.library.openReleaseInfo(release)" :title="$store.library.releaseInfo(release)" aria-label="{{ t.player_release_info }}">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
|
||||
</button>
|
||||
<button class="card-enqueue-btn" @click.stop="$store.library.enqueueRelease(release.id)" title="{{ t.player_add_to_queue }}">
|
||||
@@ -608,8 +654,14 @@
|
||||
</div>
|
||||
<span></span>
|
||||
<div class="track-actions">
|
||||
<button class="track-action-btn info-btn" @click.stop="$store.info.open('{{ t.player_track_info }}', $store.library.trackInfo(track))" :title="$store.library.trackInfo(track)" aria-label="{{ t.player_track_info }}">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
|
||||
<button class="track-action-btn info-btn popularity-info-btn"
|
||||
:class="{ 'has-popularity': $store.library.hasPopularity(track), 'no-popularity': !$store.library.hasPopularity(track) }"
|
||||
:style="$store.library.popularityStyle(track)"
|
||||
@click.stop="$store.library.openTrackInfo(track)"
|
||||
:title="$store.library.trackInfoTitle(track)"
|
||||
aria-label="{{ t.player_track_info }}">
|
||||
<span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
|
||||
<span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
|
||||
</button>
|
||||
<button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentArtist.featured_tracks, idx)" title="{{ t.player_play }}">
|
||||
<svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
|
||||
@@ -678,7 +730,7 @@
|
||||
<div class="release-year" x-text="$store.library.currentRelease.year || ''"></div>
|
||||
<div class="release-actions">
|
||||
<button class="release-action-btn secondary"
|
||||
@click.stop="$store.info.open('{{ t.player_release_info }}', $store.library.releaseInfo($store.library.currentRelease))"
|
||||
@click.stop="$store.library.openReleaseInfo($store.library.currentRelease)"
|
||||
:title="$store.library.releaseInfo($store.library.currentRelease)"
|
||||
aria-label="{{ t.player_release_info }}">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
|
||||
@@ -710,7 +762,7 @@
|
||||
<template x-for="(track, idx) in $store.library.currentRelease.tracks" :key="track.id">
|
||||
<div class="track-row"
|
||||
:class="{ playing: $store.player.currentTrack && $store.player.currentTrack.id === track.id }"
|
||||
@dblclick="$store.queue.playRelease($store.library.currentRelease.tracks, idx)">
|
||||
@dblclick="$store.queue.playRelease([track], 0)">
|
||||
<span class="track-num" x-text="track.track_number || (idx + 1)"></span>
|
||||
<div class="track-info">
|
||||
<div class="track-title" x-text="track.title"></div>
|
||||
@@ -725,10 +777,16 @@
|
||||
</div>
|
||||
<span></span>
|
||||
<div class="track-actions">
|
||||
<button class="track-action-btn info-btn" @click.stop="$store.info.open('{{ t.player_track_info }}', $store.library.trackInfo(track))" :title="$store.library.trackInfo(track)" aria-label="{{ t.player_track_info }}">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
|
||||
<button class="track-action-btn info-btn popularity-info-btn"
|
||||
:class="{ 'has-popularity': $store.library.hasPopularity(track), 'no-popularity': !$store.library.hasPopularity(track) }"
|
||||
:style="$store.library.popularityStyle(track)"
|
||||
@click.stop="$store.library.openTrackInfo(track)"
|
||||
:title="$store.library.trackInfoTitle(track)"
|
||||
aria-label="{{ t.player_track_info }}">
|
||||
<span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
|
||||
<span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
|
||||
</button>
|
||||
<button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentRelease.tracks, idx)" title="{{ t.player_play }}">
|
||||
<button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease([track], 0)" title="{{ t.player_play }}">
|
||||
<svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
|
||||
</button>
|
||||
<button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
|
||||
@@ -795,8 +853,14 @@
|
||||
</div>
|
||||
<span></span>
|
||||
<div class="track-actions">
|
||||
<button class="track-action-btn info-btn" @click.stop="$store.info.open('{{ t.player_track_info }}', $store.library.trackInfo(track))" :title="$store.library.trackInfo(track)" aria-label="{{ t.player_track_info }}">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
|
||||
<button class="track-action-btn info-btn popularity-info-btn"
|
||||
:class="{ 'has-popularity': $store.library.hasPopularity(track), 'no-popularity': !$store.library.hasPopularity(track) }"
|
||||
:style="$store.library.popularityStyle(track)"
|
||||
@click.stop="$store.library.openTrackInfo(track)"
|
||||
:title="$store.library.trackInfoTitle(track)"
|
||||
aria-label="{{ t.player_track_info }}">
|
||||
<span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
|
||||
<span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
|
||||
</button>
|
||||
<button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentPlaylist.tracks, idx)" title="{{ t.player_play }}">
|
||||
<svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
|
||||
@@ -871,8 +935,14 @@
|
||||
</div>
|
||||
</div>
|
||||
<div class="queue-track-actions">
|
||||
<button class="queue-track-remove info-btn" @click.stop="$store.info.open('{{ t.player_track_info }}', $store.library.trackInfo(track))" :title="$store.library.trackInfo(track)" aria-label="{{ t.player_track_info }}">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" width="14" height="14"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
|
||||
<button class="queue-track-remove info-btn popularity-info-btn"
|
||||
:class="{ 'has-popularity': $store.library.hasPopularity(track), 'no-popularity': !$store.library.hasPopularity(track) }"
|
||||
:style="$store.library.popularityStyle(track)"
|
||||
@click.stop="$store.library.openTrackInfo(track)"
|
||||
:title="$store.library.trackInfoTitle(track)"
|
||||
aria-label="{{ t.player_track_info }}">
|
||||
<span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
|
||||
<span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
|
||||
</button>
|
||||
<button class="queue-track-remove" @click.stop="$store.queue.remove(idx)" title="{{ t.player_remove }}">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" width="14" height="14"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>
|
||||
@@ -898,7 +968,16 @@
|
||||
</template>
|
||||
</div>
|
||||
<div class="player-track-info">
|
||||
<div class="player-track-title-row">
|
||||
<div class="player-track-title" x-text="$store.player.currentTrack.title"></div>
|
||||
<button class="like-btn player-current-like"
|
||||
:class="{ liked: $store.likes.has($store.player.currentTrack.id) }"
|
||||
@click.stop="$store.likes.toggle($store.player.currentTrack.id)"
|
||||
title="{{ t.player_like }}"
|
||||
aria-label="{{ t.player_like }}">
|
||||
<svg viewBox="0 0 24 24" :fill="$store.likes.has($store.player.currentTrack.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
|
||||
</button>
|
||||
</div>
|
||||
<div class="player-track-artist">
|
||||
<template x-for="(artist, artistIdx) in $store.library.trackArtistLinks($store.player.currentTrack)" :key="artist.label + '-' + artist.id + '-' + artistIdx">
|
||||
<span>
|
||||
@@ -971,7 +1050,7 @@
|
||||
<div class="volume-slider"
|
||||
@pointerdown.prevent="$store.player.startVolumeDrag($event)"
|
||||
aria-label="{{ t.player_volume }}">
|
||||
<div class="volume-slider-fill" :style="'width:' + ($store.player.volume * 100) + '%'">
|
||||
<div class="volume-slider-fill" :style="'width:' + $store.player.volumeSliderPercent() + '%'">
|
||||
<div class="volume-slider-thumb"></div>
|
||||
</div>
|
||||
</div>
|
||||
@@ -979,5 +1058,113 @@
|
||||
<button class="queue-toggle-btn" :class="{ active: $store.queue.visible }" @click="$store.queue.visible = !$store.queue.visible" title="{{ t.player_queue }}">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="8" y1="6" x2="21" y2="6"/><line x1="8" y1="12" x2="21" y2="12"/><line x1="8" y1="18" x2="21" y2="18"/><line x1="3" y1="6" x2="3.01" y2="6"/><line x1="3" y1="12" x2="3.01" y2="12"/><line x1="3" y1="18" x2="3.01" y2="18"/></svg>
|
||||
</button>
|
||||
<div class="device-picker" @click.outside="$store.devices.open = false">
|
||||
<button class="queue-toggle-btn device-toggle-btn"
|
||||
:class="{ active: $store.devices.isActive() }"
|
||||
@click="$store.devices.toggle()"
|
||||
:title="$store.devices.activeLabel()"
|
||||
aria-label="Devices">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
||||
<rect x="3" y="4" width="18" height="12" rx="2"/>
|
||||
<path d="M8 20h8"/>
|
||||
<path d="M12 16v4"/>
|
||||
</svg>
|
||||
</button>
|
||||
<div class="device-popover" x-show="$store.devices.open" x-transition x-cloak>
|
||||
<template x-for="device in $store.devices.devices" :key="device.id">
|
||||
<button class="device-row"
|
||||
:class="{ active: device.is_active, 'current-device': device.is_current }"
|
||||
@click="$store.devices.select(device.id)">
|
||||
<span class="device-row-icon">
|
||||
<template x-if="device.kind === 'phone'">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
||||
<rect x="7" y="2" width="10" height="20" rx="2"/>
|
||||
<path d="M11 18h2"/>
|
||||
</svg>
|
||||
</template>
|
||||
<template x-if="device.kind !== 'phone'">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
||||
<rect x="3" y="4" width="18" height="12" rx="2"/>
|
||||
<path d="M8 20h8"/>
|
||||
<path d="M12 16v4"/>
|
||||
</svg>
|
||||
</template>
|
||||
</span>
|
||||
<span class="device-row-main">
|
||||
<span class="device-row-name" x-text="device.name"></span>
|
||||
<span class="device-row-current" x-show="device.is_current">This device</span>
|
||||
</span>
|
||||
<span class="device-row-check" x-show="device.is_active">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4">
|
||||
<polyline points="20 6 9 17 4 12"/>
|
||||
</svg>
|
||||
</span>
|
||||
</button>
|
||||
</template>
|
||||
<template x-if="$store.devices.jams.length > 0">
|
||||
<div class="device-section-label jam-section-label">Jams</div>
|
||||
</template>
|
||||
<template x-for="jam in $store.devices.jams" :key="jam.id">
|
||||
<button class="device-row jam-row"
|
||||
:class="{ active: jam.is_active, pending: jam.is_pending }"
|
||||
@click="$store.devices.selectJam(jam)">
|
||||
<span class="device-row-icon">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
||||
<circle cx="8" cy="8" r="3"/>
|
||||
<circle cx="16" cy="8" r="3"/>
|
||||
<path d="M4 20v-1a4 4 0 014-4h0a4 4 0 014 4v1"/>
|
||||
<path d="M12 20v-1a4 4 0 014-4h0a4 4 0 014 4v1"/>
|
||||
</svg>
|
||||
</span>
|
||||
<span class="device-row-main">
|
||||
<span class="device-row-name" x-text="jam.name"></span>
|
||||
<span class="device-row-current"
|
||||
x-text="!jam.host_device_online ? 'Host offline' : (jam.is_pending ? 'Invite pending' : (jam.is_owner ? 'Your Jam' : 'Shared queue'))"></span>
|
||||
</span>
|
||||
<span class="device-row-check" x-show="jam.is_active">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4">
|
||||
<polyline points="20 6 9 17 4 12"/>
|
||||
</svg>
|
||||
</span>
|
||||
</button>
|
||||
</template>
|
||||
<button class="device-row start-jam-row" @click="$store.devices.openJamPanel()">
|
||||
<span class="device-row-icon">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
||||
<path d="M12 5v14"/>
|
||||
<path d="M5 12h14"/>
|
||||
</svg>
|
||||
</span>
|
||||
<span class="device-row-main">
|
||||
<span class="device-row-name">Start Jam</span>
|
||||
<span class="device-row-current">Invite listeners</span>
|
||||
</span>
|
||||
</button>
|
||||
<div class="jam-create-panel" x-show="$store.devices.jamPanelOpen" x-transition x-cloak>
|
||||
<div class="jam-selected-users" x-show="$store.devices.jamSelectedUsers.length > 0">
|
||||
<template x-for="user in $store.devices.jamSelectedUsers" :key="user.id">
|
||||
<button class="jam-user-chip" @click="$store.devices.removeJamInvitee(user.id)">
|
||||
<span x-text="user.display_name || user.username"></span>
|
||||
<span aria-hidden="true">×</span>
|
||||
</button>
|
||||
</template>
|
||||
</div>
|
||||
<input class="jam-user-search"
|
||||
type="search"
|
||||
placeholder="Search users"
|
||||
x-model="$store.devices.jamQuery"
|
||||
@input="$store.devices.queueJamSearch()">
|
||||
<div class="jam-search-results" x-show="$store.devices.jamUsers.length > 0">
|
||||
<template x-for="user in $store.devices.jamUsers" :key="user.id">
|
||||
<button class="jam-search-row" @click="$store.devices.addJamInvitee(user)">
|
||||
<span x-text="user.display_name || user.username"></span>
|
||||
<small x-text="user.email || user.username"></small>
|
||||
</button>
|
||||
</template>
|
||||
</div>
|
||||
<button class="jam-create-btn" @click="$store.devices.createJam()">Create Jam</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
+1191
-21
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user