Compare commits
8 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Ultradesu
|
1c70349df8 | ||
|
Ultradesu
|
65da460c0c | ||
|
Ultradesu
|
538a6f6abf | ||
 ab
|
04c30bc4b8 | ||
|
Ultradesu
|
c0342ed987 | ||
|
Ultradesu
|
4b8797bb2e | ||
|
Ultradesu
|
d425bf3087 | ||
|
Ultradesu
|
82923c871e |
Generated
+117
-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.12"
|
||||
version = "0.1.20"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"async-trait",
|
||||
@@ -1407,6 +1428,7 @@ dependencies = [
|
||||
"croner",
|
||||
"encoding_rs",
|
||||
"id3",
|
||||
"image",
|
||||
"librqbit",
|
||||
"openidconnect",
|
||||
"reqwest",
|
||||
@@ -1588,6 +1610,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 +2058,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 +2582,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 +3070,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 +3150,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 +3171,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 +5237,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 +5791,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",
|
||||
]
|
||||
|
||||
+2
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "furumusic"
|
||||
version = "0.1.12"
|
||||
version = "0.1.20"
|
||||
edition = "2024"
|
||||
description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
|
||||
|
||||
@@ -20,6 +20,7 @@ symphonia = { version = "0.5", default-features = false, features = ["mp3","aac"
|
||||
id3 = "1"
|
||||
encoding_rs = "0.8"
|
||||
sha2 = "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"
|
||||
|
||||
+137
-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",
|
||||
{
|
||||
@@ -264,6 +293,27 @@ impl App for AdminApp {
|
||||
}),
|
||||
"admin_v2_job_run",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/v2/api/settings",
|
||||
get(move |session: Session, db: Database| async move {
|
||||
v2::settings(session, db).await
|
||||
})
|
||||
.post(
|
||||
move |session: Session,
|
||||
db: Database,
|
||||
json: Json<v2::UpdateSettingsRequest>| async move {
|
||||
v2::update_settings(session, db, json).await
|
||||
},
|
||||
),
|
||||
"admin_v2_settings",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/v2/api/settings/probe",
|
||||
get(move |session: Session, db: Database| async move {
|
||||
v2::settings_probe(session, db).await
|
||||
}),
|
||||
"admin_v2_settings_probe",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/v2/api/jobs/{name}/toggle",
|
||||
cot::router::method::post({
|
||||
@@ -378,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",
|
||||
{
|
||||
@@ -1027,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);
|
||||
@@ -1043,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
|
||||
}
|
||||
}
|
||||
}),
|
||||
|
||||
+719
-4
@@ -1,6 +1,6 @@
|
||||
use std::collections::HashMap;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
use cot::db::Database;
|
||||
use cot::db::{Database, Model};
|
||||
use cot::html::Html;
|
||||
use cot::http::StatusCode;
|
||||
use cot::http::header::CONTENT_TYPE;
|
||||
@@ -13,7 +13,9 @@ use serde::{Deserialize, Serialize};
|
||||
use sqlx::{PgPool, Postgres, QueryBuilder};
|
||||
|
||||
use super::BUILD_INFO;
|
||||
use crate::agent;
|
||||
use crate::auth::{self, AuthenticatedUser, Role};
|
||||
use crate::config::{AppConfig, ConfigEntry, ConfigSources};
|
||||
use crate::i18n::{I18n, Translations};
|
||||
use crate::scheduler::{JobRegistry, ScheduledJob};
|
||||
|
||||
@@ -65,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)]
|
||||
@@ -154,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,
|
||||
@@ -214,6 +255,95 @@ struct MutationResponse {
|
||||
affected: u64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
struct AdminSettingsDto {
|
||||
values: AdminSettingsValues,
|
||||
sources: AdminSettingsSources,
|
||||
lastfm_api_key_configured: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
|
||||
struct AdminSettingsValues {
|
||||
auth_password_enabled: bool,
|
||||
auth_sso_enabled: bool,
|
||||
oidc_button_text: String,
|
||||
oidc_issuer: String,
|
||||
oidc_client_id: String,
|
||||
oidc_client_secret: String,
|
||||
oidc_admin_groups: String,
|
||||
oidc_user_groups: String,
|
||||
swagger_enabled: bool,
|
||||
lastfm_api_key: String,
|
||||
agent_enabled: bool,
|
||||
agent_inbox_dir: String,
|
||||
agent_storage_dir: String,
|
||||
agent_llm_url: String,
|
||||
agent_llm_model: String,
|
||||
agent_llm_auth: String,
|
||||
agent_confidence_threshold: String,
|
||||
agent_context_limit: String,
|
||||
agent_concurrency: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, JsonSchema)]
|
||||
struct AdminSettingsSources {
|
||||
auth_password_enabled: &'static str,
|
||||
auth_sso_enabled: &'static str,
|
||||
oidc_button_text: &'static str,
|
||||
oidc_issuer: &'static str,
|
||||
oidc_client_id: &'static str,
|
||||
oidc_client_secret: &'static str,
|
||||
oidc_admin_groups: &'static str,
|
||||
oidc_user_groups: &'static str,
|
||||
swagger_enabled: &'static str,
|
||||
lastfm_api_key: &'static str,
|
||||
agent_enabled: &'static str,
|
||||
agent_inbox_dir: &'static str,
|
||||
agent_storage_dir: &'static str,
|
||||
agent_llm_url: &'static str,
|
||||
agent_llm_model: &'static str,
|
||||
agent_llm_auth: &'static str,
|
||||
agent_confidence_threshold: &'static str,
|
||||
agent_context_limit: &'static str,
|
||||
agent_concurrency: &'static str,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub(super) struct UpdateSettingsRequest {
|
||||
auth_password_enabled: bool,
|
||||
auth_sso_enabled: bool,
|
||||
oidc_button_text: String,
|
||||
oidc_issuer: String,
|
||||
oidc_client_id: String,
|
||||
oidc_client_secret: String,
|
||||
oidc_admin_groups: String,
|
||||
oidc_user_groups: String,
|
||||
swagger_enabled: bool,
|
||||
lastfm_api_key: String,
|
||||
agent_enabled: bool,
|
||||
agent_inbox_dir: String,
|
||||
agent_storage_dir: String,
|
||||
agent_llm_url: String,
|
||||
agent_llm_model: String,
|
||||
agent_llm_auth: String,
|
||||
agent_confidence_threshold: String,
|
||||
agent_context_limit: String,
|
||||
agent_concurrency: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
struct AgentProbeDto {
|
||||
status: String,
|
||||
ok: bool,
|
||||
model_intro: String,
|
||||
model_name: String,
|
||||
prompt_tokens: Option<u32>,
|
||||
completion_tokens: Option<u32>,
|
||||
tokens_per_sec: Option<f64>,
|
||||
latency_ms: u64,
|
||||
error: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
struct LibraryOverviewDto {
|
||||
artists: i64,
|
||||
@@ -243,6 +373,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,
|
||||
@@ -442,6 +598,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,
|
||||
@@ -458,6 +673,163 @@ pub async fn jobs(
|
||||
Json(jobs).into_response()
|
||||
}
|
||||
|
||||
pub async fn settings(session: Session, db: Database) -> cot::Result<cot::response::Response> {
|
||||
if let Err(response) = require_admin_json(&session, &db).await {
|
||||
return Ok(response);
|
||||
}
|
||||
let (config, sources) = AppConfig::load_with_db(&db).await;
|
||||
Json(settings_dto(config, sources)).into_response()
|
||||
}
|
||||
|
||||
pub async fn update_settings(
|
||||
session: Session,
|
||||
db: Database,
|
||||
Json(body): Json<UpdateSettingsRequest>,
|
||||
) -> cot::Result<cot::response::Response> {
|
||||
if let Err(response) = require_admin_json(&session, &db).await {
|
||||
return Ok(response);
|
||||
}
|
||||
let fields = [
|
||||
(
|
||||
"auth_password_enabled",
|
||||
body.auth_password_enabled.to_string(),
|
||||
),
|
||||
("auth_sso_enabled", body.auth_sso_enabled.to_string()),
|
||||
("oidc_button_text", body.oidc_button_text.trim().to_string()),
|
||||
("oidc_issuer", body.oidc_issuer.trim().to_string()),
|
||||
("oidc_client_id", body.oidc_client_id.trim().to_string()),
|
||||
(
|
||||
"oidc_client_secret",
|
||||
body.oidc_client_secret.trim().to_string(),
|
||||
),
|
||||
(
|
||||
"oidc_admin_groups",
|
||||
body.oidc_admin_groups.trim().to_string(),
|
||||
),
|
||||
("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()),
|
||||
("agent_enabled", body.agent_enabled.to_string()),
|
||||
("agent_inbox_dir", body.agent_inbox_dir.trim().to_string()),
|
||||
(
|
||||
"agent_storage_dir",
|
||||
body.agent_storage_dir.trim().to_string(),
|
||||
),
|
||||
("agent_llm_url", body.agent_llm_url.trim().to_string()),
|
||||
("agent_llm_model", body.agent_llm_model.trim().to_string()),
|
||||
("agent_llm_auth", body.agent_llm_auth.trim().to_string()),
|
||||
(
|
||||
"agent_confidence_threshold",
|
||||
body.agent_confidence_threshold.trim().to_string(),
|
||||
),
|
||||
(
|
||||
"agent_context_limit",
|
||||
body.agent_context_limit.trim().to_string(),
|
||||
),
|
||||
(
|
||||
"agent_concurrency",
|
||||
body.agent_concurrency.trim().to_string(),
|
||||
),
|
||||
];
|
||||
for (key, value) in fields {
|
||||
let mut entry = ConfigEntry::new(key.to_string(), value);
|
||||
entry
|
||||
.save(&db)
|
||||
.await
|
||||
.map_err(|e| cot::Error::internal(e.to_string()))?;
|
||||
}
|
||||
Json(serde_json::json!({ "ok": true })).into_response()
|
||||
}
|
||||
|
||||
pub async fn settings_probe(
|
||||
session: Session,
|
||||
db: Database,
|
||||
) -> cot::Result<cot::response::Response> {
|
||||
if let Err(response) = require_admin_json(&session, &db).await {
|
||||
return Ok(response);
|
||||
}
|
||||
let (config, _) = AppConfig::load_with_db(&db).await;
|
||||
let probe = if config.agent_enabled && !config.agent_llm_url.is_empty() {
|
||||
agent::probe_llm(
|
||||
&config.agent_llm_url,
|
||||
&config.agent_llm_model,
|
||||
&config.agent_llm_auth,
|
||||
)
|
||||
.await
|
||||
} else {
|
||||
agent::AgentProbeResult::default()
|
||||
};
|
||||
let status = if !config.agent_enabled {
|
||||
"disabled"
|
||||
} else if config.agent_llm_url.is_empty() {
|
||||
"not_configured"
|
||||
} else if probe.ok {
|
||||
"ok"
|
||||
} else {
|
||||
"error"
|
||||
};
|
||||
Json(AgentProbeDto {
|
||||
status: status.to_string(),
|
||||
ok: probe.ok,
|
||||
model_intro: probe.model_intro,
|
||||
model_name: probe.model_name,
|
||||
prompt_tokens: probe.prompt_tokens,
|
||||
completion_tokens: probe.completion_tokens,
|
||||
tokens_per_sec: probe.tokens_per_sec,
|
||||
latency_ms: probe.latency_ms,
|
||||
error: probe.error,
|
||||
})
|
||||
.into_response()
|
||||
}
|
||||
|
||||
fn settings_dto(config: AppConfig, sources: ConfigSources) -> AdminSettingsDto {
|
||||
AdminSettingsDto {
|
||||
lastfm_api_key_configured: !config.lastfm_api_key.trim().is_empty(),
|
||||
values: AdminSettingsValues {
|
||||
auth_password_enabled: config.auth_password_enabled,
|
||||
auth_sso_enabled: config.auth_sso_enabled,
|
||||
oidc_button_text: config.oidc_button_text,
|
||||
oidc_issuer: config.oidc_issuer,
|
||||
oidc_client_id: config.oidc_client_id,
|
||||
oidc_client_secret: config.oidc_client_secret,
|
||||
oidc_admin_groups: config.oidc_admin_groups,
|
||||
oidc_user_groups: config.oidc_user_groups,
|
||||
swagger_enabled: config.swagger_enabled,
|
||||
lastfm_api_key: config.lastfm_api_key,
|
||||
agent_enabled: config.agent_enabled,
|
||||
agent_inbox_dir: config.agent_inbox_dir,
|
||||
agent_storage_dir: config.agent_storage_dir,
|
||||
agent_llm_url: config.agent_llm_url,
|
||||
agent_llm_model: config.agent_llm_model,
|
||||
agent_llm_auth: config.agent_llm_auth,
|
||||
agent_confidence_threshold: config.agent_confidence_threshold.to_string(),
|
||||
agent_context_limit: config.agent_context_limit.to_string(),
|
||||
agent_concurrency: config.agent_concurrency.to_string(),
|
||||
},
|
||||
sources: AdminSettingsSources {
|
||||
auth_password_enabled: sources.auth_password_enabled.code(),
|
||||
auth_sso_enabled: sources.auth_sso_enabled.code(),
|
||||
oidc_button_text: sources.oidc_button_text.code(),
|
||||
oidc_issuer: sources.oidc_issuer.code(),
|
||||
oidc_client_id: sources.oidc_client_id.code(),
|
||||
oidc_client_secret: sources.oidc_client_secret.code(),
|
||||
oidc_admin_groups: sources.oidc_admin_groups.code(),
|
||||
oidc_user_groups: sources.oidc_user_groups.code(),
|
||||
swagger_enabled: sources.swagger_enabled.code(),
|
||||
lastfm_api_key: sources.lastfm_api_key.code(),
|
||||
agent_enabled: sources.agent_enabled.code(),
|
||||
agent_inbox_dir: sources.agent_inbox_dir.code(),
|
||||
agent_storage_dir: sources.agent_storage_dir.code(),
|
||||
agent_llm_url: sources.agent_llm_url.code(),
|
||||
agent_llm_model: sources.agent_llm_model.code(),
|
||||
agent_llm_auth: sources.agent_llm_auth.code(),
|
||||
agent_confidence_threshold: sources.agent_confidence_threshold.code(),
|
||||
agent_context_limit: sources.agent_context_limit.code(),
|
||||
agent_concurrency: sources.agent_concurrency.code(),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn run_job(
|
||||
session: Session,
|
||||
db: Database,
|
||||
@@ -582,6 +954,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,
|
||||
@@ -615,13 +1009,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)
|
||||
@@ -649,6 +1057,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
|
||||
@@ -660,6 +1090,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,
|
||||
@@ -961,6 +1513,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,
|
||||
@@ -976,11 +1533,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()) {
|
||||
@@ -1232,6 +1850,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,
|
||||
|
||||
+113
-11
@@ -799,7 +799,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 +879,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 +1794,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 +1922,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 +1947,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();
|
||||
|
||||
|
||||
@@ -328,6 +328,23 @@ pub async fn save_cover_to_storage(
|
||||
.await?;
|
||||
|
||||
if let Some((id,)) = existing {
|
||||
if let Some((file_path,)) = sqlx::query_as::<_, (String,)>(
|
||||
"SELECT file_path FROM furumusic__media_file WHERE id = $1",
|
||||
)
|
||||
.bind(id)
|
||||
.fetch_optional(pool)
|
||||
.await?
|
||||
{
|
||||
let path = PathBuf::from(&file_path);
|
||||
let path = if path.is_absolute() {
|
||||
path
|
||||
} else {
|
||||
Path::new(storage_dir).join(path)
|
||||
};
|
||||
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);
|
||||
}
|
||||
|
||||
@@ -374,6 +391,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;
|
||||
|
||||
@@ -133,6 +133,7 @@ pub struct ConfigSources {
|
||||
pub agent_confidence_threshold: ConfigSource,
|
||||
pub agent_context_limit: ConfigSource,
|
||||
pub agent_concurrency: ConfigSource,
|
||||
pub lastfm_api_key: ConfigSource,
|
||||
}
|
||||
|
||||
impl Default for ConfigSources {
|
||||
@@ -158,6 +159,7 @@ impl Default for ConfigSources {
|
||||
agent_confidence_threshold: ConfigSource::Default,
|
||||
agent_context_limit: ConfigSource::Default,
|
||||
agent_concurrency: ConfigSource::Default,
|
||||
lastfm_api_key: ConfigSource::Default,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -262,6 +264,8 @@ pub struct AppConfig {
|
||||
pub agent_context_limit: u64,
|
||||
/// Number of files to process in parallel via the LLM.
|
||||
pub agent_concurrency: u64,
|
||||
/// Last.fm API key for weekly popularity enrichment.
|
||||
pub lastfm_api_key: String,
|
||||
}
|
||||
|
||||
impl Default for AppConfig {
|
||||
@@ -287,6 +291,7 @@ impl Default for AppConfig {
|
||||
agent_confidence_threshold: 0.85,
|
||||
agent_context_limit: 8192,
|
||||
agent_concurrency: 2,
|
||||
lastfm_api_key: String::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -313,6 +318,7 @@ impl_env_overrides!(
|
||||
agent_confidence_threshold,
|
||||
agent_context_limit,
|
||||
agent_concurrency,
|
||||
lastfm_api_key,
|
||||
);
|
||||
|
||||
impl AppConfig {
|
||||
@@ -396,6 +402,7 @@ impl AppConfig {
|
||||
apply_db_field!(agent_confidence_threshold);
|
||||
apply_db_field!(agent_context_limit);
|
||||
apply_db_field!(agent_concurrency);
|
||||
apply_db_field!(lastfm_api_key);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+17
-2
@@ -268,6 +268,7 @@ translations! {
|
||||
// Player UI
|
||||
player_library: "Library" , "Библиотека";
|
||||
player_artists: "Artists" , "Артисты";
|
||||
player_release: "Release" , "Релиз";
|
||||
player_releases: "Releases" , "Релизы";
|
||||
player_tracks: "Tracks" , "Треки";
|
||||
player_title: "Title" , "Название";
|
||||
@@ -321,6 +322,11 @@ translations! {
|
||||
player_audio: "Audio" , "Аудио";
|
||||
player_size: "Size" , "Размер";
|
||||
player_uploader: "Uploader" , "Загрузил";
|
||||
player_lastfm_rating: "Last.fm popularity" , "Популярность Last.fm";
|
||||
player_lastfm_listeners: "Last.fm listeners" , "Слушатели Last.fm";
|
||||
player_lastfm_playcount: "Last.fm plays" , "Прослушивания Last.fm";
|
||||
player_lastfm_updated: "Last.fm updated" , "Last.fm обновлён";
|
||||
player_lastfm_not_loaded: "not loaded yet" , "ещё не загружено";
|
||||
player_play: "Play" , "Играть";
|
||||
player_like: "Like" , "Лайк";
|
||||
player_add_to_queue: "Add to queue" , "Добавить в очередь";
|
||||
@@ -357,21 +363,27 @@ translations! {
|
||||
player_saved_torrents: "Saved torrents" , "Сохранённые торренты";
|
||||
player_refresh: "Refresh" , "Обновить";
|
||||
player_no_saved_torrents: "No saved torrents" , "Сохранённых торрентов нет";
|
||||
player_upload: "Upload" , "Загрузить";
|
||||
player_choose_saved_or_add_torrent: "Choose a saved item or upload new files." , "Выберите сохранённый элемент или загрузите новые файлы.";
|
||||
player_local_files: "Local audio files" , "Локальные аудиофайлы";
|
||||
player_torrent_file: "Torrent file" , "Torrent-файл";
|
||||
player_magnet_link: "Magnet link" , "Magnet-ссылка";
|
||||
player_preview_content: "Preview content" , "Предпросмотр";
|
||||
player_upload_content: "Upload" , "Загрузить";
|
||||
player_download_selected: "Download selected" , "Скачать выбранное";
|
||||
player_pause_download: "Pause download" , "Поставить на паузу";
|
||||
player_expand_all: "Expand all" , "Развернуть всё";
|
||||
player_collapse: "Collapse" , "Свернуть";
|
||||
player_selected: "selected" , "выбрано";
|
||||
player_preview: "Preview" , "Предпросмотр";
|
||||
player_resolving: "Resolving metadata" , "Получаю метаданные";
|
||||
player_downloading: "Downloading" , "Скачивается";
|
||||
player_moving: "Moving" , "Перемещается";
|
||||
player_completed: "Completed" , "Готово";
|
||||
player_failed: "Failed" , "Ошибка";
|
||||
player_paused: "Paused" , "Пауза";
|
||||
player_no_torrent_selected: "No torrent selected" , "Торрент не выбран";
|
||||
player_downloaded: "Downloaded" , "Загружено";
|
||||
player_speed: "Speed" , "Скорость";
|
||||
player_down: "down" , "вниз";
|
||||
player_up: "up" , "вверх";
|
||||
player_peers: "peers" , "пиры";
|
||||
@@ -385,7 +397,10 @@ translations! {
|
||||
player_no_plays_yet: "No plays yet" , "Прослушиваний пока нет";
|
||||
player_page: "Page" , "Страница";
|
||||
player_of: "of" , "из";
|
||||
player_choose_torrent: "Choose a .torrent file or paste a magnet link." , "Выберите .torrent файл или вставьте magnet-ссылку.";
|
||||
player_choose_torrent: "Choose local files, paste a magnet link, or choose a .torrent file." , "Выберите локальные файлы, вставьте magnet-ссылку или выберите .torrent файл.";
|
||||
player_uploading_files: "Uploading files..." , "Загружаю файлы...";
|
||||
player_upload_complete: "Upload complete. Files are queued for processing." , "Загрузка завершена. Файлы поставлены в обработку.";
|
||||
player_upload_failed: "Upload failed" , "Загрузка не удалась";
|
||||
player_reading_torrent: "Reading torrent file..." , "Читаю torrent-файл...";
|
||||
player_resolving_magnet: "Resolving magnet metadata. This can take a while..." , "Получаю метаданные magnet-ссылки. Это может занять время...";
|
||||
player_preview_failed: "Preview failed" , "Предпросмотр не удался";
|
||||
|
||||
@@ -0,0 +1,96 @@
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use crate::agent::cover_variants;
|
||||
use crate::scheduler::{Job, JobContext, JobLog};
|
||||
|
||||
pub struct CoverVariantBackfillJob;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl Job for CoverVariantBackfillJob {
|
||||
fn name(&self) -> &'static str {
|
||||
"cover_variant_backfill"
|
||||
}
|
||||
|
||||
fn description(&self) -> &'static str {
|
||||
"Generate missing resized cover image variants"
|
||||
}
|
||||
|
||||
fn default_cron(&self) -> &'static str {
|
||||
// Once a day after cover extraction and artist image assignment.
|
||||
"0 45 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 variant backfill");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let rows: Vec<(i64, String)> = sqlx::query_as(
|
||||
"SELECT id, file_path FROM furumusic__media_file WHERE file_type = 'cover_art' ORDER BY id",
|
||||
)
|
||||
.fetch_all(&ctx.pool)
|
||||
.await?;
|
||||
|
||||
if rows.is_empty() {
|
||||
log.info("No cover art media files found");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
log.info(&format!(
|
||||
"Found {} cover art media file(s), checking variants...",
|
||||
rows.len()
|
||||
));
|
||||
|
||||
let mut created = 0usize;
|
||||
let mut unchanged = 0usize;
|
||||
let mut missing_original = 0usize;
|
||||
let mut failed = 0usize;
|
||||
|
||||
for (media_file_id, file_path) in rows {
|
||||
let path = resolve_media_path(storage_dir, &file_path);
|
||||
if !path.exists() {
|
||||
missing_original += 1;
|
||||
log.warn(&format!(
|
||||
"Media file {media_file_id}: original cover not found at {}",
|
||||
path.display()
|
||||
));
|
||||
continue;
|
||||
}
|
||||
|
||||
match cover_variants::ensure_cover_variants(&path).await {
|
||||
Ok(0) => unchanged += 1,
|
||||
Ok(count) => {
|
||||
created += count;
|
||||
log.info(&format!(
|
||||
"Media file {media_file_id}: created {count} variant(s)"
|
||||
));
|
||||
}
|
||||
Err(err) => {
|
||||
failed += 1;
|
||||
log.warn(&format!(
|
||||
"Media file {media_file_id}: failed to create variants: {err}"
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
log.info(&format!(
|
||||
"Cover variant backfill complete: {created} variant(s) created, \
|
||||
{unchanged} original(s) already complete, {missing_original} missing original(s), \
|
||||
{failed} failed original(s)"
|
||||
));
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn resolve_media_path(storage_dir: &str, file_path: &str) -> PathBuf {
|
||||
let path = PathBuf::from(file_path);
|
||||
if path.is_absolute() {
|
||||
path
|
||||
} else {
|
||||
Path::new(storage_dir).join(path)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,249 @@
|
||||
use serde::Deserialize;
|
||||
|
||||
use crate::scheduler::{Job, JobContext, JobLog};
|
||||
|
||||
pub struct LastfmPopularityJob;
|
||||
|
||||
const LASTFM_REQUEST_DELAY: std::time::Duration = std::time::Duration::from_millis(1200);
|
||||
|
||||
#[derive(Debug, sqlx::FromRow)]
|
||||
struct TrackLookupRow {
|
||||
id: i64,
|
||||
title: String,
|
||||
artist_name: Option<String>,
|
||||
lastfm_updated_at: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct LastfmTrackInfoResponse {
|
||||
track: Option<LastfmTrack>,
|
||||
error: Option<i32>,
|
||||
message: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct LastfmTrack {
|
||||
listeners: Option<String>,
|
||||
playcount: Option<String>,
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl Job for LastfmPopularityJob {
|
||||
fn name(&self) -> &'static str {
|
||||
"lastfm_popularity"
|
||||
}
|
||||
|
||||
fn description(&self) -> &'static str {
|
||||
"Update Last.fm playcount/listener popularity for library tracks"
|
||||
}
|
||||
|
||||
fn default_cron(&self) -> &'static str {
|
||||
// Sundays at 04:15
|
||||
"0 15 4 * * Sun"
|
||||
}
|
||||
|
||||
async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
|
||||
let api_key = ctx.config.lastfm_api_key.trim();
|
||||
if api_key.is_empty() {
|
||||
log.warn("lastfm_api_key is not configured, skipping Last.fm popularity update");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let tracks = sqlx::query_as::<_, TrackLookupRow>(
|
||||
r#"SELECT t.id,
|
||||
t.title::text AS title,
|
||||
t.lastfm_updated_at::text AS lastfm_updated_at,
|
||||
(
|
||||
SELECT a.name::text
|
||||
FROM furumusic__track_artist ta
|
||||
JOIN furumusic__artist a ON a.id = ta.artist_id
|
||||
WHERE ta.track_id = t.id AND ta.role <> 'featuring'
|
||||
ORDER BY ta.position
|
||||
LIMIT 1
|
||||
) AS artist_name
|
||||
FROM furumusic__track t
|
||||
WHERE t.is_hidden = false
|
||||
ORDER BY t.lastfm_updated_at IS NOT NULL, t.lastfm_updated_at ASC, t.id ASC"#,
|
||||
)
|
||||
.fetch_all(&ctx.pool)
|
||||
.await?;
|
||||
|
||||
if tracks.is_empty() {
|
||||
log.info("No visible tracks found for Last.fm popularity update");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
log.info(&format!(
|
||||
"Starting Last.fm popularity update for {} visible tracks; oldest or missing ratings are processed first; request delay is {} ms; rating formula is ln(playcount + 1) * ln(listeners + 1)",
|
||||
tracks.len(),
|
||||
LASTFM_REQUEST_DELAY.as_millis()
|
||||
));
|
||||
|
||||
let client = reqwest::Client::builder()
|
||||
.user_agent("furumusic-lastfm-popularity/0.1")
|
||||
.timeout(std::time::Duration::from_secs(15))
|
||||
.build()?;
|
||||
let mut updated = 0u64;
|
||||
let mut skipped = 0u64;
|
||||
let mut failed = 0u64;
|
||||
|
||||
for (index, track) in tracks.iter().enumerate() {
|
||||
let Some(artist) = track
|
||||
.artist_name
|
||||
.as_deref()
|
||||
.map(str::trim)
|
||||
.filter(|v| !v.is_empty())
|
||||
else {
|
||||
skipped += 1;
|
||||
log.warn(&format!(
|
||||
"Skipping track {} \"{}\": no primary artist",
|
||||
track.id, track.title
|
||||
));
|
||||
continue;
|
||||
};
|
||||
|
||||
log.info(&format!(
|
||||
"Last.fm lookup {}/{}: track {} \"{}\" by \"{}\" (previous update: {})",
|
||||
index + 1,
|
||||
tracks.len(),
|
||||
track.id,
|
||||
track.title,
|
||||
artist,
|
||||
track.lastfm_updated_at.as_deref().unwrap_or("never")
|
||||
));
|
||||
let result = fetch_track_info(&client, api_key, artist, &track.title).await;
|
||||
match result {
|
||||
Ok(Some((listeners, playcount))) => {
|
||||
let rating = popularity_rating(listeners, playcount);
|
||||
let fetched_at = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
|
||||
sqlx::query(
|
||||
r#"UPDATE furumusic__track
|
||||
SET lastfm_listeners = $2,
|
||||
lastfm_playcount = $3,
|
||||
lastfm_rating = $4,
|
||||
lastfm_updated_at = $5
|
||||
WHERE id = $1"#,
|
||||
)
|
||||
.bind(track.id)
|
||||
.bind(listeners)
|
||||
.bind(playcount)
|
||||
.bind(rating)
|
||||
.bind(&fetched_at)
|
||||
.execute(&ctx.pool)
|
||||
.await?;
|
||||
sqlx::query(
|
||||
r#"INSERT INTO furumusic__track_popularity_history
|
||||
(track_id, source, listeners, playcount, rating, fetched_at)
|
||||
VALUES ($1, 'lastfm', $2, $3, $4, $5)"#,
|
||||
)
|
||||
.bind(track.id)
|
||||
.bind(listeners)
|
||||
.bind(playcount)
|
||||
.bind(rating)
|
||||
.bind(&fetched_at)
|
||||
.execute(&ctx.pool)
|
||||
.await?;
|
||||
updated += 1;
|
||||
log.info(&format!(
|
||||
"Updated track {} \"{}\" by \"{}\": listeners={listeners}, playcount={playcount}, rating={rating:.4}",
|
||||
track.id, track.title, artist
|
||||
));
|
||||
}
|
||||
Ok(None) => {
|
||||
skipped += 1;
|
||||
log.warn(&format!(
|
||||
"Last.fm has no usable match for track {} \"{}\" by \"{}\"",
|
||||
track.id, track.title, artist
|
||||
));
|
||||
}
|
||||
Err(err) if err.to_string().contains("Last.fm rate limit exceeded") => {
|
||||
failed += 1;
|
||||
log.error("Last.fm rate limit exceeded; stopping this run early");
|
||||
break;
|
||||
}
|
||||
Err(err) => {
|
||||
failed += 1;
|
||||
log.warn(&format!(
|
||||
"Last.fm lookup failed for track {} \"{}\" / \"{}\": {err}",
|
||||
track.id, artist, track.title
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
if (index + 1) % 50 == 0 {
|
||||
log.info(&format!(
|
||||
"Last.fm progress: {}/{} tracks, {updated} updated, {skipped} skipped, {failed} failed",
|
||||
index + 1,
|
||||
tracks.len()
|
||||
));
|
||||
}
|
||||
tokio::time::sleep(LASTFM_REQUEST_DELAY).await;
|
||||
}
|
||||
|
||||
log.info(&format!(
|
||||
"Last.fm popularity update finished: {updated} updated, {skipped} skipped, {failed} failed, {} considered",
|
||||
tracks.len()
|
||||
));
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
async fn fetch_track_info(
|
||||
client: &reqwest::Client,
|
||||
api_key: &str,
|
||||
artist: &str,
|
||||
track: &str,
|
||||
) -> anyhow::Result<Option<(i64, i64)>> {
|
||||
let response = client
|
||||
.get("https://ws.audioscrobbler.com/2.0/")
|
||||
.query(&[
|
||||
("method", "track.getInfo"),
|
||||
("api_key", api_key),
|
||||
("artist", artist),
|
||||
("track", track),
|
||||
("autocorrect", "1"),
|
||||
("format", "json"),
|
||||
])
|
||||
.send()
|
||||
.await?;
|
||||
|
||||
if response.status() == reqwest::StatusCode::NOT_FOUND {
|
||||
return Ok(None);
|
||||
}
|
||||
let response = response.error_for_status()?;
|
||||
let body: LastfmTrackInfoResponse = response.json().await?;
|
||||
if let Some(code) = body.error {
|
||||
if code == 29 {
|
||||
anyhow::bail!("Last.fm rate limit exceeded");
|
||||
}
|
||||
if code == 6 || code == 7 {
|
||||
return Ok(None);
|
||||
}
|
||||
anyhow::bail!(
|
||||
"Last.fm API error {code}: {}",
|
||||
body.message.unwrap_or_else(|| "unknown error".to_string())
|
||||
);
|
||||
}
|
||||
let Some(info) = body.track else {
|
||||
return Ok(None);
|
||||
};
|
||||
let listeners = info
|
||||
.listeners
|
||||
.as_deref()
|
||||
.unwrap_or("0")
|
||||
.parse::<i64>()
|
||||
.unwrap_or(0);
|
||||
let playcount = info
|
||||
.playcount
|
||||
.as_deref()
|
||||
.unwrap_or("0")
|
||||
.parse::<i64>()
|
||||
.unwrap_or(0);
|
||||
Ok(Some((listeners.max(0), playcount.max(0))))
|
||||
}
|
||||
|
||||
fn popularity_rating(listeners: i64, playcount: i64) -> f64 {
|
||||
let listeners = listeners.max(0) as f64;
|
||||
let playcount = playcount.max(0) as f64;
|
||||
playcount.ln_1p() * listeners.ln_1p()
|
||||
}
|
||||
@@ -1,8 +1,10 @@
|
||||
pub mod artist_image_backfill;
|
||||
pub mod artist_track_image_backfill;
|
||||
pub mod cover_backfill;
|
||||
pub mod cover_variant_backfill;
|
||||
pub mod inbox_discover;
|
||||
pub mod inbox_process;
|
||||
pub mod lastfm_popularity;
|
||||
pub mod metadata_backfill;
|
||||
|
||||
use std::path::{Component, Path, PathBuf};
|
||||
|
||||
@@ -52,7 +52,9 @@ fn build_registry() -> Arc<JobRegistry> {
|
||||
registry.register(jobs::cover_backfill::CoverBackfillJob);
|
||||
registry.register(jobs::artist_image_backfill::ArtistImageBackfillJob);
|
||||
registry.register(jobs::artist_track_image_backfill::ArtistTrackImageBackfillJob);
|
||||
registry.register(jobs::cover_variant_backfill::CoverVariantBackfillJob);
|
||||
registry.register(jobs::metadata_backfill::MetadataBackfillJob);
|
||||
registry.register(jobs::lastfm_popularity::LastfmPopularityJob);
|
||||
Arc::new(registry)
|
||||
}
|
||||
|
||||
|
||||
@@ -1637,6 +1637,61 @@ pub mod db_migrations {
|
||||
&[Operation::custom(create_torrent_session).build()];
|
||||
}
|
||||
|
||||
// -- M0032: Last.fm track popularity ------------------------------------
|
||||
|
||||
#[cot::db::migrations::migration_op]
|
||||
async fn create_lastfm_track_popularity(
|
||||
ctx: migrations::MigrationContext<'_>,
|
||||
) -> cot::db::Result<()> {
|
||||
ctx.db
|
||||
.raw("ALTER TABLE furumusic__track ADD COLUMN lastfm_listeners BIGINT")
|
||||
.await?;
|
||||
ctx.db
|
||||
.raw("ALTER TABLE furumusic__track ADD COLUMN lastfm_playcount BIGINT")
|
||||
.await?;
|
||||
ctx.db
|
||||
.raw("ALTER TABLE furumusic__track ADD COLUMN lastfm_rating DOUBLE PRECISION")
|
||||
.await?;
|
||||
ctx.db
|
||||
.raw("ALTER TABLE furumusic__track ADD COLUMN lastfm_updated_at VARCHAR(32)")
|
||||
.await?;
|
||||
ctx.db
|
||||
.raw(
|
||||
"CREATE TABLE IF NOT EXISTS furumusic__track_popularity_history (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
track_id BIGINT NOT NULL,
|
||||
source VARCHAR(32) NOT NULL,
|
||||
listeners BIGINT NOT NULL,
|
||||
playcount BIGINT NOT NULL,
|
||||
rating DOUBLE PRECISION NOT NULL,
|
||||
fetched_at VARCHAR(32) NOT NULL
|
||||
)",
|
||||
)
|
||||
.await?;
|
||||
ctx.db
|
||||
.raw(
|
||||
"CREATE INDEX IF NOT EXISTS idx_track_popularity_history_track
|
||||
ON furumusic__track_popularity_history (track_id, fetched_at DESC)",
|
||||
)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub struct M0032CreateLastfmTrackPopularity;
|
||||
|
||||
impl migrations::Migration for M0032CreateLastfmTrackPopularity {
|
||||
const APP_NAME: &'static str = "furumusic";
|
||||
const MIGRATION_NAME: &'static str = "m_0032_create_lastfm_track_popularity";
|
||||
const DEPENDENCIES: &'static [migrations::MigrationDependency] =
|
||||
&[migrations::MigrationDependency::migration(
|
||||
"furumusic",
|
||||
"m_0031_create_torrent_session",
|
||||
)];
|
||||
const OPERATIONS: &'static [Operation] =
|
||||
&[Operation::custom(create_lastfm_track_popularity).build()];
|
||||
}
|
||||
|
||||
pub const MIGRATIONS: &[&SyncDynMigration] = &[
|
||||
&M0006CreateMediaFile,
|
||||
&M0007CreateArtist,
|
||||
@@ -1659,5 +1714,6 @@ pub mod db_migrations {
|
||||
&M0029AddPlaybackVolume,
|
||||
&M0030AddMediaFileUploader,
|
||||
&M0031CreateTorrentSession,
|
||||
&M0032CreateLastfmTrackPopularity,
|
||||
];
|
||||
}
|
||||
|
||||
+1
-5
@@ -389,11 +389,7 @@ pub async fn oidc_callback_handler(
|
||||
config.oidc_user_groups,
|
||||
);
|
||||
|
||||
if !is_allowed_by_groups(
|
||||
&groups,
|
||||
&config.oidc_user_groups,
|
||||
&config.oidc_admin_groups,
|
||||
) {
|
||||
if !is_allowed_by_groups(&groups, &config.oidc_user_groups, &config.oidc_admin_groups) {
|
||||
tracing::warn!(
|
||||
"OIDC login denied by group allowlist: sub={sub}, groups={groups:?}, user_groups={:?}, admin_groups={:?}",
|
||||
config.oidc_user_groups,
|
||||
|
||||
@@ -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,
|
||||
@@ -64,6 +66,10 @@ pub(super) struct TrackItem {
|
||||
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>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
@@ -84,6 +90,10 @@ pub(super) struct ArtistAppearanceTrack {
|
||||
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>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
|
||||
@@ -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(
|
||||
|
||||
+364
-36
@@ -2,7 +2,9 @@ use std::sync::Arc;
|
||||
|
||||
use cot::db::Database;
|
||||
use cot::http::StatusCode;
|
||||
use cot::http::header::{ACCEPT_RANGES, CONTENT_LENGTH, CONTENT_RANGE, CONTENT_TYPE, RANGE};
|
||||
use cot::http::header::{
|
||||
ACCEPT_RANGES, CONTENT_LENGTH, CONTENT_RANGE, CONTENT_TYPE, HeaderName, RANGE,
|
||||
};
|
||||
use cot::json::Json;
|
||||
use cot::request::extractors::Path;
|
||||
use cot::response::IntoResponse;
|
||||
@@ -23,7 +25,7 @@ mod queries;
|
||||
mod rows;
|
||||
|
||||
use dto::*;
|
||||
use helpers::{cover_url, load_release_uploaders, track_cover_url};
|
||||
use helpers::{cover_variant_url, load_release_uploaders, track_cover_variant_url};
|
||||
use queries::*;
|
||||
use rows::*;
|
||||
|
||||
@@ -40,6 +42,13 @@ fn json_error(status: StatusCode, message: &str) -> cot::response::Response {
|
||||
.expect("valid response")
|
||||
}
|
||||
|
||||
#[derive(serde::Serialize)]
|
||||
struct LocalUploadResponse {
|
||||
ok: bool,
|
||||
filename: String,
|
||||
size: u64,
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// SPA shell
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -194,7 +203,7 @@ async fn artists_handler(
|
||||
.map(|r| ArtistCard {
|
||||
id: r.id,
|
||||
name: r.name,
|
||||
image_url: cover_url(r.image_file_id),
|
||||
image_url: cover_variant_url(r.image_file_id, "medium"),
|
||||
release_count: r.release_count,
|
||||
track_count: r.track_count,
|
||||
})
|
||||
@@ -270,7 +279,7 @@ async fn artist_detail_handler(
|
||||
title: r.title,
|
||||
release_type: r.release_type,
|
||||
year: r.year,
|
||||
cover_url: cover_url(r.cover_file_id),
|
||||
cover_url: cover_variant_url(r.cover_file_id, "medium"),
|
||||
track_count: r.track_count,
|
||||
uploaders: release_uploaders.remove(&r.id).unwrap_or_default(),
|
||||
})
|
||||
@@ -304,7 +313,11 @@ async fn artist_detail_handler(
|
||||
mf.audio_bitrate,
|
||||
mf.audio_sample_rate,
|
||||
mf.audio_bit_depth,
|
||||
mf.file_size_bytes
|
||||
mf.file_size_bytes,
|
||||
t.lastfm_listeners,
|
||||
t.lastfm_playcount,
|
||||
t.lastfm_rating,
|
||||
t.lastfm_updated_at
|
||||
FROM furumusic__track_artist ta
|
||||
JOIN furumusic__track t ON t.id = ta.track_id
|
||||
JOIN furumusic__release r ON r.id = t.release_id
|
||||
@@ -373,7 +386,11 @@ async fn artist_detail_handler(
|
||||
duration_seconds: t.duration_seconds,
|
||||
artists: featured_main_artists.remove(&tid).unwrap_or_default(),
|
||||
featured_artists: featured_feat_artists.remove(&tid).unwrap_or_default(),
|
||||
cover_url: track_cover_url(t.cover_file_id, t.release_cover_file_id),
|
||||
cover_url: track_cover_variant_url(
|
||||
t.cover_file_id,
|
||||
t.release_cover_file_id,
|
||||
"medium",
|
||||
),
|
||||
stream_url: format!("/api/player/stream/{tid}"),
|
||||
uploader_name: t.uploader_name,
|
||||
audio_format: t.audio_format,
|
||||
@@ -381,6 +398,10 @@ async fn artist_detail_handler(
|
||||
audio_sample_rate: t.audio_sample_rate,
|
||||
audio_bit_depth: t.audio_bit_depth,
|
||||
file_size_bytes: t.file_size_bytes,
|
||||
lastfm_listeners: t.lastfm_listeners,
|
||||
lastfm_playcount: t.lastfm_playcount,
|
||||
lastfm_rating: t.lastfm_rating,
|
||||
lastfm_updated_at: t.lastfm_updated_at,
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
@@ -388,7 +409,7 @@ async fn artist_detail_handler(
|
||||
Json(ArtistDetail {
|
||||
id: artist.id,
|
||||
name: artist.name,
|
||||
image_url: cover_url(image_file_id),
|
||||
image_url: cover_variant_url(image_file_id, "large"),
|
||||
total_track_count,
|
||||
total_play_count,
|
||||
releases: release_cards,
|
||||
@@ -444,13 +465,19 @@ async fn release_detail_handler(
|
||||
r#"SELECT t.id, t.title::text as title, t.track_number, t.disc_number,
|
||||
t.duration_seconds, t.cover_file_id,
|
||||
r.cover_file_id as release_cover_file_id,
|
||||
r.id as release_id,
|
||||
r.title::text as release_title,
|
||||
r.year as release_year,
|
||||
COALESCE(mf.uploader_name, 'UFO')::text AS uploader_name,
|
||||
mf.audio_format,
|
||||
mf.audio_bitrate,
|
||||
mf.audio_sample_rate,
|
||||
mf.audio_bit_depth,
|
||||
mf.file_size_bytes
|
||||
mf.file_size_bytes,
|
||||
t.lastfm_listeners,
|
||||
t.lastfm_playcount,
|
||||
t.lastfm_rating,
|
||||
t.lastfm_updated_at
|
||||
FROM furumusic__track t
|
||||
JOIN furumusic__release r ON r.id = t.release_id
|
||||
LEFT JOIN furumusic__media_file mf ON mf.id = t.audio_file_id
|
||||
@@ -517,8 +544,14 @@ async fn release_detail_handler(
|
||||
duration_seconds: t.duration_seconds,
|
||||
artists: track_main_artists.remove(&tid).unwrap_or_default(),
|
||||
featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
|
||||
release_id: t.release_id,
|
||||
release_title: t.release_title,
|
||||
release_year: t.release_year,
|
||||
cover_url: track_cover_url(t.cover_file_id, t.release_cover_file_id),
|
||||
cover_url: track_cover_variant_url(
|
||||
t.cover_file_id,
|
||||
t.release_cover_file_id,
|
||||
"medium",
|
||||
),
|
||||
stream_url: format!("/api/player/stream/{tid}"),
|
||||
uploader_name: t.uploader_name,
|
||||
audio_format: t.audio_format,
|
||||
@@ -526,6 +559,10 @@ async fn release_detail_handler(
|
||||
audio_sample_rate: t.audio_sample_rate,
|
||||
audio_bit_depth: t.audio_bit_depth,
|
||||
file_size_bytes: t.file_size_bytes,
|
||||
lastfm_listeners: t.lastfm_listeners,
|
||||
lastfm_playcount: t.lastfm_playcount,
|
||||
lastfm_rating: t.lastfm_rating,
|
||||
lastfm_updated_at: t.lastfm_updated_at,
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
@@ -540,7 +577,7 @@ async fn release_detail_handler(
|
||||
title: release.title,
|
||||
release_type: release.release_type,
|
||||
year: release.year,
|
||||
cover_url: cover_url(release.cover_file_id),
|
||||
cover_url: cover_variant_url(release.cover_file_id, "large"),
|
||||
artists: release_artists
|
||||
.into_iter()
|
||||
.map(|a| ArtistRef {
|
||||
@@ -674,13 +711,19 @@ async fn playlist_detail_handler(
|
||||
r#"SELECT t.id, t.title::text as title, t.track_number, t.disc_number,
|
||||
t.duration_seconds, t.cover_file_id,
|
||||
r.cover_file_id as release_cover_file_id,
|
||||
r.id as release_id,
|
||||
r.title::text as release_title,
|
||||
r.year as release_year,
|
||||
COALESCE(mf.uploader_name, 'UFO')::text AS uploader_name,
|
||||
mf.audio_format,
|
||||
mf.audio_bitrate,
|
||||
mf.audio_sample_rate,
|
||||
mf.audio_bit_depth,
|
||||
mf.file_size_bytes
|
||||
mf.file_size_bytes,
|
||||
t.lastfm_listeners,
|
||||
t.lastfm_playcount,
|
||||
t.lastfm_rating,
|
||||
t.lastfm_updated_at
|
||||
FROM furumusic__playlist_track pt
|
||||
JOIN furumusic__track t ON t.id = pt.track_id
|
||||
JOIN furumusic__release r ON r.id = t.release_id
|
||||
@@ -767,8 +810,14 @@ async fn build_track_items(
|
||||
duration_seconds: t.duration_seconds,
|
||||
artists: track_main_artists.remove(&tid).unwrap_or_default(),
|
||||
featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
|
||||
release_id: t.release_id,
|
||||
release_title: t.release_title,
|
||||
release_year: t.release_year,
|
||||
cover_url: track_cover_url(t.cover_file_id, t.release_cover_file_id),
|
||||
cover_url: track_cover_variant_url(
|
||||
t.cover_file_id,
|
||||
t.release_cover_file_id,
|
||||
"medium",
|
||||
),
|
||||
stream_url: format!("/api/player/stream/{tid}"),
|
||||
uploader_name: t.uploader_name,
|
||||
audio_format: t.audio_format,
|
||||
@@ -776,6 +825,10 @@ async fn build_track_items(
|
||||
audio_sample_rate: t.audio_sample_rate,
|
||||
audio_bit_depth: t.audio_bit_depth,
|
||||
file_size_bytes: t.file_size_bytes,
|
||||
lastfm_listeners: t.lastfm_listeners,
|
||||
lastfm_playcount: t.lastfm_playcount,
|
||||
lastfm_rating: t.lastfm_rating,
|
||||
lastfm_updated_at: t.lastfm_updated_at,
|
||||
}
|
||||
})
|
||||
.collect())
|
||||
@@ -790,13 +843,19 @@ async fn likes_playlist_handler(
|
||||
r#"SELECT t.id, t.title::text as title, t.track_number, t.disc_number,
|
||||
t.duration_seconds, t.cover_file_id,
|
||||
r.cover_file_id as release_cover_file_id,
|
||||
r.id as release_id,
|
||||
r.title::text as release_title,
|
||||
r.year as release_year,
|
||||
COALESCE(mf.uploader_name, 'UFO')::text AS uploader_name,
|
||||
mf.audio_format,
|
||||
mf.audio_bitrate,
|
||||
mf.audio_sample_rate,
|
||||
mf.audio_bit_depth,
|
||||
mf.file_size_bytes
|
||||
mf.file_size_bytes,
|
||||
t.lastfm_listeners,
|
||||
t.lastfm_playcount,
|
||||
t.lastfm_rating,
|
||||
t.lastfm_updated_at
|
||||
FROM furumusic__user_liked_track ult
|
||||
JOIN furumusic__track t ON t.id = ult.track_id
|
||||
JOIN furumusic__release r ON r.id = t.release_id
|
||||
@@ -910,6 +969,140 @@ async fn stream_handler(
|
||||
Ok(response)
|
||||
}
|
||||
|
||||
async fn local_upload_handler(
|
||||
session: Session,
|
||||
db: Database,
|
||||
config: AppConfig,
|
||||
scheduler_handle: Arc<tokio::sync::OnceCell<Arc<SchedulerHandle>>>,
|
||||
request: cot::request::Request,
|
||||
) -> cot::Result<cot::http::Response<Body>> {
|
||||
let Some(user) = auth::get_session_user(&session, &db).await else {
|
||||
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
|
||||
};
|
||||
|
||||
let inbox_dir = config.agent_inbox_dir.trim();
|
||||
if inbox_dir.is_empty() {
|
||||
return Ok(json_error(
|
||||
StatusCode::BAD_REQUEST,
|
||||
"agent_inbox_dir is not configured",
|
||||
));
|
||||
}
|
||||
let inbox_root = std::path::PathBuf::from(inbox_dir);
|
||||
if !inbox_root.is_absolute() {
|
||||
return Ok(json_error(
|
||||
StatusCode::BAD_REQUEST,
|
||||
"agent_inbox_dir must be an absolute path",
|
||||
));
|
||||
}
|
||||
|
||||
let filename_header = HeaderName::from_static("x-furumusic-filename");
|
||||
let original_name = request
|
||||
.headers()
|
||||
.get(filename_header)
|
||||
.and_then(|value| value.to_str().ok())
|
||||
.map(percent_decode_header)
|
||||
.map(|value| value.trim().to_string())
|
||||
.filter(|value| !value.is_empty())
|
||||
.unwrap_or_else(|| "upload.mp3".to_string());
|
||||
let filename = sanitize_upload_filename(&original_name);
|
||||
|
||||
let bytes = request
|
||||
.into_body()
|
||||
.into_bytes()
|
||||
.await
|
||||
.map_err(|err| cot::Error::internal(err.to_string()))?;
|
||||
if bytes.is_empty() {
|
||||
return Ok(json_error(
|
||||
StatusCode::BAD_REQUEST,
|
||||
"uploaded file is empty",
|
||||
));
|
||||
}
|
||||
|
||||
let upload_dir = inbox_root
|
||||
.join("user_uploads")
|
||||
.join(user.id.to_string())
|
||||
.join(format!("local-{}", uuid::Uuid::new_v4()));
|
||||
tokio::fs::create_dir_all(&upload_dir)
|
||||
.await
|
||||
.map_err(|err| cot::Error::internal(err.to_string()))?;
|
||||
let destination = upload_dir.join(&filename);
|
||||
tokio::fs::write(&destination, &bytes)
|
||||
.await
|
||||
.map_err(|err| cot::Error::internal(err.to_string()))?;
|
||||
|
||||
if let Some(handle) = scheduler_handle.get() {
|
||||
let handle = Arc::clone(handle);
|
||||
tokio::spawn(async move {
|
||||
if let Err(err) = handle.trigger_job_now("inbox_discover").await {
|
||||
tracing::warn!("failed to trigger inbox_discover after local upload: {err}");
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
Json(LocalUploadResponse {
|
||||
ok: true,
|
||||
filename,
|
||||
size: bytes.len() as u64,
|
||||
})
|
||||
.into_response()
|
||||
}
|
||||
|
||||
fn sanitize_upload_filename(value: &str) -> String {
|
||||
let name = std::path::Path::new(value)
|
||||
.file_name()
|
||||
.and_then(|name| name.to_str())
|
||||
.unwrap_or("upload.mp3");
|
||||
let sanitized: String = name
|
||||
.chars()
|
||||
.map(|c| match c {
|
||||
'/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '_',
|
||||
c if c.is_control() => '_',
|
||||
c => c,
|
||||
})
|
||||
.collect();
|
||||
let trimmed = sanitized.trim().trim_matches('.').trim();
|
||||
if trimmed.is_empty() {
|
||||
"upload.mp3".to_string()
|
||||
} else {
|
||||
trimmed.to_string()
|
||||
}
|
||||
}
|
||||
|
||||
fn percent_decode_header(value: &str) -> String {
|
||||
let bytes = value.as_bytes();
|
||||
let mut out = Vec::with_capacity(bytes.len());
|
||||
let mut index = 0;
|
||||
while index < bytes.len() {
|
||||
match bytes[index] {
|
||||
b'%' if index + 2 < bytes.len() => {
|
||||
let hi = hex_value(bytes[index + 1]);
|
||||
let lo = hex_value(bytes[index + 2]);
|
||||
if let (Some(hi), Some(lo)) = (hi, lo) {
|
||||
out.push((hi << 4) | lo);
|
||||
index += 3;
|
||||
} else {
|
||||
out.push(bytes[index]);
|
||||
index += 1;
|
||||
}
|
||||
}
|
||||
byte => {
|
||||
out.push(byte);
|
||||
index += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
String::from_utf8_lossy(&out).to_string()
|
||||
}
|
||||
|
||||
fn hex_value(byte: u8) -> Option<u8> {
|
||||
match byte {
|
||||
b'0'..=b'9' => Some(byte - b'0'),
|
||||
b'a'..=b'f' => Some(byte - b'a' + 10),
|
||||
b'A'..=b'F' => Some(byte - b'A' + 10),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_range(header: &str, file_size: u64) -> Option<(u64, u64)> {
|
||||
let bytes_prefix = "bytes=";
|
||||
if !header.starts_with(bytes_prefix) {
|
||||
@@ -971,13 +1164,40 @@ async fn cover_handler(
|
||||
pool: &sqlx::PgPool,
|
||||
config: &AppConfig,
|
||||
path: Path<PathMediaFileId>,
|
||||
) -> cot::Result<cot::http::Response<Body>> {
|
||||
cover_response(session, db, pool, config, path.0.media_file_id, None).await
|
||||
}
|
||||
|
||||
async fn cover_variant_handler(
|
||||
session: Session,
|
||||
db: Database,
|
||||
pool: &sqlx::PgPool,
|
||||
config: &AppConfig,
|
||||
path: Path<PathMediaFileVariant>,
|
||||
) -> cot::Result<cot::http::Response<Body>> {
|
||||
cover_response(
|
||||
session,
|
||||
db,
|
||||
pool,
|
||||
config,
|
||||
path.0.media_file_id,
|
||||
Some(path.0.variant.as_str()),
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
async fn cover_response(
|
||||
session: Session,
|
||||
db: Database,
|
||||
pool: &sqlx::PgPool,
|
||||
config: &AppConfig,
|
||||
media_file_id: i64,
|
||||
variant_name: Option<&str>,
|
||||
) -> cot::Result<cot::http::Response<Body>> {
|
||||
let Some(_user) = auth::get_session_user(&session, &db).await else {
|
||||
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
|
||||
};
|
||||
|
||||
let media_file_id = path.0.media_file_id;
|
||||
|
||||
let media = sqlx::query_as::<_, MediaFileRow>(
|
||||
"SELECT file_path, mime_type::text as mime_type, file_size_bytes FROM furumusic__media_file WHERE id = $1",
|
||||
)
|
||||
@@ -996,13 +1216,25 @@ async fn cover_handler(
|
||||
return Ok(json_error(StatusCode::NOT_FOUND, "file not found on disk"));
|
||||
}
|
||||
|
||||
let data = tokio::fs::read(&full_path)
|
||||
let (response_path, content_type) = variant_name
|
||||
.and_then(crate::agent::cover_variants::variant_by_name)
|
||||
.map(|variant| {
|
||||
let variant_path = crate::agent::cover_variants::variant_path(&full_path, variant);
|
||||
if variant_path.exists() {
|
||||
(variant_path, "image/jpeg")
|
||||
} else {
|
||||
(full_path.clone(), media.mime_type.as_str())
|
||||
}
|
||||
})
|
||||
.unwrap_or_else(|| (full_path.clone(), media.mime_type.as_str()));
|
||||
|
||||
let data = tokio::fs::read(&response_path)
|
||||
.await
|
||||
.map_err(|e| cot::Error::internal(e.to_string()))?;
|
||||
|
||||
let response = cot::http::Response::builder()
|
||||
.status(StatusCode::OK)
|
||||
.header(CONTENT_TYPE, media.mime_type.as_str())
|
||||
.header(CONTENT_TYPE, content_type)
|
||||
.header(CONTENT_LENGTH, data.len().to_string())
|
||||
.header("Cache-Control", "public, max-age=86400")
|
||||
.body(Body::fixed(data))
|
||||
@@ -1258,13 +1490,19 @@ async fn search_handler(
|
||||
r#"SELECT t.id, t.title::text AS title, t.track_number, t.disc_number,
|
||||
t.duration_seconds, t.cover_file_id,
|
||||
rel.cover_file_id AS release_cover_file_id,
|
||||
rel.id AS release_id,
|
||||
rel.title::text AS release_title,
|
||||
rel.year AS release_year,
|
||||
COALESCE(mf.uploader_name, 'UFO')::text AS uploader_name,
|
||||
mf.audio_format,
|
||||
mf.audio_bitrate,
|
||||
mf.audio_sample_rate,
|
||||
mf.audio_bit_depth,
|
||||
mf.file_size_bytes
|
||||
mf.file_size_bytes,
|
||||
t.lastfm_listeners,
|
||||
t.lastfm_playcount,
|
||||
t.lastfm_rating,
|
||||
t.lastfm_updated_at
|
||||
FROM furumusic__track t
|
||||
JOIN furumusic__release rel ON rel.id = t.release_id
|
||||
LEFT JOIN furumusic__media_file mf ON mf.id = t.audio_file_id
|
||||
@@ -1328,11 +1566,13 @@ async fn search_handler(
|
||||
|
||||
let t = sqlx::query_as::<_, SearchTrackRow>(
|
||||
r#"SELECT id, title, track_number, disc_number, duration_seconds, cover_file_id,
|
||||
release_cover_file_id, release_year, uploader_name, audio_format, audio_bitrate,
|
||||
audio_sample_rate, audio_bit_depth, file_size_bytes FROM (
|
||||
release_cover_file_id, release_id, release_title, release_year, uploader_name, audio_format, audio_bitrate,
|
||||
audio_sample_rate, audio_bit_depth, file_size_bytes, lastfm_listeners, lastfm_playcount, lastfm_rating, lastfm_updated_at FROM (
|
||||
SELECT t.id, t.title::text AS title, t.track_number, t.disc_number,
|
||||
t.duration_seconds, t.cover_file_id,
|
||||
rel.cover_file_id AS release_cover_file_id,
|
||||
rel.id AS release_id,
|
||||
rel.title::text AS release_title,
|
||||
rel.year AS release_year,
|
||||
COALESCE(mf.uploader_name, 'UFO')::text AS uploader_name,
|
||||
mf.audio_format,
|
||||
@@ -1340,20 +1580,27 @@ async fn search_handler(
|
||||
mf.audio_sample_rate,
|
||||
mf.audio_bit_depth,
|
||||
mf.file_size_bytes,
|
||||
t.lastfm_listeners,
|
||||
t.lastfm_playcount,
|
||||
t.lastfm_rating,
|
||||
t.lastfm_updated_at,
|
||||
MAX(sim) AS similarity
|
||||
FROM (
|
||||
SELECT id, title, title_sort, track_number, disc_number, duration_seconds, cover_file_id, release_id, audio_file_id,
|
||||
lastfm_listeners, lastfm_playcount, lastfm_rating, lastfm_updated_at,
|
||||
similarity(title_sort, $1) AS sim
|
||||
FROM furumusic__track WHERE is_hidden = false AND title_sort % $1
|
||||
UNION ALL
|
||||
SELECT id, title, title_sort, track_number, disc_number, duration_seconds, cover_file_id, release_id, audio_file_id,
|
||||
lastfm_listeners, lastfm_playcount, lastfm_rating, lastfm_updated_at,
|
||||
0.01::real AS sim
|
||||
FROM furumusic__track WHERE is_hidden = false AND title_sort ILIKE '%' || $1 || '%'
|
||||
) t
|
||||
JOIN furumusic__release rel ON rel.id = t.release_id
|
||||
LEFT JOIN furumusic__media_file mf ON mf.id = t.audio_file_id
|
||||
GROUP BY t.id, t.title, t.track_number, t.disc_number, t.duration_seconds, t.cover_file_id, rel.cover_file_id, rel.year,
|
||||
mf.uploader_name, mf.audio_format, mf.audio_bitrate, mf.audio_sample_rate, mf.audio_bit_depth, mf.file_size_bytes
|
||||
GROUP BY t.id, t.title, t.track_number, t.disc_number, t.duration_seconds, t.cover_file_id, rel.cover_file_id, rel.id, rel.title, rel.year,
|
||||
mf.uploader_name, mf.audio_format, mf.audio_bitrate, mf.audio_sample_rate, mf.audio_bit_depth, mf.file_size_bytes,
|
||||
t.lastfm_listeners, t.lastfm_playcount, t.lastfm_rating, t.lastfm_updated_at
|
||||
ORDER BY similarity DESC
|
||||
LIMIT $2
|
||||
) sub"#,
|
||||
@@ -1412,7 +1659,7 @@ async fn search_handler(
|
||||
.map(|r| ArtistCard {
|
||||
id: r.id,
|
||||
name: r.name,
|
||||
image_url: cover_url(r.image_file_id),
|
||||
image_url: cover_variant_url(r.image_file_id, "medium"),
|
||||
release_count: r.release_count,
|
||||
track_count: r.track_count,
|
||||
})
|
||||
@@ -1430,7 +1677,7 @@ async fn search_handler(
|
||||
title: r.title,
|
||||
release_type: r.release_type,
|
||||
year: r.year,
|
||||
cover_url: cover_url(r.cover_file_id),
|
||||
cover_url: cover_variant_url(r.cover_file_id, "medium"),
|
||||
track_count: r.track_count,
|
||||
uploaders: release_uploaders.remove(&r.id).unwrap_or_default(),
|
||||
})
|
||||
@@ -1448,8 +1695,14 @@ async fn search_handler(
|
||||
duration_seconds: t.duration_seconds,
|
||||
artists: track_main_artists.remove(&tid).unwrap_or_default(),
|
||||
featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
|
||||
release_id: t.release_id,
|
||||
release_title: t.release_title,
|
||||
release_year: t.release_year,
|
||||
cover_url: track_cover_url(t.cover_file_id, t.release_cover_file_id),
|
||||
cover_url: track_cover_variant_url(
|
||||
t.cover_file_id,
|
||||
t.release_cover_file_id,
|
||||
"medium",
|
||||
),
|
||||
stream_url: format!("/api/player/stream/{tid}"),
|
||||
uploader_name: t.uploader_name,
|
||||
audio_format: t.audio_format,
|
||||
@@ -1457,6 +1710,10 @@ async fn search_handler(
|
||||
audio_sample_rate: t.audio_sample_rate,
|
||||
audio_bit_depth: t.audio_bit_depth,
|
||||
file_size_bytes: t.file_size_bytes,
|
||||
lastfm_listeners: t.lastfm_listeners,
|
||||
lastfm_playcount: t.lastfm_playcount,
|
||||
lastfm_rating: t.lastfm_rating,
|
||||
lastfm_updated_at: t.lastfm_updated_at,
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
@@ -1915,7 +2172,7 @@ async fn followed_artists_handler(
|
||||
.map(|r| ArtistCard {
|
||||
id: r.id,
|
||||
name: r.name,
|
||||
image_url: cover_url(r.image_file_id),
|
||||
image_url: cover_variant_url(r.image_file_id, "small"),
|
||||
release_count: r.release_count,
|
||||
track_count: r.track_count,
|
||||
})
|
||||
@@ -2015,13 +2272,19 @@ async fn tracks_by_ids_handler(
|
||||
r#"SELECT t.id, t.title::text as title, t.track_number, t.disc_number,
|
||||
t.duration_seconds, t.cover_file_id,
|
||||
r.cover_file_id as release_cover_file_id,
|
||||
r.id as release_id,
|
||||
r.title::text as release_title,
|
||||
r.year as release_year,
|
||||
COALESCE(mf.uploader_name, 'UFO')::text AS uploader_name,
|
||||
mf.audio_format,
|
||||
mf.audio_bitrate,
|
||||
mf.audio_sample_rate,
|
||||
mf.audio_bit_depth,
|
||||
mf.file_size_bytes
|
||||
mf.file_size_bytes,
|
||||
t.lastfm_listeners,
|
||||
t.lastfm_playcount,
|
||||
t.lastfm_rating,
|
||||
t.lastfm_updated_at
|
||||
FROM furumusic__track t
|
||||
JOIN furumusic__release r ON r.id = t.release_id
|
||||
LEFT JOIN furumusic__media_file mf ON mf.id = t.audio_file_id
|
||||
@@ -2087,8 +2350,14 @@ async fn tracks_by_ids_handler(
|
||||
duration_seconds: t.duration_seconds,
|
||||
artists: track_main_artists.remove(&tid).unwrap_or_default(),
|
||||
featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
|
||||
release_id: t.release_id,
|
||||
release_title: t.release_title,
|
||||
release_year: t.release_year,
|
||||
cover_url: track_cover_url(t.cover_file_id, t.release_cover_file_id),
|
||||
cover_url: track_cover_variant_url(
|
||||
t.cover_file_id,
|
||||
t.release_cover_file_id,
|
||||
"medium",
|
||||
),
|
||||
stream_url: format!("/api/player/stream/{tid}"),
|
||||
uploader_name: t.uploader_name,
|
||||
audio_format: t.audio_format,
|
||||
@@ -2096,6 +2365,10 @@ async fn tracks_by_ids_handler(
|
||||
audio_sample_rate: t.audio_sample_rate,
|
||||
audio_bit_depth: t.audio_bit_depth,
|
||||
file_size_bytes: t.file_size_bytes,
|
||||
lastfm_listeners: t.lastfm_listeners,
|
||||
lastfm_playcount: t.lastfm_playcount,
|
||||
lastfm_rating: t.lastfm_rating,
|
||||
lastfm_updated_at: t.lastfm_updated_at,
|
||||
},
|
||||
);
|
||||
}
|
||||
@@ -2268,9 +2541,7 @@ impl App for PlayerApp {
|
||||
.await;
|
||||
let service = torrent_service
|
||||
.get_or_init(|| async {
|
||||
Arc::new(TorrentService::new(Arc::clone(
|
||||
&scheduler_handle,
|
||||
)))
|
||||
Arc::new(TorrentService::new(Arc::clone(&scheduler_handle)))
|
||||
})
|
||||
.await;
|
||||
match service.details(pg_pool, user.id, &path.0.id).await {
|
||||
@@ -2282,7 +2553,8 @@ impl App for PlayerApp {
|
||||
}
|
||||
}
|
||||
})
|
||||
.delete(move |session: Session, db: Database, path: Path<PathStringId>| {
|
||||
.delete(
|
||||
move |session: Session, db: Database, path: Path<PathStringId>| {
|
||||
let pool = Arc::clone(&pool);
|
||||
let pool_config = Arc::clone(&pool_config);
|
||||
let torrent_service = Arc::clone(&torrent_service);
|
||||
@@ -2309,13 +2581,16 @@ impl App for PlayerApp {
|
||||
})
|
||||
.await;
|
||||
match service.remove(pg_pool, user.id, &path.0.id).await {
|
||||
Ok(()) => Json(serde_json::json!({ "ok": true })).into_response(),
|
||||
Ok(()) => {
|
||||
Json(serde_json::json!({ "ok": true })).into_response()
|
||||
}
|
||||
Err(err) => {
|
||||
Ok(json_error(StatusCode::NOT_FOUND, &err.to_string()))
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
},
|
||||
)
|
||||
},
|
||||
"player_torrent_detail",
|
||||
),
|
||||
@@ -2365,6 +2640,29 @@ impl App for PlayerApp {
|
||||
},
|
||||
"player_torrent_preview",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/uploads/local",
|
||||
{
|
||||
let scheduler_handle = Arc::clone(&self.scheduler_handle);
|
||||
post(
|
||||
move |session: Session, db: Database, request: cot::request::Request| {
|
||||
let scheduler_handle = Arc::clone(&scheduler_handle);
|
||||
async move {
|
||||
let (live_config, _) = AppConfig::load_with_db(&db).await;
|
||||
local_upload_handler(
|
||||
session,
|
||||
db,
|
||||
live_config,
|
||||
scheduler_handle,
|
||||
request,
|
||||
)
|
||||
.await
|
||||
}
|
||||
},
|
||||
)
|
||||
},
|
||||
"player_local_upload",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/torrents/{id}/start",
|
||||
{
|
||||
@@ -2431,7 +2729,8 @@ impl App for PlayerApp {
|
||||
let pool_config = Arc::clone(&pool_config);
|
||||
let torrent_service = Arc::clone(&torrent_service);
|
||||
let scheduler_handle = Arc::clone(&self.scheduler_handle);
|
||||
post(move |session: Session, db: Database, path: Path<PathStringId>| {
|
||||
post(
|
||||
move |session: Session, db: Database, path: Path<PathStringId>| {
|
||||
let pool = Arc::clone(&pool);
|
||||
let pool_config = Arc::clone(&pool_config);
|
||||
let torrent_service = Arc::clone(&torrent_service);
|
||||
@@ -2464,7 +2763,8 @@ impl App for PlayerApp {
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
},
|
||||
)
|
||||
},
|
||||
"player_torrent_pause",
|
||||
),
|
||||
@@ -2913,6 +3213,34 @@ impl App for PlayerApp {
|
||||
"player_stream",
|
||||
),
|
||||
// -- Cover art --
|
||||
Route::with_handler_and_name(
|
||||
"/cover/{media_file_id}/{variant}",
|
||||
{
|
||||
let pool = Arc::clone(&pool);
|
||||
let pool_config = Arc::clone(&pool_config);
|
||||
let config = Arc::clone(&self.config);
|
||||
get(
|
||||
move |session: Session, db: Database, path: Path<PathMediaFileVariant>| {
|
||||
let pool = Arc::clone(&pool);
|
||||
let pool_config = Arc::clone(&pool_config);
|
||||
let config = Arc::clone(&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("player pool")
|
||||
})
|
||||
.await;
|
||||
cover_variant_handler(session, db, pg_pool, &config, path).await
|
||||
}
|
||||
},
|
||||
)
|
||||
},
|
||||
"player_cover_variant",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/cover/{media_file_id}",
|
||||
{
|
||||
|
||||
@@ -70,3 +70,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,
|
||||
}
|
||||
|
||||
@@ -37,6 +37,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>,
|
||||
@@ -44,6 +46,10 @@ pub(super) struct TrackRow {
|
||||
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>,
|
||||
}
|
||||
|
||||
#[derive(sqlx::FromRow)]
|
||||
@@ -103,6 +109,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>,
|
||||
@@ -110,6 +118,10 @@ pub(super) struct PlaylistTrackRow {
|
||||
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>,
|
||||
}
|
||||
|
||||
#[derive(sqlx::FromRow)]
|
||||
@@ -128,6 +140,10 @@ pub(super) struct AppearanceTrackRow {
|
||||
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>,
|
||||
}
|
||||
|
||||
#[derive(sqlx::FromRow)]
|
||||
@@ -158,6 +174,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>,
|
||||
@@ -165,6 +183,10 @@ pub(super) struct SearchTrackRow {
|
||||
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>,
|
||||
}
|
||||
|
||||
#[derive(sqlx::FromRow)]
|
||||
|
||||
+11
-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,7 @@ 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 {
|
||||
if !live_config.agent_enabled && job_name != "lastfm_popularity" {
|
||||
tracing::warn!(job = job_name, "Skipping: agent_enabled=false");
|
||||
return;
|
||||
}
|
||||
|
||||
+321
-27
@@ -1,4 +1,4 @@
|
||||
use std::collections::HashMap;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
@@ -98,6 +98,7 @@ pub struct TorrentStartRequest {
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
enum TorrentJobStatus {
|
||||
Resolving,
|
||||
Preview,
|
||||
Downloading,
|
||||
Moving,
|
||||
@@ -110,6 +111,7 @@ impl TorrentJobStatus {
|
||||
fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Self::Preview => "preview",
|
||||
Self::Resolving => "resolving",
|
||||
Self::Downloading => "downloading",
|
||||
Self::Moving => "moving",
|
||||
Self::Complete => "complete",
|
||||
@@ -121,6 +123,7 @@ impl TorrentJobStatus {
|
||||
fn from_str(value: &str) -> Self {
|
||||
match value {
|
||||
"downloading" => Self::Downloading,
|
||||
"resolving" => Self::Resolving,
|
||||
"moving" => Self::Moving,
|
||||
"complete" => Self::Complete,
|
||||
"failed" => Self::Failed,
|
||||
@@ -194,10 +197,14 @@ impl TorrentSessionRow {
|
||||
self.status.as_str()
|
||||
};
|
||||
let stats = handle.map(|h| h.stats());
|
||||
let downloaded_bytes = stats
|
||||
let mut downloaded_bytes = stats
|
||||
.as_ref()
|
||||
.map(|s| s.progress_bytes)
|
||||
.unwrap_or_else(|| i64_to_u64(self.downloaded_bytes));
|
||||
let selected_size = i64_to_u64(self.selected_size);
|
||||
if status == "complete" {
|
||||
downloaded_bytes = selected_size;
|
||||
}
|
||||
let uploaded_bytes = stats
|
||||
.as_ref()
|
||||
.map(|s| s.uploaded_bytes)
|
||||
@@ -225,7 +232,7 @@ impl TorrentSessionRow {
|
||||
status: status.to_string(),
|
||||
client_state: stats.as_ref().map(|s| s.state.to_string()),
|
||||
total_size: i64_to_u64(self.total_size),
|
||||
selected_size: i64_to_u64(self.selected_size),
|
||||
selected_size,
|
||||
downloaded_bytes,
|
||||
uploaded_bytes,
|
||||
progress_percent,
|
||||
@@ -313,10 +320,14 @@ impl TorrentJob {
|
||||
|
||||
fn dto(&self) -> TorrentJobDto {
|
||||
let stats = self.handle.as_ref().map(|h| h.stats());
|
||||
let downloaded_bytes = stats
|
||||
let mut downloaded_bytes = stats
|
||||
.as_ref()
|
||||
.map(|s| s.progress_bytes)
|
||||
.unwrap_or(self.downloaded_bytes);
|
||||
let selected_size = self.selected_size();
|
||||
if self.status == TorrentJobStatus::Complete {
|
||||
downloaded_bytes = selected_size;
|
||||
}
|
||||
let uploaded_bytes = stats
|
||||
.as_ref()
|
||||
.map(|s| s.uploaded_bytes)
|
||||
@@ -336,7 +347,7 @@ impl TorrentJob {
|
||||
status: self.status.as_str().to_string(),
|
||||
client_state: stats.as_ref().map(|s| s.state.to_string()),
|
||||
total_size: self.total_size(),
|
||||
selected_size: self.selected_size(),
|
||||
selected_size,
|
||||
downloaded_bytes,
|
||||
uploaded_bytes,
|
||||
progress_percent: if self.status == TorrentJobStatus::Complete {
|
||||
@@ -364,6 +375,7 @@ pub struct TorrentService {
|
||||
temp_root: PathBuf,
|
||||
session: OnceCell<Arc<Session>>,
|
||||
jobs: Mutex<HashMap<String, TorrentJob>>,
|
||||
resolving_jobs: Mutex<HashSet<String>>,
|
||||
scheduler_handle: Arc<OnceCell<Arc<SchedulerHandle>>>,
|
||||
}
|
||||
|
||||
@@ -373,6 +385,7 @@ impl TorrentService {
|
||||
temp_root: std::env::temp_dir().join("furumusic").join("torrents"),
|
||||
session: OnceCell::new(),
|
||||
jobs: Mutex::new(HashMap::new()),
|
||||
resolving_jobs: Mutex::new(HashSet::new()),
|
||||
scheduler_handle,
|
||||
}
|
||||
}
|
||||
@@ -396,7 +409,11 @@ impl TorrentService {
|
||||
.cloned()
|
||||
}
|
||||
|
||||
pub async fn list(&self, pool: &PgPool, user_id: i64) -> anyhow::Result<Vec<TorrentJobDto>> {
|
||||
pub async fn list(
|
||||
self: &Arc<Self>,
|
||||
pool: &PgPool,
|
||||
user_id: i64,
|
||||
) -> anyhow::Result<Vec<TorrentJobDto>> {
|
||||
let rows = sqlx::query_as::<_, TorrentSessionRow>(
|
||||
r#"SELECT id, user_id, name, info_hash, source_kind, source_label, torrent_bytes,
|
||||
files_json, selected_files_json, status, total_size, selected_size,
|
||||
@@ -404,7 +421,7 @@ impl TorrentService {
|
||||
created_at, updated_at, completed_at
|
||||
FROM furumusic__torrent_session
|
||||
WHERE user_id = $1
|
||||
ORDER BY updated_at DESC, created_at DESC
|
||||
ORDER BY created_at DESC, id DESC
|
||||
LIMIT $2"#,
|
||||
)
|
||||
.bind(user_id)
|
||||
@@ -419,6 +436,21 @@ impl TorrentService {
|
||||
.collect::<HashMap<_, _>>()
|
||||
};
|
||||
|
||||
for row in rows.iter().filter(|row| row.status == "resolving") {
|
||||
if row.source_kind == "magnet" {
|
||||
if let Some(magnet) = row.source_label.clone() {
|
||||
self.spawn_resolve_pending_magnet(
|
||||
pool.clone(),
|
||||
user_id,
|
||||
row.id.clone(),
|
||||
magnet,
|
||||
row.created_at.clone(),
|
||||
)
|
||||
.await;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(rows
|
||||
.iter()
|
||||
.map(|row| row.dto(handles.get(&row.id)))
|
||||
@@ -447,7 +479,7 @@ impl TorrentService {
|
||||
}
|
||||
|
||||
pub async fn preview(
|
||||
&self,
|
||||
self: &Arc<Self>,
|
||||
pool: &PgPool,
|
||||
user_id: i64,
|
||||
request: TorrentPreviewRequest,
|
||||
@@ -465,17 +497,31 @@ impl TorrentService {
|
||||
.filter(|s| !s.is_empty())
|
||||
.map(str::to_owned);
|
||||
|
||||
let add = match request.kind {
|
||||
TorrentPreviewKind::Magnet => {
|
||||
if matches!(request.kind, TorrentPreviewKind::Magnet) {
|
||||
let magnet = request
|
||||
.magnet
|
||||
.as_deref()
|
||||
.map(str::trim)
|
||||
.filter(|s| !s.is_empty())
|
||||
.context("magnet link is empty")?;
|
||||
AddTorrent::from_url(magnet.to_string())
|
||||
.context("magnet link is empty")?
|
||||
.to_string();
|
||||
let info_hash = extract_magnet_info_hash(&magnet).context("invalid magnet link")?;
|
||||
let name = magnet_display_name(&magnet)
|
||||
.or(source_label)
|
||||
.unwrap_or_else(|| info_hash.clone());
|
||||
let now = now_string();
|
||||
insert_pending_magnet(pool, &id, user_id, &name, &info_hash, &magnet, &now).await?;
|
||||
self.spawn_resolve_pending_magnet(pool.clone(), user_id, id.clone(), magnet, now)
|
||||
.await;
|
||||
|
||||
let row = load_row(pool, user_id, &id).await?;
|
||||
return Ok(TorrentSessionDto {
|
||||
job: row.dto(None),
|
||||
preview: row.preview()?,
|
||||
selected_files: row.selected_files(),
|
||||
});
|
||||
}
|
||||
TorrentPreviewKind::TorrentFile => {
|
||||
|
||||
let encoded = request
|
||||
.torrent_base64
|
||||
.as_deref()
|
||||
@@ -484,23 +530,17 @@ impl TorrentService {
|
||||
let bytes = base64::engine::general_purpose::STANDARD
|
||||
.decode(encoded)
|
||||
.context("invalid torrent file encoding")?;
|
||||
AddTorrent::from_bytes(bytes)
|
||||
}
|
||||
};
|
||||
|
||||
let response = tokio::time::timeout(
|
||||
METADATA_TIMEOUT,
|
||||
session.add_torrent(
|
||||
add,
|
||||
let response = session
|
||||
.add_torrent(
|
||||
AddTorrent::from_bytes(bytes),
|
||||
Some(AddTorrentOptions {
|
||||
list_only: true,
|
||||
output_folder: Some(output_dir.to_string_lossy().to_string()),
|
||||
..Default::default()
|
||||
}),
|
||||
),
|
||||
)
|
||||
.await
|
||||
.context("timed out while resolving torrent metadata")??;
|
||||
.await?;
|
||||
|
||||
let AddTorrentResponse::ListOnly(list) = response else {
|
||||
bail!("torrent was unexpectedly added instead of previewed");
|
||||
@@ -564,6 +604,114 @@ impl TorrentService {
|
||||
Ok(dto)
|
||||
}
|
||||
|
||||
async fn spawn_resolve_pending_magnet(
|
||||
self: &Arc<Self>,
|
||||
pool: PgPool,
|
||||
user_id: i64,
|
||||
id: String,
|
||||
magnet: String,
|
||||
created_at: String,
|
||||
) {
|
||||
{
|
||||
let mut resolving = self.resolving_jobs.lock().await;
|
||||
if !resolving.insert(id.clone()) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
let service = Arc::clone(self);
|
||||
tokio::spawn(async move {
|
||||
let result = service
|
||||
.resolve_pending_magnet(&pool, user_id, &id, &magnet, &created_at)
|
||||
.await;
|
||||
if let Err(err) = result {
|
||||
update_resolving_error(&pool, &id, &err.to_string()).await;
|
||||
}
|
||||
service.resolving_jobs.lock().await.remove(&id);
|
||||
});
|
||||
}
|
||||
|
||||
async fn resolve_pending_magnet(
|
||||
&self,
|
||||
pool: &PgPool,
|
||||
user_id: i64,
|
||||
id: &str,
|
||||
magnet: &str,
|
||||
created_at: &str,
|
||||
) -> anyhow::Result<()> {
|
||||
let session = self.session().await?;
|
||||
let output_dir = self.temp_root.join(id).join("download");
|
||||
tokio::fs::create_dir_all(&output_dir).await?;
|
||||
let response = tokio::time::timeout(
|
||||
METADATA_TIMEOUT,
|
||||
session.add_torrent(
|
||||
AddTorrent::from_url(magnet.to_string()),
|
||||
Some(AddTorrentOptions {
|
||||
list_only: true,
|
||||
output_folder: Some(output_dir.to_string_lossy().to_string()),
|
||||
..Default::default()
|
||||
}),
|
||||
),
|
||||
)
|
||||
.await
|
||||
.context("timed out while resolving torrent metadata")??;
|
||||
|
||||
let AddTorrentResponse::ListOnly(list) = response else {
|
||||
bail!("torrent was unexpectedly added instead of previewed");
|
||||
};
|
||||
|
||||
let name = list
|
||||
.info
|
||||
.name
|
||||
.as_ref()
|
||||
.map(|b| String::from_utf8_lossy(b.as_ref()).to_string())
|
||||
.filter(|s| !s.is_empty())
|
||||
.or_else(|| magnet_display_name(magnet))
|
||||
.unwrap_or_else(|| list.info_hash.as_string());
|
||||
|
||||
let mut files = Vec::new();
|
||||
for (index, details) in list.info.iter_file_details()?.enumerate() {
|
||||
let name = details
|
||||
.filename
|
||||
.to_string()
|
||||
.unwrap_or_else(|_| "<invalid filename>".to_string());
|
||||
files.push(TorrentFileDto {
|
||||
index,
|
||||
name,
|
||||
components: details.filename.to_vec().unwrap_or_default(),
|
||||
length: details.len,
|
||||
selected: true,
|
||||
});
|
||||
}
|
||||
|
||||
let selected_files = files.iter().map(|f| f.index).collect::<Vec<_>>();
|
||||
let job = TorrentJob {
|
||||
id: id.to_string(),
|
||||
user_id,
|
||||
name,
|
||||
info_hash: list.info_hash.as_string(),
|
||||
source_kind: "magnet".to_string(),
|
||||
source_label: Some(magnet.to_string()),
|
||||
torrent_bytes: list.torrent_bytes.to_vec(),
|
||||
files,
|
||||
status: TorrentJobStatus::Preview,
|
||||
output_dir,
|
||||
selected_files,
|
||||
handle: None,
|
||||
downloaded_bytes: 0,
|
||||
uploaded_bytes: 0,
|
||||
progress_percent: 0.0,
|
||||
error: None,
|
||||
created_at: created_at.to_string(),
|
||||
updated_at: now_string(),
|
||||
completed_at: None,
|
||||
};
|
||||
|
||||
update_resolved_job(pool, &job).await?;
|
||||
self.jobs.lock().await.insert(id.to_string(), job);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn status(
|
||||
&self,
|
||||
pool: &PgPool,
|
||||
@@ -598,9 +746,8 @@ impl TorrentService {
|
||||
self.stop_torrent(&handle).await;
|
||||
}
|
||||
|
||||
let result = sqlx::query(
|
||||
"DELETE FROM furumusic__torrent_session WHERE id = $1 AND user_id = $2",
|
||||
)
|
||||
let result =
|
||||
sqlx::query("DELETE FROM furumusic__torrent_session WHERE id = $1 AND user_id = $2")
|
||||
.bind(id)
|
||||
.bind(user_id)
|
||||
.execute(pool)
|
||||
@@ -636,7 +783,12 @@ impl TorrentService {
|
||||
if job.user_id != uploader_user_id {
|
||||
bail!("torrent job not found");
|
||||
}
|
||||
if job.handle.is_some() && matches!(job.status, TorrentJobStatus::Downloading | TorrentJobStatus::Moving) {
|
||||
if job.handle.is_some()
|
||||
&& matches!(
|
||||
job.status,
|
||||
TorrentJobStatus::Downloading | TorrentJobStatus::Moving
|
||||
)
|
||||
{
|
||||
bail!("torrent job is already running");
|
||||
}
|
||||
validate_selection(&job.files, &selected_files)?;
|
||||
@@ -941,6 +1093,89 @@ async fn insert_job(pool: &PgPool, job: &TorrentJob) -> anyhow::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn insert_pending_magnet(
|
||||
pool: &PgPool,
|
||||
id: &str,
|
||||
user_id: i64,
|
||||
name: &str,
|
||||
info_hash: &str,
|
||||
magnet: &str,
|
||||
now: &str,
|
||||
) -> anyhow::Result<()> {
|
||||
sqlx::query(
|
||||
r#"INSERT INTO furumusic__torrent_session
|
||||
(id, user_id, name, info_hash, source_kind, source_label, torrent_bytes,
|
||||
files_json, selected_files_json, status, total_size, selected_size,
|
||||
downloaded_bytes, uploaded_bytes, progress_percent, error,
|
||||
created_at, updated_at, completed_at)
|
||||
VALUES ($1, $2, $3, $4, 'magnet', $5, $6,
|
||||
'[]', '[]', 'resolving', 0, 0,
|
||||
0, 0, 0, NULL,
|
||||
$7, $8, NULL)"#,
|
||||
)
|
||||
.bind(id)
|
||||
.bind(user_id)
|
||||
.bind(name)
|
||||
.bind(info_hash)
|
||||
.bind(magnet)
|
||||
.bind(Vec::<u8>::new())
|
||||
.bind(now)
|
||||
.bind(now)
|
||||
.execute(pool)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn update_resolved_job(pool: &PgPool, job: &TorrentJob) -> anyhow::Result<()> {
|
||||
sqlx::query(
|
||||
r#"UPDATE furumusic__torrent_session
|
||||
SET name = $2,
|
||||
info_hash = $3,
|
||||
torrent_bytes = $4,
|
||||
files_json = $5,
|
||||
selected_files_json = $6,
|
||||
status = 'preview',
|
||||
total_size = $7,
|
||||
selected_size = $8,
|
||||
downloaded_bytes = 0,
|
||||
uploaded_bytes = 0,
|
||||
progress_percent = 0,
|
||||
error = NULL,
|
||||
updated_at = $9,
|
||||
completed_at = NULL
|
||||
WHERE id = $1"#,
|
||||
)
|
||||
.bind(&job.id)
|
||||
.bind(&job.name)
|
||||
.bind(&job.info_hash)
|
||||
.bind(&job.torrent_bytes)
|
||||
.bind(serde_json::to_string(&job.files)?)
|
||||
.bind(serde_json::to_string(&job.selected_files)?)
|
||||
.bind(u64_to_i64(job.total_size()))
|
||||
.bind(u64_to_i64(job.selected_size()))
|
||||
.bind(&job.updated_at)
|
||||
.execute(pool)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn update_resolving_error(pool: &PgPool, id: &str, error: &str) {
|
||||
if let Err(err) = sqlx::query(
|
||||
r#"UPDATE furumusic__torrent_session
|
||||
SET error = $2,
|
||||
updated_at = $3
|
||||
WHERE id = $1 AND status = 'resolving'"#,
|
||||
)
|
||||
.bind(id)
|
||||
.bind(error)
|
||||
.bind(now_string())
|
||||
.execute(pool)
|
||||
.await
|
||||
{
|
||||
tracing::warn!("failed to persist torrent metadata resolving error: {err}");
|
||||
}
|
||||
}
|
||||
|
||||
async fn mark_job_started(
|
||||
pool: &PgPool,
|
||||
id: &str,
|
||||
@@ -1048,6 +1283,65 @@ fn i64_to_u64(value: i64) -> u64 {
|
||||
value.max(0) as u64
|
||||
}
|
||||
|
||||
fn extract_magnet_info_hash(magnet: &str) -> Option<String> {
|
||||
if !magnet.starts_with("magnet:?") {
|
||||
return None;
|
||||
}
|
||||
magnet
|
||||
.split(['?', '&'])
|
||||
.find_map(|part| part.strip_prefix("xt=urn:btih:"))
|
||||
.map(|hash| percent_decode(hash).to_ascii_lowercase())
|
||||
.filter(|hash| !hash.is_empty())
|
||||
}
|
||||
|
||||
fn magnet_display_name(magnet: &str) -> Option<String> {
|
||||
magnet
|
||||
.split(['?', '&'])
|
||||
.find_map(|part| part.strip_prefix("dn="))
|
||||
.map(percent_decode)
|
||||
.map(|value| value.trim().to_string())
|
||||
.filter(|value| !value.is_empty())
|
||||
}
|
||||
|
||||
fn percent_decode(value: &str) -> String {
|
||||
let bytes = value.as_bytes();
|
||||
let mut out = Vec::with_capacity(bytes.len());
|
||||
let mut index = 0;
|
||||
while index < bytes.len() {
|
||||
match bytes[index] {
|
||||
b'+' => {
|
||||
out.push(b' ');
|
||||
index += 1;
|
||||
}
|
||||
b'%' if index + 2 < bytes.len() => {
|
||||
let hi = hex_value(bytes[index + 1]);
|
||||
let lo = hex_value(bytes[index + 2]);
|
||||
if let (Some(hi), Some(lo)) = (hi, lo) {
|
||||
out.push((hi << 4) | lo);
|
||||
index += 3;
|
||||
} else {
|
||||
out.push(bytes[index]);
|
||||
index += 1;
|
||||
}
|
||||
}
|
||||
byte => {
|
||||
out.push(byte);
|
||||
index += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
String::from_utf8_lossy(&out).to_string()
|
||||
}
|
||||
|
||||
fn hex_value(byte: u8) -> Option<u8> {
|
||||
match byte {
|
||||
b'0'..=b'9' => Some(byte - b'0'),
|
||||
b'a'..=b'f' => Some(byte - b'a' + 10),
|
||||
b'A'..=b'F' => Some(byte - b'A' + 10),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn sanitize_path_component(value: &str) -> String {
|
||||
let sanitized: String = value
|
||||
.chars()
|
||||
|
||||
@@ -25,28 +25,76 @@
|
||||
</div>
|
||||
{% endif %}
|
||||
|
||||
{% if review.status_str() == "pending" %}
|
||||
<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;">
|
||||
{% 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>
|
||||
</form>
|
||||
<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 %}
|
||||
|
||||
+1179
-30
File diff suppressed because it is too large
Load Diff
+113
-18
@@ -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>
|
||||
@@ -64,6 +89,15 @@
|
||||
:class="{ error: $store.torrents.error }"
|
||||
x-text="$store.torrents.message"></p>
|
||||
</div>
|
||||
<button class="torrent-modal-close"
|
||||
@click="$store.torrents.close()"
|
||||
title="{{ t.player_close }}"
|
||||
aria-label="{{ t.player_close }}">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2">
|
||||
<line x1="18" y1="6" x2="6" y2="18"/>
|
||||
<line x1="6" y1="6" x2="18" y2="18"/>
|
||||
</svg>
|
||||
</button>
|
||||
<div class="torrent-client-status">
|
||||
<span class="torrent-status-pill"
|
||||
:class="{ active: $store.torrents.activeCount() > 0 }"
|
||||
@@ -74,7 +108,7 @@
|
||||
<span x-text="$store.torrents.agentSummary()"></span>
|
||||
</span>
|
||||
<span class="torrent-status-pill"
|
||||
x-text="$store.torrents.sessions.length + ' saved'"></span>
|
||||
x-text="$store.torrents.sessions.length + ' ' + T.saved"></span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
@@ -94,7 +128,7 @@
|
||||
</template>
|
||||
<template x-for="job in $store.torrents.sessions" :key="job.id">
|
||||
<div class="torrent-session-row"
|
||||
:class="{ active: $store.torrents.previewData && $store.torrents.previewData.id === job.id }"
|
||||
:class="{ active: $store.torrents.workspaceMode === 'session' && $store.torrents.previewData && $store.torrents.previewData.id === job.id }"
|
||||
@click="$store.torrents.openSession(job.id)">
|
||||
<div class="torrent-session-main">
|
||||
<div class="torrent-session-topline">
|
||||
@@ -109,19 +143,34 @@
|
||||
:style="'width:' + $store.torrents.progressValue(job) + '%'"></div>
|
||||
</div>
|
||||
</div>
|
||||
<button class="torrent-session-remove"
|
||||
@click.stop="$store.torrents.removeSession(job.id)">{{ t.player_delete }}</button>
|
||||
</div>
|
||||
</template>
|
||||
<button type="button"
|
||||
class="torrent-session-row torrent-session-add"
|
||||
:class="{ active: $store.torrents.isImporting() }"
|
||||
@click="$store.torrents.addNew()"
|
||||
:disabled="$store.torrents.loading">
|
||||
<span class="torrent-session-add-icon">+</span>
|
||||
<span>{{ t.player_upload }}</span>
|
||||
</button>
|
||||
</div>
|
||||
</aside>
|
||||
|
||||
<section class="torrent-workspace">
|
||||
<template x-if="$store.torrents.workspaceMode === 'empty'">
|
||||
<div class="empty-state torrent-workspace-empty">
|
||||
<p x-text="T.chooseSavedOrAddTorrent"></p>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<template x-if="$store.torrents.isImporting()">
|
||||
<div class="torrent-import-panel">
|
||||
<div class="torrent-modal-grid">
|
||||
<div>
|
||||
<label for="torrent-file-input">{{ t.player_torrent_file }}</label>
|
||||
<input id="torrent-file-input" type="file" accept=".torrent,application/x-bittorrent"
|
||||
@change="$store.torrents.file = $event.target.files[0] || null">
|
||||
<label for="local-file-input">{{ t.player_local_files }}</label>
|
||||
<input id="local-file-input" type="file" multiple accept="audio/*,.mp3,.flac,.wav,.m4a,.ogg,.opus,.aac"
|
||||
@change="$store.torrents.setLocalFiles($event.target.files)">
|
||||
<div class="torrent-upload-summary" x-text="$store.torrents.localUploadSummary()"></div>
|
||||
</div>
|
||||
<div>
|
||||
<label for="torrent-magnet-input">{{ t.player_magnet_link }}</label>
|
||||
@@ -129,13 +178,30 @@
|
||||
x-model="$store.torrents.magnet"
|
||||
placeholder="magnet:?xt=urn:btih:...">
|
||||
</div>
|
||||
<div>
|
||||
<label for="torrent-file-input">{{ t.player_torrent_file }}</label>
|
||||
<input id="torrent-file-input" type="file" accept=".torrent,application/x-bittorrent"
|
||||
@change="$store.torrents.file = $event.target.files[0] || null">
|
||||
</div>
|
||||
</div>
|
||||
<div class="torrent-upload-progress"
|
||||
x-show="$store.torrents.uploadProgress > 0 || ($store.torrents.localFiles.length > 0 && $store.torrents.loading)">
|
||||
<div class="torrent-progress-head">
|
||||
<span x-text="$store.torrents.uploadProgress >= 100 ? T.uploadComplete : T.uploadingFiles"></span>
|
||||
<span x-text="$store.torrents.uploadProgressText"></span>
|
||||
</div>
|
||||
<div class="torrent-progress-track">
|
||||
<div class="torrent-progress-bar"
|
||||
:style="'width:' + $store.torrents.uploadProgress + '%'"></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="torrent-actions">
|
||||
<button class="modal-btn modal-btn-primary" @click="$store.torrents.preview()" :disabled="$store.torrents.loading">
|
||||
{{ t.player_preview_content }}
|
||||
{{ t.player_upload_content }}
|
||||
</button>
|
||||
<button class="modal-btn modal-btn-ghost" @click="$store.torrents.clearSelection()" :disabled="!$store.torrents.previewData">{{ t.player_clear }}</button>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<template x-if="$store.torrents.currentJob">
|
||||
<div class="torrent-progress-card">
|
||||
@@ -147,10 +213,32 @@
|
||||
<div class="torrent-progress-bar"
|
||||
:style="'width:' + $store.torrents.progressValue($store.torrents.currentJob) + '%'"></div>
|
||||
</div>
|
||||
<div class="torrent-progress-details">
|
||||
<span x-text="$store.torrents.bytes($store.torrents.currentJob.downloaded_bytes) + ' / ' + $store.torrents.bytes($store.torrents.currentJob.selected_size || $store.torrents.currentJob.total_size)"></span>
|
||||
<span x-text="$store.torrents.speedText($store.torrents.currentJob)"></span>
|
||||
<span x-text="$store.torrents.peerText($store.torrents.currentJob)"></span>
|
||||
<div class="torrent-progress-details"
|
||||
:class="{ completed: $store.torrents.isCompleted($store.torrents.currentJob) }">
|
||||
<span class="torrent-progress-metric">
|
||||
<span class="torrent-progress-label"
|
||||
x-text="$store.torrents.isCompleted($store.torrents.currentJob) ? T.size : T.downloaded"></span>
|
||||
<span class="torrent-progress-value"
|
||||
x-text="$store.torrents.progressDetailText($store.torrents.currentJob)"></span>
|
||||
</span>
|
||||
<span class="torrent-progress-metric"
|
||||
x-show="!$store.torrents.isCompleted($store.torrents.currentJob)">
|
||||
<span class="torrent-progress-label" x-text="T.speed"></span>
|
||||
<span class="torrent-progress-value"
|
||||
x-text="$store.torrents.speedText($store.torrents.currentJob)"></span>
|
||||
</span>
|
||||
<span class="torrent-progress-metric"
|
||||
x-show="!$store.torrents.isCompleted($store.torrents.currentJob)">
|
||||
<span class="torrent-progress-label" x-text="T.peers"></span>
|
||||
<span class="torrent-progress-value"
|
||||
x-text="$store.torrents.peerText($store.torrents.currentJob)"></span>
|
||||
</span>
|
||||
<span class="torrent-progress-metric"
|
||||
x-show="!$store.torrents.isCompleted($store.torrents.currentJob) && $store.torrents.etaText($store.torrents.currentJob)">
|
||||
<span class="torrent-progress-label" x-text="T.eta"></span>
|
||||
<span class="torrent-progress-value"
|
||||
x-text="$store.torrents.etaText($store.torrents.currentJob)"></span>
|
||||
</span>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
@@ -162,12 +250,19 @@
|
||||
<div class="torrent-preview-meta"
|
||||
x-text="$store.torrents.previewData.files.length + ' {{ t.player_files_count }} - ' + $store.torrents.bytes($store.torrents.previewData.total_size)"></div>
|
||||
</div>
|
||||
<div class="torrent-preview-actions">
|
||||
<button class="modal-btn"
|
||||
:class="$store.torrents.isCurrentDownloading() ? 'modal-btn-pause' : 'modal-btn-primary'"
|
||||
@click="$store.torrents.isCurrentDownloading() ? $store.torrents.pause() : $store.torrents.start()"
|
||||
:disabled="$store.torrents.loading">
|
||||
<span x-text="$store.torrents.isCurrentDownloading() ? '{{ t.player_pause_download }}' : '{{ t.player_download_selected }}'"></span>
|
||||
:class="$store.torrents.actionButtonClass()"
|
||||
@click="$store.torrents.toggleDownloadAction()"
|
||||
:disabled="$store.torrents.actionButtonDisabled()">
|
||||
<span x-text="$store.torrents.actionButtonText()"></span>
|
||||
</button>
|
||||
<button class="modal-btn modal-btn-danger"
|
||||
@click="$store.torrents.removeSession($store.torrents.previewData.id)"
|
||||
:disabled="$store.torrents.loading">
|
||||
{{ t.player_delete }}
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
<div class="torrent-tree-toolbar">
|
||||
<div class="torrent-selected-summary"
|
||||
|
||||
+452
-37
@@ -3,11 +3,15 @@
|
||||
const T = {
|
||||
info: "{{ t.player_info }}",
|
||||
noDetails: "{{ t.player_no_details }}",
|
||||
trackInfoTitle: "{{ t.player_track_info }}",
|
||||
releaseInfoTitle: "{{ t.player_release_info }}",
|
||||
loadingHistory: "{{ t.player_loading_history }}",
|
||||
failedLoadHistory: "{{ t.player_failed_load_history }}",
|
||||
totalPlays: "{{ t.player_total_plays }}",
|
||||
unknown: "{{ t.player_unknown }}",
|
||||
unknownSize: "{{ t.player_unknown_size }}",
|
||||
title: "{{ t.player_title }}",
|
||||
release: "{{ t.player_release }}",
|
||||
unknownRelease: "{{ t.player_unknown_release }}",
|
||||
unknownTrack: "{{ t.player_unknown_track }}",
|
||||
unknownAudio: "{{ t.player_unknown_audio }}",
|
||||
@@ -21,6 +25,11 @@ const T = {
|
||||
audio: "{{ t.player_audio }}",
|
||||
size: "{{ t.player_size }}",
|
||||
uploader: "{{ t.player_uploader }}",
|
||||
lastfmRating: "{{ t.player_lastfm_rating }}",
|
||||
lastfmListeners: "{{ t.player_lastfm_listeners }}",
|
||||
lastfmPlaycount: "{{ t.player_lastfm_playcount }}",
|
||||
lastfmUpdated: "{{ t.player_lastfm_updated }}",
|
||||
lastfmNotLoaded: "{{ t.player_lastfm_not_loaded }}",
|
||||
trackWord: "{{ t.player_tracks_count }}",
|
||||
clientIdle: "{{ t.player_client_idle }}",
|
||||
active: "{{ t.player_active }}",
|
||||
@@ -29,13 +38,20 @@ const T = {
|
||||
processing: "{{ t.player_processing }}",
|
||||
queued: "{{ t.player_queued }}",
|
||||
saved: "{{ t.player_saved }}",
|
||||
chooseSavedOrAddTorrent: "{{ t.player_choose_saved_or_add_torrent }}",
|
||||
uploadFailed: "{{ t.player_upload_failed }}",
|
||||
uploadComplete: "{{ t.player_upload_complete }}",
|
||||
uploadingFiles: "{{ t.player_uploading_files }}",
|
||||
preview: "{{ t.player_preview }}",
|
||||
resolving: "{{ t.player_resolving }}",
|
||||
downloading: "{{ t.player_downloading }}",
|
||||
moving: "{{ t.player_moving }}",
|
||||
completed: "{{ t.player_completed }}",
|
||||
failed: "{{ t.player_failed }}",
|
||||
paused: "{{ t.player_paused }}",
|
||||
noTorrentSelected: "{{ t.player_no_torrent_selected }}",
|
||||
downloaded: "{{ t.player_downloaded }}",
|
||||
speed: "{{ t.player_speed }}",
|
||||
down: "{{ t.player_down }}",
|
||||
up: "{{ t.player_up }}",
|
||||
peers: "{{ t.player_peers }}",
|
||||
@@ -43,6 +59,8 @@ const T = {
|
||||
seen: "{{ t.player_seen }}",
|
||||
eta: "{{ t.player_eta }}",
|
||||
selected: "{{ t.player_selected }}",
|
||||
downloadSelected: "{{ t.player_download_selected }}",
|
||||
pauseDownload: "{{ t.player_pause_download }}",
|
||||
chooseTorrent: "{{ t.player_choose_torrent }}",
|
||||
readingTorrent: "{{ t.player_reading_torrent }}",
|
||||
resolvingMagnet: "{{ t.player_resolving_magnet }}",
|
||||
@@ -83,6 +101,11 @@ function formatTime(seconds) {
|
||||
return m + ':' + (sec < 10 ? '0' : '') + sec;
|
||||
}
|
||||
|
||||
function coverVariantUrl(url, variant) {
|
||||
if (!url) return url;
|
||||
return url.replace(/\/(small|medium|large)$/, '/' + variant);
|
||||
}
|
||||
|
||||
document.addEventListener('alpine:init', () => {
|
||||
// -----------------------------------------------------------------------
|
||||
// Audio element
|
||||
@@ -104,14 +127,33 @@ document.addEventListener('alpine:init', () => {
|
||||
Alpine.store('info', {
|
||||
modal: null,
|
||||
open(title, body) {
|
||||
if (Array.isArray(body)) {
|
||||
this.openRows(title, body);
|
||||
return;
|
||||
}
|
||||
this.modal = {
|
||||
title: title || T.info,
|
||||
body: body || T.noDetails,
|
||||
rows: null,
|
||||
};
|
||||
},
|
||||
openRows(title, rows) {
|
||||
this.modal = {
|
||||
title: title || T.info,
|
||||
body: '',
|
||||
rows: (rows || []).filter(row => row && ((row.value !== undefined && row.value !== null && row.value !== '') || (row.links && row.links.length))),
|
||||
};
|
||||
},
|
||||
close() {
|
||||
this.modal = null;
|
||||
},
|
||||
navigate(link) {
|
||||
if (!link || !link.id) return;
|
||||
this.close();
|
||||
const library = Alpine.store('library');
|
||||
if (link.type === 'release') library.openRelease(link.id);
|
||||
if (link.type === 'artist') library.openArtist(link.id);
|
||||
},
|
||||
});
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
@@ -426,7 +468,7 @@ document.addEventListener('alpine:init', () => {
|
||||
navigator.mediaSession.metadata = new MediaMetadata({
|
||||
title: t.title,
|
||||
artist: t.artists.map(a => a.name).join(', '),
|
||||
artwork: t.cover_url ? [{ src: t.cover_url, sizes: '512x512', type: 'image/jpeg' }] : [],
|
||||
artwork: t.cover_url ? [{ src: coverVariantUrl(t.cover_url, 'large'), sizes: '512x512', type: 'image/jpeg' }] : [],
|
||||
});
|
||||
navigator.mediaSession.setActionHandler('play', () => this.resume());
|
||||
navigator.mediaSession.setActionHandler('pause', () => this.pause());
|
||||
@@ -620,6 +662,8 @@ document.addEventListener('alpine:init', () => {
|
||||
searchResults: null,
|
||||
searchLoading: false,
|
||||
_previousView: 'artists',
|
||||
_activeHash: location.hash || '#artists',
|
||||
_scrollPositions: {},
|
||||
|
||||
_hashNav: false, // guard against circular hash updates
|
||||
|
||||
@@ -629,26 +673,31 @@ document.addEventListener('alpine:init', () => {
|
||||
|
||||
// Listen for browser back/forward
|
||||
window.addEventListener('hashchange', () => {
|
||||
this._navigateFromHash();
|
||||
if (this._hashNav) return;
|
||||
const nextHash = location.hash || '#artists';
|
||||
this._saveScrollPosition(this._activeHash);
|
||||
this._activeHash = nextHash;
|
||||
this._navigateFromHash({ fromHash: true, restoreScroll: true });
|
||||
});
|
||||
|
||||
// Navigate to initial hash (if any)
|
||||
this._navigateFromHash();
|
||||
this._navigateFromHash({ fromHash: true, restoreScroll: true });
|
||||
},
|
||||
|
||||
_setHash(hash) {
|
||||
this._hashNav = true;
|
||||
this._activeHash = hash;
|
||||
location.hash = hash;
|
||||
// Reset guard after a tick
|
||||
setTimeout(() => { this._hashNav = false; }, 0);
|
||||
},
|
||||
|
||||
_navigateFromHash() {
|
||||
_navigateFromHash(options = {}) {
|
||||
if (this._hashNav) return;
|
||||
const hash = location.hash || '#artists';
|
||||
const match = hash.match(/^#(\w+)(?:\/([-]?\d+))?(?:\?(.*))?$/);
|
||||
if (!match) {
|
||||
this.goArtists();
|
||||
this.goArtists(options);
|
||||
return;
|
||||
}
|
||||
const view = match[1];
|
||||
@@ -656,26 +705,74 @@ document.addEventListener('alpine:init', () => {
|
||||
const params = match[3] || '';
|
||||
|
||||
if (view === 'artists' && !id) {
|
||||
if (this.view !== 'artists') this.goArtists();
|
||||
if (this.view !== 'artists') this.goArtists(options);
|
||||
else if (options.restoreScroll) this._restoreScrollPosition(hash);
|
||||
} else if (view === 'artist' && id) {
|
||||
this.openArtist(id);
|
||||
this.openArtist(id, options);
|
||||
} else if (view === 'release' && id) {
|
||||
this.openRelease(id);
|
||||
this.openRelease(id, options);
|
||||
} else if (view === 'playlist' && id) {
|
||||
this.openPlaylist(id);
|
||||
this.openPlaylist(id, options);
|
||||
} else if (view === 'search') {
|
||||
const qMatch = params.match(/q=([^&]*)/);
|
||||
if (qMatch) {
|
||||
const q = decodeURIComponent(qMatch[1]);
|
||||
this.searchQuery = q;
|
||||
this.search(q);
|
||||
this.search(q, options);
|
||||
}
|
||||
} else {
|
||||
this.goArtists();
|
||||
this.goArtists(options);
|
||||
}
|
||||
},
|
||||
|
||||
goArtists() {
|
||||
_scrollElement() {
|
||||
return document.getElementById('center-scroll');
|
||||
},
|
||||
|
||||
_saveScrollPosition(hash = this._activeHash) {
|
||||
const el = this._scrollElement();
|
||||
if (!el || !hash) return;
|
||||
this._scrollPositions[hash] = el.scrollTop;
|
||||
},
|
||||
|
||||
_scrollToTop() {
|
||||
const el = this._scrollElement();
|
||||
if (el) el.scrollTop = 0;
|
||||
},
|
||||
|
||||
_restoreScrollPosition(hash = this._activeHash) {
|
||||
const top = this._scrollPositions[hash];
|
||||
if (top == null) return;
|
||||
const restore = () => {
|
||||
const el = this._scrollElement();
|
||||
if (el) el.scrollTop = top;
|
||||
};
|
||||
this.$nextTick(() => {
|
||||
restore();
|
||||
requestAnimationFrame(restore);
|
||||
setTimeout(restore, 150);
|
||||
});
|
||||
},
|
||||
|
||||
_afterNavigation(options = {}) {
|
||||
if (options.restoreScroll) {
|
||||
this._restoreScrollPosition(this._activeHash);
|
||||
} else {
|
||||
this.$nextTick(() => { this._scrollToTop(); });
|
||||
}
|
||||
},
|
||||
|
||||
_beginNavigation(hash, options = {}) {
|
||||
if (!options.fromHash) {
|
||||
this._saveScrollPosition(this._activeHash);
|
||||
this._setHash(hash);
|
||||
} else {
|
||||
this._activeHash = hash;
|
||||
}
|
||||
},
|
||||
|
||||
goArtists(options = {}) {
|
||||
this._beginNavigation('#artists', options);
|
||||
this.view = 'artists';
|
||||
this.currentArtist = null;
|
||||
this.currentRelease = null;
|
||||
@@ -683,8 +780,8 @@ document.addEventListener('alpine:init', () => {
|
||||
this.searchQuery = '';
|
||||
this.searchResults = null;
|
||||
this._previousView = 'artists';
|
||||
this._setHash('#artists');
|
||||
this.$nextTick(() => { this._setupScroll(); });
|
||||
this._afterNavigation(options);
|
||||
},
|
||||
|
||||
async loadArtists(page) {
|
||||
@@ -708,17 +805,18 @@ document.addEventListener('alpine:init', () => {
|
||||
this.loading = false;
|
||||
},
|
||||
|
||||
async openArtist(id) {
|
||||
async openArtist(id, options = {}) {
|
||||
this._beginNavigation('#artist/' + id, options);
|
||||
this.searchQuery = '';
|
||||
this.searchResults = null;
|
||||
this.view = 'artist_detail';
|
||||
this.currentArtist = null;
|
||||
this._setHash('#artist/' + id);
|
||||
try {
|
||||
const res = await fetch(`/api/player/artists/${id}`);
|
||||
if (!res.ok) throw new Error('failed');
|
||||
this.currentArtist = await res.json();
|
||||
} catch {}
|
||||
this._afterNavigation(options);
|
||||
},
|
||||
|
||||
artistReleaseGroups() {
|
||||
@@ -778,6 +876,47 @@ document.addEventListener('alpine:init', () => {
|
||||
return (idx === 0 ? size.toFixed(0) : size.toFixed(1)) + ' ' + units[idx];
|
||||
},
|
||||
|
||||
trackPopularityValue(track) {
|
||||
const value = Number(track?.lastfm_rating);
|
||||
return Number.isFinite(value) && value > 0 ? value : null;
|
||||
},
|
||||
|
||||
hasPopularity(track) {
|
||||
return this.trackPopularityValue(track) != null;
|
||||
},
|
||||
|
||||
popularityLabel(track) {
|
||||
const value = this.trackPopularityValue(track);
|
||||
if (value == null) return 'i';
|
||||
if (value >= 10000) return Math.round(value / 1000) + 'k';
|
||||
if (value >= 1000) return (value / 1000).toFixed(1).replace(/\.0$/, '') + 'k';
|
||||
return Math.round(value).toString();
|
||||
},
|
||||
|
||||
popularityStyle(track) {
|
||||
const value = this.trackPopularityValue(track);
|
||||
if (value == null) return '';
|
||||
const t = Math.max(0, Math.min(1, Math.log1p(value) / Math.log1p(180)));
|
||||
const hue = 210 - (190 * t);
|
||||
const saturation = 42 + (46 * t);
|
||||
const lightness = 30 + (16 * t);
|
||||
const bg = `hsla(${hue.toFixed(0)}, ${saturation.toFixed(0)}%, ${lightness.toFixed(0)}%, 0.28)`;
|
||||
const hoverBg = `hsla(${hue.toFixed(0)}, ${saturation.toFixed(0)}%, ${Math.min(54, lightness + 6).toFixed(0)}%, 0.36)`;
|
||||
const border = `hsla(${hue.toFixed(0)}, ${saturation.toFixed(0)}%, ${Math.min(66, lightness + 16).toFixed(0)}%, 0.52)`;
|
||||
const fg = `hsl(${hue.toFixed(0)}, ${Math.min(96, saturation + 8).toFixed(0)}%, ${Math.min(86, lightness + 34).toFixed(0)}%)`;
|
||||
return `--popularity-bg:${bg};--popularity-hover-bg:${hoverBg};--popularity-border:${border};--popularity-fg:${fg}`;
|
||||
},
|
||||
|
||||
trackInfoTitle(track) {
|
||||
const value = this.trackPopularityValue(track);
|
||||
if (value == null) return this.trackInfo(track);
|
||||
return `${T.lastfmRating}: ${Math.round(value)}\n${this.trackInfo(track)}`;
|
||||
},
|
||||
|
||||
openTrackInfo(track) {
|
||||
Alpine.store('info').openRows(T.trackInfoTitle, this.trackInfoRows(track));
|
||||
},
|
||||
|
||||
uploadersInfo(uploaders) {
|
||||
const rows = uploaders || [];
|
||||
if (!rows.length) return 'UFO';
|
||||
@@ -798,6 +937,31 @@ document.addEventListener('alpine:init', () => {
|
||||
return lines.join('\n');
|
||||
},
|
||||
|
||||
openReleaseInfo(release) {
|
||||
Alpine.store('info').openRows(T.releaseInfoTitle, this.releaseInfoRows(release));
|
||||
},
|
||||
|
||||
infoLinks(items, type) {
|
||||
const seen = new Set();
|
||||
return (items || [])
|
||||
.filter(item => item && item.id && !seen.has(Number(item.id)) && seen.add(Number(item.id)))
|
||||
.map(item => ({ type, id: item.id, label: item.label || item.name || item.title || String(item.id) }));
|
||||
},
|
||||
|
||||
releaseInfoRows(release) {
|
||||
if (!release) return [];
|
||||
const rows = [
|
||||
{ label: T.release, value: release.title || T.unknownRelease },
|
||||
{ label: T.type, value: release.release_type || T.unknown },
|
||||
{ label: T.year, value: release.year || T.unknown },
|
||||
{ label: T.tracks, value: release.track_count || release.tracks?.length || 0 },
|
||||
{ label: T.uploaders, value: this.uploadersInfo(release.uploaders || []) },
|
||||
];
|
||||
const artistLinks = this.infoLinks(release.artists || [], 'artist');
|
||||
if (artistLinks.length) rows.splice(1, 0, { label: T.artists, links: artistLinks });
|
||||
return rows;
|
||||
},
|
||||
|
||||
trackInfo(track) {
|
||||
if (!track) return '';
|
||||
const artists = this.trackArtistLinks(track).map(artist => artist.label).join(', ') || T.unknown;
|
||||
@@ -816,31 +980,76 @@ document.addEventListener('alpine:init', () => {
|
||||
`${T.size}: ${this.bytes(track.file_size_bytes)}`,
|
||||
`${T.uploader}: ${track.uploader_name || 'UFO'}`,
|
||||
];
|
||||
if (track.lastfm_rating != null || track.lastfm_listeners != null || track.lastfm_playcount != null) {
|
||||
const rating = Number(track.lastfm_rating || 0);
|
||||
lines.push(`${T.lastfmRating}: ${Number.isFinite(rating) ? Math.round(rating) : T.unknown}`);
|
||||
lines.push(`${T.lastfmListeners}: ${new Intl.NumberFormat().format(track.lastfm_listeners || 0)}`);
|
||||
lines.push(`${T.lastfmPlaycount}: ${new Intl.NumberFormat().format(track.lastfm_playcount || 0)}`);
|
||||
if (track.lastfm_updated_at) lines.push(`${T.lastfmUpdated}: ${track.lastfm_updated_at}`);
|
||||
} else {
|
||||
lines.push(`${T.lastfmRating}: ${T.lastfmNotLoaded}`);
|
||||
}
|
||||
return lines.join('\n');
|
||||
},
|
||||
|
||||
async openRelease(id) {
|
||||
trackInfoRows(track) {
|
||||
if (!track) return [];
|
||||
const artistLinks = this.infoLinks(this.trackArtistLinks(track), 'artist');
|
||||
const releaseLinks = track.release_id
|
||||
? [{ type: 'release', id: track.release_id, label: track.release_title || T.unknownRelease }]
|
||||
: [];
|
||||
const audio = [
|
||||
track.audio_format || null,
|
||||
track.audio_bitrate ? `${track.audio_bitrate} kbps` : null,
|
||||
track.audio_sample_rate ? `${track.audio_sample_rate} Hz` : null,
|
||||
track.audio_bit_depth ? `${track.audio_bit_depth}-bit` : null,
|
||||
].filter(Boolean).join(' · ') || T.unknownAudio;
|
||||
const rows = [
|
||||
{ label: T.title, value: track.title || T.unknownTrack },
|
||||
{ label: T.release, links: releaseLinks },
|
||||
{ label: T.artists, links: artistLinks },
|
||||
{ label: T.releaseYear, value: track.release_year || T.unknown },
|
||||
{ label: T.duration, value: formatTime(track.duration_seconds) },
|
||||
{ label: T.audio, value: audio },
|
||||
{ label: T.size, value: this.bytes(track.file_size_bytes) },
|
||||
{ label: T.uploader, value: track.uploader_name || 'UFO' },
|
||||
];
|
||||
if (track.lastfm_rating != null || track.lastfm_listeners != null || track.lastfm_playcount != null) {
|
||||
const rating = Number(track.lastfm_rating || 0);
|
||||
rows.push({ label: T.lastfmRating, value: Number.isFinite(rating) ? Math.round(rating) : T.unknown });
|
||||
rows.push({ label: T.lastfmListeners, value: new Intl.NumberFormat().format(track.lastfm_listeners || 0) });
|
||||
rows.push({ label: T.lastfmPlaycount, value: new Intl.NumberFormat().format(track.lastfm_playcount || 0) });
|
||||
if (track.lastfm_updated_at) rows.push({ label: T.lastfmUpdated, value: track.lastfm_updated_at });
|
||||
} else {
|
||||
rows.push({ label: T.lastfmRating, value: T.lastfmNotLoaded });
|
||||
}
|
||||
return rows;
|
||||
},
|
||||
|
||||
async openRelease(id, options = {}) {
|
||||
this._beginNavigation('#release/' + id, options);
|
||||
this.searchQuery = '';
|
||||
this.searchResults = null;
|
||||
this.view = 'release_detail';
|
||||
this.currentRelease = null;
|
||||
this._setHash('#release/' + id);
|
||||
try {
|
||||
const res = await fetch(`/api/player/releases/${id}`);
|
||||
if (!res.ok) throw new Error('failed');
|
||||
this.currentRelease = await res.json();
|
||||
} catch {}
|
||||
this._afterNavigation(options);
|
||||
},
|
||||
|
||||
async openPlaylist(id) {
|
||||
async openPlaylist(id, options = {}) {
|
||||
this._beginNavigation('#playlist/' + id, options);
|
||||
this.view = 'playlist_detail';
|
||||
this.currentPlaylist = null;
|
||||
this._setHash('#playlist/' + id);
|
||||
try {
|
||||
const res = await fetch(`/api/player/playlists/${id}`);
|
||||
if (!res.ok) throw new Error('failed');
|
||||
this.currentPlaylist = await res.json();
|
||||
} catch {}
|
||||
this._afterNavigation(options);
|
||||
},
|
||||
|
||||
async playRelease(releaseId) {
|
||||
@@ -876,17 +1085,17 @@ document.addEventListener('alpine:init', () => {
|
||||
} catch {}
|
||||
},
|
||||
|
||||
async search(query) {
|
||||
async search(query, options = {}) {
|
||||
const q = (query || '').trim();
|
||||
if (!q) {
|
||||
this.clearSearch();
|
||||
return;
|
||||
}
|
||||
this._beginNavigation('#search?q=' + encodeURIComponent(q), options);
|
||||
if (this.view !== 'search') {
|
||||
this._previousView = this.view;
|
||||
}
|
||||
this.view = 'search';
|
||||
this._setHash('#search?q=' + encodeURIComponent(q));
|
||||
this.searchLoading = true;
|
||||
try {
|
||||
const res = await fetch(`/api/player/search?q=${encodeURIComponent(q)}&limit=10`);
|
||||
@@ -896,6 +1105,7 @@ document.addEventListener('alpine:init', () => {
|
||||
this.searchResults = { artists: [], releases: [], tracks: [] };
|
||||
}
|
||||
this.searchLoading = false;
|
||||
this._afterNavigation(options);
|
||||
},
|
||||
|
||||
clearSearch() {
|
||||
@@ -1078,11 +1288,13 @@ document.addEventListener('alpine:init', () => {
|
||||
Alpine.store('torrents', {
|
||||
modal: false,
|
||||
file: null,
|
||||
localFiles: [],
|
||||
magnet: '',
|
||||
sessions: [],
|
||||
loadingSessions: false,
|
||||
currentJob: null,
|
||||
previewData: null,
|
||||
workspaceMode: 'empty',
|
||||
treeRoot: null,
|
||||
selected: new Set(),
|
||||
expanded: new Set(),
|
||||
@@ -1090,10 +1302,13 @@ document.addEventListener('alpine:init', () => {
|
||||
message: '',
|
||||
error: false,
|
||||
_pollTimer: null,
|
||||
_pollJobId: null,
|
||||
_refreshTimer: null,
|
||||
queuedTasks: 0,
|
||||
processingTasks: 0,
|
||||
loadingAgentStatus: false,
|
||||
uploadProgress: 0,
|
||||
uploadProgressText: '',
|
||||
|
||||
open() {
|
||||
this.modal = true;
|
||||
@@ -1107,6 +1322,34 @@ document.addEventListener('alpine:init', () => {
|
||||
close() {
|
||||
this.modal = false;
|
||||
this._stopRefresh();
|
||||
this._stopPoll();
|
||||
},
|
||||
|
||||
_stopPoll() {
|
||||
if (this._pollTimer) clearInterval(this._pollTimer);
|
||||
this._pollTimer = null;
|
||||
this._pollJobId = null;
|
||||
},
|
||||
|
||||
isImporting() {
|
||||
return this.workspaceMode === 'new';
|
||||
},
|
||||
|
||||
addNew() {
|
||||
if (this.loading) return;
|
||||
this._stopPoll();
|
||||
this.workspaceMode = 'new';
|
||||
this.file = null;
|
||||
this.localFiles = [];
|
||||
this.magnet = '';
|
||||
this.uploadProgress = 0;
|
||||
this.uploadProgressText = '';
|
||||
this.currentJob = null;
|
||||
this.previewData = null;
|
||||
this.treeRoot = null;
|
||||
this.selected = new Set();
|
||||
this.expanded = new Set();
|
||||
this._setMessage(T.chooseTorrent);
|
||||
},
|
||||
|
||||
_setMessage(message, error = false) {
|
||||
@@ -1138,6 +1381,35 @@ document.addEventListener('alpine:init', () => {
|
||||
return this.isDownloading(this.currentJob);
|
||||
},
|
||||
|
||||
isCompleted(job) {
|
||||
return this.normalizedStatus(job) === 'completed';
|
||||
},
|
||||
|
||||
isCurrentCompleted() {
|
||||
return this.isCompleted(this.currentJob);
|
||||
},
|
||||
|
||||
selectedArray() {
|
||||
return [...this.selected].sort((a, b) => Number(a) - Number(b));
|
||||
},
|
||||
|
||||
selectionMatchesJob(job) {
|
||||
if (!job) return false;
|
||||
const saved = Array.isArray(job.selected_files) ? job.selected_files : [];
|
||||
const selected = this.selectedArray();
|
||||
if (saved.length !== selected.length) return false;
|
||||
const savedSet = new Set(saved.map(index => Number(index)));
|
||||
return selected.every(index => savedSet.has(Number(index)));
|
||||
},
|
||||
|
||||
hasCurrentSelectionChanges() {
|
||||
return !!this.currentJob && !this.selectionMatchesJob(this.currentJob);
|
||||
},
|
||||
|
||||
isCurrentCompletedLocked() {
|
||||
return this.isCurrentCompleted() && !this.hasCurrentSelectionChanges();
|
||||
},
|
||||
|
||||
normalizedStatus(job) {
|
||||
const status = String(job?.status || 'preview').toLowerCase();
|
||||
if (status === 'complete') return 'completed';
|
||||
@@ -1147,6 +1419,7 @@ document.addEventListener('alpine:init', () => {
|
||||
statusLabel(job) {
|
||||
const labels = {
|
||||
preview: T.preview,
|
||||
resolving: T.resolving,
|
||||
downloading: T.downloading,
|
||||
moving: T.moving,
|
||||
completed: T.completed,
|
||||
@@ -1195,15 +1468,51 @@ document.addEventListener('alpine:init', () => {
|
||||
speedText(job) {
|
||||
if (!job) return '0 B/s';
|
||||
const down = Number(job.download_speed_mbps || 0);
|
||||
const up = Number(job.upload_speed_mbps || 0);
|
||||
return T.down + ' ' + down.toFixed(2) + ' MiB/s - ' + T.up + ' ' + up.toFixed(2) + ' MiB/s';
|
||||
return down.toFixed(2) + ' MiB/s';
|
||||
},
|
||||
|
||||
peerText(job) {
|
||||
if (!job) return T.peers + ' n/a';
|
||||
if (!job) return 'n/a';
|
||||
const live = job.peers_live == null ? '?' : job.peers_live;
|
||||
const seen = job.peers_seen == null ? '?' : job.peers_seen;
|
||||
return T.peers + ' ' + live + ' ' + T.live + ' / ' + seen + ' ' + T.seen + (job.eta ? ' - ' + T.eta + ' ' + job.eta : '');
|
||||
return live + ' ' + T.live + ' / ' + seen + ' ' + T.seen;
|
||||
},
|
||||
|
||||
etaText(job) {
|
||||
return job && job.eta ? job.eta : '';
|
||||
},
|
||||
|
||||
progressDetailText(job) {
|
||||
if (!job) return '';
|
||||
const size = this.bytes(job.selected_size || job.total_size);
|
||||
if (this.isCompleted(job)) return size;
|
||||
return this.bytes(job.downloaded_bytes) + ' / ' + size;
|
||||
},
|
||||
|
||||
actionButtonClass() {
|
||||
if (this.isCurrentCompletedLocked()) return 'modal-btn-ghost';
|
||||
return this.isCurrentDownloading() ? 'modal-btn-pause' : 'modal-btn-primary';
|
||||
},
|
||||
|
||||
actionButtonText() {
|
||||
if (this.normalizedStatus(this.currentJob) === 'resolving') return T.resolving;
|
||||
if (this.isCurrentCompletedLocked()) return T.completed;
|
||||
return this.isCurrentDownloading() ? T.pauseDownload : T.downloadSelected;
|
||||
},
|
||||
|
||||
actionButtonDisabled() {
|
||||
return this.loading
|
||||
|| this.isCurrentCompletedLocked()
|
||||
|| this.normalizedStatus(this.currentJob) === 'resolving'
|
||||
|| !this.previewData
|
||||
|| !Array.isArray(this.previewData.files)
|
||||
|| this.previewData.files.length === 0;
|
||||
},
|
||||
|
||||
toggleDownloadAction() {
|
||||
if (this.isCurrentCompletedLocked()) return;
|
||||
if (this.isCurrentDownloading()) this.pause();
|
||||
else this.start();
|
||||
},
|
||||
|
||||
sessionMeta(job) {
|
||||
@@ -1245,13 +1554,33 @@ document.addEventListener('alpine:init', () => {
|
||||
_rememberJob(job) {
|
||||
if (!job || !job.id) return;
|
||||
const rest = this.sessions.filter(item => item.id !== job.id);
|
||||
this.sessions = [job, ...rest].sort((a, b) => String(b.updated_at || '').localeCompare(String(a.updated_at || '')));
|
||||
this.sessions = [job, ...rest].sort((a, b) => String(b.created_at || '').localeCompare(String(a.created_at || '')));
|
||||
if (this.currentJob && this.currentJob.id === job.id) this.currentJob = job;
|
||||
},
|
||||
|
||||
_isSelectedJob(id) {
|
||||
return this.workspaceMode === 'session'
|
||||
&& this.currentJob
|
||||
&& this.currentJob.id === id
|
||||
&& this.previewData
|
||||
&& this.previewData.id === id;
|
||||
},
|
||||
|
||||
_syncCurrentJobFromSessions() {
|
||||
if (!this.currentJob || !this.previewData) return;
|
||||
const selected = this.sessions.find(job => job.id === this.currentJob.id && job.id === this.previewData.id);
|
||||
if (selected) this.currentJob = selected;
|
||||
},
|
||||
|
||||
_applySession(data) {
|
||||
const preview = data.preview || data;
|
||||
const job = data.job || null;
|
||||
this.workspaceMode = 'session';
|
||||
this.file = null;
|
||||
this.localFiles = [];
|
||||
this.magnet = '';
|
||||
this.uploadProgress = 0;
|
||||
this.uploadProgressText = '';
|
||||
this.previewData = preview;
|
||||
this.currentJob = job;
|
||||
const selected = Array.isArray(data.selected_files) && data.selected_files.length
|
||||
@@ -1269,6 +1598,8 @@ document.addEventListener('alpine:init', () => {
|
||||
const data = await res.json();
|
||||
if (!res.ok) throw new Error(data.error || T.loadTorrentsFailed);
|
||||
this.sessions = Array.isArray(data) ? data : [];
|
||||
this._syncCurrentJobFromSessions();
|
||||
await this._refreshResolvedSelection();
|
||||
} catch (err) {
|
||||
this._setMessage(err.message || String(err), true);
|
||||
} finally {
|
||||
@@ -1276,8 +1607,22 @@ document.addEventListener('alpine:init', () => {
|
||||
}
|
||||
},
|
||||
|
||||
async _refreshResolvedSelection() {
|
||||
if (!this.currentJob || !this.previewData || (this.previewData.files || []).length > 0) return;
|
||||
const selected = this.sessions.find(job => job.id === this.currentJob.id);
|
||||
if (!selected || this.normalizedStatus(selected) === 'resolving') return;
|
||||
try {
|
||||
const res = await fetch(`/api/player/torrents/session/${selected.id}`);
|
||||
const data = await res.json();
|
||||
if (!res.ok) return;
|
||||
this._applySession(data);
|
||||
this._setMessage(T.allFilesSelected);
|
||||
} catch {}
|
||||
},
|
||||
|
||||
async openSession(id) {
|
||||
if (!id || this.loading) return;
|
||||
this._stopPoll();
|
||||
this.loading = true;
|
||||
this._setMessage(T.openingSavedTorrent);
|
||||
try {
|
||||
@@ -1310,6 +1655,7 @@ document.addEventListener('alpine:init', () => {
|
||||
this.currentJob = null;
|
||||
this.treeRoot = null;
|
||||
this.selected = new Set();
|
||||
this.workspaceMode = this.sessions.length ? 'empty' : 'new';
|
||||
}
|
||||
this._setMessage(T.torrentRemoved);
|
||||
} catch (err) {
|
||||
@@ -1331,8 +1677,76 @@ document.addEventListener('alpine:init', () => {
|
||||
});
|
||||
},
|
||||
|
||||
setLocalFiles(files) {
|
||||
this.localFiles = Array.from(files || []);
|
||||
},
|
||||
|
||||
localUploadBytes() {
|
||||
return this.localFiles.reduce((sum, file) => sum + Number(file.size || 0), 0);
|
||||
},
|
||||
|
||||
localUploadSummary() {
|
||||
const count = this.localFiles.length;
|
||||
if (count === 0) return '';
|
||||
return count + ' ' + T.selected + ' - ' + this.bytes(this.localUploadBytes());
|
||||
},
|
||||
|
||||
uploadLocalFile(file, loadedBefore, totalBytes) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const xhr = new XMLHttpRequest();
|
||||
xhr.open('POST', '/api/player/uploads/local');
|
||||
xhr.setRequestHeader('Content-Type', file.type || 'application/octet-stream');
|
||||
xhr.setRequestHeader('X-Furumusic-Filename', encodeURIComponent(file.name || 'upload.mp3'));
|
||||
xhr.upload.onprogress = event => {
|
||||
if (!event.lengthComputable || totalBytes <= 0) return;
|
||||
const loaded = loadedBefore + event.loaded;
|
||||
this.uploadProgress = Math.max(0, Math.min(100, loaded / totalBytes * 100));
|
||||
this.uploadProgressText = this.uploadProgress.toFixed(1) + '%';
|
||||
};
|
||||
xhr.onload = () => {
|
||||
let data = {};
|
||||
try { data = JSON.parse(xhr.responseText || '{}'); } catch {}
|
||||
if (xhr.status >= 200 && xhr.status < 300) resolve(data);
|
||||
else reject(new Error(data.error || T.uploadFailed));
|
||||
};
|
||||
xhr.onerror = () => reject(new Error(T.uploadFailed));
|
||||
xhr.send(file);
|
||||
});
|
||||
},
|
||||
|
||||
async uploadLocalFiles() {
|
||||
if (this.loading || this.localFiles.length === 0) return;
|
||||
this.loading = true;
|
||||
this.uploadProgress = 0;
|
||||
this.uploadProgressText = '0.0%';
|
||||
this._setMessage(T.uploadingFiles);
|
||||
const totalBytes = this.localUploadBytes();
|
||||
let loadedBefore = 0;
|
||||
try {
|
||||
for (const file of this.localFiles) {
|
||||
await this.uploadLocalFile(file, loadedBefore, totalBytes);
|
||||
loadedBefore += Number(file.size || 0);
|
||||
this.uploadProgress = totalBytes > 0 ? Math.min(100, loadedBefore / totalBytes * 100) : 100;
|
||||
this.uploadProgressText = this.uploadProgress.toFixed(1) + '%';
|
||||
}
|
||||
this.localFiles = [];
|
||||
this.uploadProgress = 100;
|
||||
this.uploadProgressText = '100.0%';
|
||||
this._setMessage(T.uploadComplete);
|
||||
await this.loadAgentStatus();
|
||||
} catch (err) {
|
||||
this._setMessage(err.message || String(err), true);
|
||||
} finally {
|
||||
this.loading = false;
|
||||
}
|
||||
},
|
||||
|
||||
async preview() {
|
||||
if (this.loading) return;
|
||||
if (this.localFiles.length > 0) {
|
||||
await this.uploadLocalFiles();
|
||||
return;
|
||||
}
|
||||
const magnet = this.magnet.trim();
|
||||
if (!this.file && !magnet) {
|
||||
this._setMessage(T.chooseTorrent, true);
|
||||
@@ -1343,6 +1757,7 @@ document.addEventListener('alpine:init', () => {
|
||||
this.previewData = null;
|
||||
this.treeRoot = null;
|
||||
this.currentJob = null;
|
||||
this.workspaceMode = 'new';
|
||||
this.selected = new Set();
|
||||
this.expanded = new Set();
|
||||
this._setMessage(this.file ? T.readingTorrent : T.resolvingMagnet);
|
||||
@@ -1360,7 +1775,7 @@ document.addEventListener('alpine:init', () => {
|
||||
if (!res.ok) throw new Error(data.error || T.previewFailed);
|
||||
|
||||
this._applySession(data);
|
||||
this._setMessage(T.allFilesSelected);
|
||||
this._setMessage((data.preview?.files || []).length ? T.allFilesSelected : T.resolving);
|
||||
await this.loadSessions();
|
||||
} catch (err) {
|
||||
this._setMessage(err.message || String(err), true);
|
||||
@@ -1554,7 +1969,7 @@ document.addEventListener('alpine:init', () => {
|
||||
|
||||
async start() {
|
||||
if (!this.previewData || this.loading) return;
|
||||
const selected = [...this.selected];
|
||||
const selected = this.selectedArray();
|
||||
if (selected.length === 0) {
|
||||
this._setMessage(T.selectOneFile, true);
|
||||
return;
|
||||
@@ -1596,8 +2011,7 @@ document.addEventListener('alpine:init', () => {
|
||||
this.currentJob = data;
|
||||
this._rememberJob(data);
|
||||
this._setMessage(T.downloadPaused);
|
||||
if (this._pollTimer) clearInterval(this._pollTimer);
|
||||
this._pollTimer = null;
|
||||
this._stopPoll();
|
||||
await this.loadSessions();
|
||||
} catch (err) {
|
||||
this._setMessage(err.message || String(err), true);
|
||||
@@ -1607,28 +2021,29 @@ document.addEventListener('alpine:init', () => {
|
||||
},
|
||||
|
||||
_poll(id) {
|
||||
if (this._pollTimer) clearInterval(this._pollTimer);
|
||||
this._stopPoll();
|
||||
this._pollJobId = id;
|
||||
this._pollTimer = setInterval(async () => {
|
||||
try {
|
||||
const res = await fetch(`/api/player/torrents/${id}/status`);
|
||||
const data = await res.json();
|
||||
if (!res.ok) throw new Error(data.error || T.statusFailed);
|
||||
this.currentJob = data;
|
||||
this._rememberJob(data);
|
||||
if (this._isSelectedJob(id)) {
|
||||
this.currentJob = data;
|
||||
this._setMessage(
|
||||
this.statusLabel(data) + ' - ' + this.progressValue(data).toFixed(1) + '% - ' + this.bytes(data.downloaded_bytes),
|
||||
data.status === 'failed'
|
||||
);
|
||||
}
|
||||
if (data.status === 'complete' || data.status === 'failed') {
|
||||
clearInterval(this._pollTimer);
|
||||
this._pollTimer = null;
|
||||
this._stopPoll();
|
||||
this.loadSessions();
|
||||
this.loadAgentStatus();
|
||||
}
|
||||
} catch (err) {
|
||||
this._setMessage(err.message || String(err), true);
|
||||
clearInterval(this._pollTimer);
|
||||
this._pollTimer = null;
|
||||
if (this._isSelectedJob(id)) this._setMessage(err.message || String(err), true);
|
||||
this._stopPoll();
|
||||
}
|
||||
}, 2000);
|
||||
},
|
||||
|
||||
+52
-13
@@ -391,7 +391,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 +434,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 +562,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 +614,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 +690,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>
|
||||
@@ -725,8 +737,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.currentRelease.tracks, idx)" title="{{ t.player_play }}">
|
||||
<svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
|
||||
@@ -795,8 +813,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 +895,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 +928,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>
|
||||
|
||||
+362
-50
@@ -661,11 +661,20 @@ button.user-stat:hover {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 2px;
|
||||
opacity: 0;
|
||||
opacity: 1;
|
||||
transition: opacity 0.15s;
|
||||
}
|
||||
|
||||
.track-row:hover .track-actions { opacity: 1; }
|
||||
.track-actions > :not(.popularity-info-btn) {
|
||||
opacity: 0;
|
||||
pointer-events: none;
|
||||
transition: opacity 0.15s;
|
||||
}
|
||||
|
||||
.track-row:hover .track-actions > * {
|
||||
opacity: 1;
|
||||
pointer-events: auto;
|
||||
}
|
||||
|
||||
.track-action-btn {
|
||||
background: none;
|
||||
@@ -692,6 +701,43 @@ button.user-stat:hover {
|
||||
color: var(--text-primary);
|
||||
}
|
||||
|
||||
.popularity-info-btn {
|
||||
min-width: 26px;
|
||||
height: 20px;
|
||||
padding: 0 3px;
|
||||
border: 0;
|
||||
border-radius: 0;
|
||||
background: transparent;
|
||||
font-size: 11px;
|
||||
font-weight: 800;
|
||||
line-height: 1;
|
||||
letter-spacing: 0;
|
||||
font-variant-numeric: tabular-nums;
|
||||
}
|
||||
|
||||
.popularity-info-btn.has-popularity {
|
||||
color: var(--popularity-fg, var(--text-primary));
|
||||
background: transparent;
|
||||
}
|
||||
|
||||
.popularity-info-btn.has-popularity:hover {
|
||||
color: var(--popularity-fg, var(--text-primary));
|
||||
background: transparent;
|
||||
}
|
||||
|
||||
.popularity-info-btn.no-popularity {
|
||||
min-width: 18px;
|
||||
width: 18px;
|
||||
padding: 0;
|
||||
}
|
||||
|
||||
.popularity-info-btn .info-letter {
|
||||
font-size: 12px;
|
||||
font-weight: 800;
|
||||
font-style: normal;
|
||||
line-height: 1;
|
||||
}
|
||||
|
||||
.card-info-btn {
|
||||
position: absolute;
|
||||
top: 8px;
|
||||
@@ -926,12 +972,21 @@ button.user-stat:hover {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 2px;
|
||||
opacity: 0;
|
||||
opacity: 1;
|
||||
transition: opacity 0.15s;
|
||||
flex-shrink: 0;
|
||||
}
|
||||
|
||||
.queue-track:hover .queue-track-actions { opacity: 1; }
|
||||
.queue-track-actions > :not(.popularity-info-btn) {
|
||||
opacity: 0;
|
||||
pointer-events: none;
|
||||
transition: opacity 0.15s;
|
||||
}
|
||||
|
||||
.queue-track:hover .queue-track-actions > * {
|
||||
opacity: 1;
|
||||
pointer-events: auto;
|
||||
}
|
||||
|
||||
.queue-track-remove {
|
||||
background: none;
|
||||
@@ -948,6 +1003,20 @@ button.user-stat:hover {
|
||||
|
||||
.queue-track-remove:hover { color: var(--text-primary); background: var(--bg-hover); }
|
||||
|
||||
.queue-track-remove.popularity-info-btn {
|
||||
min-width: 26px;
|
||||
width: auto;
|
||||
height: 20px;
|
||||
padding: 0 3px;
|
||||
border-radius: 0;
|
||||
}
|
||||
|
||||
.queue-track-remove.popularity-info-btn.no-popularity {
|
||||
min-width: 18px;
|
||||
width: 18px;
|
||||
padding: 0;
|
||||
}
|
||||
|
||||
/* Drag handle */
|
||||
.queue-drag-handle {
|
||||
cursor: grab;
|
||||
@@ -1010,12 +1079,28 @@ button.user-stat:hover {
|
||||
overflow: hidden;
|
||||
min-width: 0;
|
||||
}
|
||||
|
||||
.player-track-title-row {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 6px;
|
||||
min-width: 0;
|
||||
}
|
||||
|
||||
.player-track-title {
|
||||
font-size: 13px;
|
||||
font-weight: 500;
|
||||
white-space: nowrap;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
min-width: 0;
|
||||
}
|
||||
|
||||
.player-current-like {
|
||||
width: 24px;
|
||||
height: 24px;
|
||||
padding: 4px;
|
||||
flex: 0 0 auto;
|
||||
}
|
||||
|
||||
.player-track-artist {
|
||||
@@ -1694,7 +1779,7 @@ button.user-stat:hover {
|
||||
.modal-playlist-item svg { width: 16px; height: 16px; flex-shrink: 0; }
|
||||
|
||||
.info-modal {
|
||||
max-width: min(520px, calc(100vw - 24px));
|
||||
max-width: min(620px, calc(100vw - 24px));
|
||||
}
|
||||
|
||||
.info-modal-head {
|
||||
@@ -1716,14 +1801,72 @@ button.user-stat:hover {
|
||||
border-radius: 8px;
|
||||
background: var(--bg-primary);
|
||||
color: var(--text-secondary);
|
||||
font-family: ui-monospace, SFMono-Regular, Consolas, monospace;
|
||||
font-size: 13px;
|
||||
line-height: 1.55;
|
||||
white-space: pre-wrap;
|
||||
overflow: auto;
|
||||
max-height: min(58dvh, 520px);
|
||||
}
|
||||
|
||||
.info-modal-plain {
|
||||
margin: 0;
|
||||
font-family: ui-monospace, SFMono-Regular, Consolas, monospace;
|
||||
white-space: pre-wrap;
|
||||
}
|
||||
|
||||
.info-table {
|
||||
width: 100%;
|
||||
border-collapse: collapse;
|
||||
}
|
||||
|
||||
.info-table th,
|
||||
.info-table td {
|
||||
padding: 9px 0;
|
||||
border-bottom: 1px solid rgba(255, 255, 255, 0.07);
|
||||
vertical-align: top;
|
||||
}
|
||||
|
||||
.info-table tr:last-child th,
|
||||
.info-table tr:last-child td {
|
||||
border-bottom: 0;
|
||||
}
|
||||
|
||||
.info-table th {
|
||||
width: 34%;
|
||||
padding-right: 18px;
|
||||
color: var(--text-subdued);
|
||||
font-size: 11px;
|
||||
font-weight: 700;
|
||||
text-align: left;
|
||||
text-transform: uppercase;
|
||||
}
|
||||
|
||||
.info-table td {
|
||||
color: var(--text-primary);
|
||||
}
|
||||
|
||||
.info-link-list {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: 6px;
|
||||
}
|
||||
|
||||
.info-link {
|
||||
border: 1px solid rgba(29, 185, 84, 0.36);
|
||||
border-radius: 999px;
|
||||
background: rgba(29, 185, 84, 0.1);
|
||||
color: var(--text-primary);
|
||||
cursor: pointer;
|
||||
padding: 3px 8px;
|
||||
font: inherit;
|
||||
line-height: 1.3;
|
||||
}
|
||||
|
||||
.info-link:hover {
|
||||
border-color: rgba(29, 185, 84, 0.7);
|
||||
background: rgba(29, 185, 84, 0.18);
|
||||
color: var(--accent);
|
||||
}
|
||||
|
||||
.modal-btn {
|
||||
padding: 8px 16px;
|
||||
border-radius: 20px;
|
||||
@@ -1741,6 +1884,11 @@ button.user-stat:hover {
|
||||
color: #111;
|
||||
}
|
||||
.modal-btn-ghost { background: transparent; color: var(--text-secondary); }
|
||||
.modal-btn-danger {
|
||||
background: rgba(229,96,96,0.16);
|
||||
color: #ffb9b9;
|
||||
border: 1px solid rgba(229,96,96,0.32);
|
||||
}
|
||||
|
||||
.modal-footer {
|
||||
display: flex;
|
||||
@@ -1749,9 +1897,10 @@ button.user-stat:hover {
|
||||
}
|
||||
|
||||
.torrent-modal {
|
||||
width: min(860px, calc(100vw - 32px));
|
||||
max-width: 860px;
|
||||
max-height: min(88dvh, 760px);
|
||||
width: min(1180px, calc(100vw - 48px));
|
||||
max-width: 1180px;
|
||||
height: min(820px, calc(100dvh - 64px));
|
||||
max-height: calc(100dvh - 64px);
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
@@ -1761,6 +1910,8 @@ button.user-stat:hover {
|
||||
justify-content: space-between;
|
||||
gap: 14px;
|
||||
margin-bottom: 12px;
|
||||
flex: 0 0 auto;
|
||||
position: relative;
|
||||
}
|
||||
|
||||
.torrent-modal-head h3 {
|
||||
@@ -1792,6 +1943,25 @@ button.user-stat:hover {
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.torrent-modal-close {
|
||||
display: none;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
flex: 0 0 auto;
|
||||
width: 34px;
|
||||
height: 34px;
|
||||
border: 1px solid var(--border-color);
|
||||
border-radius: 999px;
|
||||
background: var(--bg-primary);
|
||||
color: var(--text-secondary);
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
.torrent-modal-close svg {
|
||||
width: 18px;
|
||||
height: 18px;
|
||||
}
|
||||
|
||||
.torrent-status-pill.active {
|
||||
border-color: rgba(29,185,84,0.42);
|
||||
color: #9ff0b9;
|
||||
@@ -1816,9 +1986,10 @@ button.user-stat:hover {
|
||||
|
||||
.torrent-manager-layout {
|
||||
display: grid;
|
||||
grid-template-columns: minmax(210px, 260px) minmax(0, 1fr);
|
||||
grid-template-columns: minmax(260px, 320px) minmax(0, 1fr);
|
||||
gap: 14px;
|
||||
min-height: 0;
|
||||
flex: 1 1 auto;
|
||||
}
|
||||
|
||||
.torrent-manager-sidebar,
|
||||
@@ -1851,19 +2022,52 @@ button.user-stat:hover {
|
||||
|
||||
.torrent-session-list {
|
||||
overflow-y: auto;
|
||||
min-height: 150px;
|
||||
max-height: min(52vh, 470px);
|
||||
min-height: 0;
|
||||
max-height: none;
|
||||
flex: 1 1 auto;
|
||||
}
|
||||
|
||||
.torrent-session-row {
|
||||
display: grid;
|
||||
grid-template-columns: minmax(0, 1fr) auto;
|
||||
grid-template-columns: minmax(0, 1fr);
|
||||
gap: 8px;
|
||||
padding: 10px 12px;
|
||||
border-bottom: 1px solid var(--border-color);
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
.torrent-session-add {
|
||||
width: 100%;
|
||||
grid-template-columns: auto minmax(0, 1fr);
|
||||
align-items: center;
|
||||
border: 0;
|
||||
border-bottom: 1px solid var(--border-color);
|
||||
background: transparent;
|
||||
color: var(--text-secondary);
|
||||
text-align: left;
|
||||
font: inherit;
|
||||
font-size: 13px;
|
||||
font-weight: 800;
|
||||
}
|
||||
|
||||
.torrent-session-add:disabled {
|
||||
cursor: default;
|
||||
opacity: 0.6;
|
||||
}
|
||||
|
||||
.torrent-session-add-icon {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
width: 22px;
|
||||
height: 22px;
|
||||
border-radius: 999px;
|
||||
border: 1px solid rgba(29,185,84,0.38);
|
||||
color: #9ff0b9;
|
||||
font-size: 16px;
|
||||
line-height: 1;
|
||||
}
|
||||
|
||||
.torrent-session-row:last-child { border-bottom: 0; }
|
||||
.torrent-session-row:hover,
|
||||
.torrent-session-row.active { background: var(--bg-hover); }
|
||||
@@ -1903,19 +2107,28 @@ button.user-stat:hover {
|
||||
}
|
||||
|
||||
.torrent-status-badge.status-preview {
|
||||
background: rgba(122,162,255,0.14);
|
||||
color: #a8c0ff;
|
||||
background: rgba(122,162,255,0.16);
|
||||
color: #adc3ff;
|
||||
}
|
||||
|
||||
.torrent-status-badge.status-downloading,
|
||||
.torrent-status-badge.status-moving {
|
||||
.torrent-status-badge.status-resolving {
|
||||
background: rgba(182,141,255,0.16);
|
||||
color: #d0b6ff;
|
||||
}
|
||||
|
||||
.torrent-status-badge.status-downloading {
|
||||
background: rgba(29,185,84,0.16);
|
||||
color: #9ff0b9;
|
||||
}
|
||||
|
||||
.torrent-status-badge.status-moving {
|
||||
background: rgba(75,198,240,0.16);
|
||||
color: #a8e8ff;
|
||||
}
|
||||
|
||||
.torrent-status-badge.status-completed {
|
||||
background: rgba(105,214,161,0.2);
|
||||
color: #b8ffd2;
|
||||
background: rgba(110,211,123,0.16);
|
||||
color: #b8f7be;
|
||||
}
|
||||
|
||||
.torrent-status-badge.status-paused {
|
||||
@@ -1953,23 +2166,6 @@ button.user-stat:hover {
|
||||
transition: width 0.25s ease;
|
||||
}
|
||||
|
||||
.torrent-session-remove {
|
||||
align-self: flex-start;
|
||||
border: 1px solid rgba(229,96,96,0.24);
|
||||
background: rgba(229,96,96,0.12);
|
||||
color: #ffb9b9;
|
||||
border-radius: 5px;
|
||||
padding: 4px 7px;
|
||||
font-size: 11px;
|
||||
font-weight: 800;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
.torrent-session-remove:hover {
|
||||
background: rgba(229,96,96,0.2);
|
||||
color: #ffd7d7;
|
||||
}
|
||||
|
||||
.torrent-progress-card {
|
||||
margin-top: 10px;
|
||||
padding: 10px 12px;
|
||||
@@ -2005,12 +2201,44 @@ button.user-stat:hover {
|
||||
}
|
||||
|
||||
.torrent-progress-details {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: 8px 12px;
|
||||
display: grid;
|
||||
grid-template-columns: repeat(4, minmax(0, 1fr));
|
||||
gap: 8px;
|
||||
margin-top: 8px;
|
||||
color: var(--text-subdued);
|
||||
min-height: 38px;
|
||||
}
|
||||
|
||||
.torrent-progress-details.completed {
|
||||
grid-template-columns: minmax(0, 1fr);
|
||||
}
|
||||
|
||||
.torrent-progress-metric {
|
||||
min-width: 0;
|
||||
min-height: 38px;
|
||||
padding: 5px 7px;
|
||||
border-radius: 6px;
|
||||
background: var(--bg-secondary);
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
justify-content: center;
|
||||
gap: 2px;
|
||||
}
|
||||
|
||||
.torrent-progress-label {
|
||||
color: var(--text-muted);
|
||||
font-size: 10px;
|
||||
line-height: 12px;
|
||||
text-transform: uppercase;
|
||||
font-weight: 800;
|
||||
}
|
||||
|
||||
.torrent-progress-value {
|
||||
color: var(--text-secondary);
|
||||
font-size: 12px;
|
||||
line-height: 14px;
|
||||
font-weight: 700;
|
||||
overflow-wrap: anywhere;
|
||||
}
|
||||
|
||||
.history-modal {
|
||||
@@ -2074,6 +2302,26 @@ button.user-stat:hover {
|
||||
max-width: 360px;
|
||||
}
|
||||
|
||||
.torrent-import-panel,
|
||||
.torrent-workspace-empty {
|
||||
min-height: 150px;
|
||||
}
|
||||
|
||||
.torrent-upload-summary {
|
||||
min-height: 16px;
|
||||
margin-top: 5px;
|
||||
color: var(--text-subdued);
|
||||
font-size: 11px;
|
||||
}
|
||||
|
||||
.torrent-upload-progress {
|
||||
margin-top: 10px;
|
||||
padding: 10px 12px;
|
||||
border: 1px solid var(--border-color);
|
||||
border-radius: 8px;
|
||||
background: var(--bg-primary);
|
||||
}
|
||||
|
||||
.torrent-modal label {
|
||||
display: block;
|
||||
margin-bottom: 6px;
|
||||
@@ -2118,6 +2366,13 @@ button.user-stat:hover {
|
||||
margin-top: 16px;
|
||||
}
|
||||
|
||||
.torrent-preview-actions {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
justify-content: flex-end;
|
||||
gap: 8px;
|
||||
}
|
||||
|
||||
.torrent-preview-title {
|
||||
min-width: 0;
|
||||
font-size: 14px;
|
||||
@@ -2174,7 +2429,7 @@ button.user-stat:hover {
|
||||
margin-top: 10px;
|
||||
overflow-y: auto;
|
||||
min-height: 140px;
|
||||
max-height: min(46vh, 420px);
|
||||
max-height: none;
|
||||
border: 1px solid var(--border-color);
|
||||
border-radius: 8px;
|
||||
background: var(--bg-primary);
|
||||
@@ -2373,7 +2628,7 @@ button.user-stat:hover {
|
||||
}
|
||||
|
||||
.torrent-modal {
|
||||
width: calc(100vw - 24px);
|
||||
width: min(1180px, calc(100vw - 32px));
|
||||
}
|
||||
|
||||
.card-grid {
|
||||
@@ -2695,6 +2950,24 @@ button.user-stat:hover {
|
||||
padding: 6px;
|
||||
}
|
||||
|
||||
.popularity-info-btn {
|
||||
min-width: 28px;
|
||||
height: 22px;
|
||||
padding: 0 3px;
|
||||
}
|
||||
|
||||
.popularity-info-btn.no-popularity {
|
||||
min-width: 20px;
|
||||
width: 20px;
|
||||
padding: 0;
|
||||
}
|
||||
|
||||
.track-actions > *,
|
||||
.queue-track-actions > * {
|
||||
opacity: 1;
|
||||
pointer-events: auto;
|
||||
}
|
||||
|
||||
.track-action-btn svg,
|
||||
.like-btn svg {
|
||||
width: 17px;
|
||||
@@ -2717,34 +2990,65 @@ button.user-stat:hover {
|
||||
}
|
||||
|
||||
.info-modal,
|
||||
.torrent-modal,
|
||||
.history-modal {
|
||||
width: min(400px, calc(100vw - 24px));
|
||||
max-width: 400px;
|
||||
}
|
||||
|
||||
.info-table th,
|
||||
.info-table td {
|
||||
display: block;
|
||||
width: 100%;
|
||||
padding-right: 0;
|
||||
}
|
||||
|
||||
.info-table th {
|
||||
padding-bottom: 2px;
|
||||
border-bottom: 0;
|
||||
}
|
||||
|
||||
.info-table td {
|
||||
padding-top: 0;
|
||||
}
|
||||
|
||||
.torrent-modal {
|
||||
max-height: min(82dvh, 640px);
|
||||
padding: 20px;
|
||||
width: 100vw;
|
||||
max-width: none;
|
||||
height: 100dvh;
|
||||
max-height: none;
|
||||
border-radius: 0;
|
||||
padding: calc(14px + env(safe-area-inset-top)) 14px calc(14px + env(safe-area-inset-bottom));
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
.torrent-modal-head {
|
||||
flex-direction: column;
|
||||
display: grid;
|
||||
grid-template-columns: minmax(0, 1fr) auto;
|
||||
gap: 8px;
|
||||
align-items: start;
|
||||
}
|
||||
|
||||
.torrent-client-status {
|
||||
grid-column: 1 / -1;
|
||||
justify-content: flex-start;
|
||||
}
|
||||
|
||||
.torrent-modal-close {
|
||||
display: inline-flex;
|
||||
}
|
||||
|
||||
.torrent-manager-layout {
|
||||
grid-template-columns: 1fr;
|
||||
gap: 10px;
|
||||
}
|
||||
|
||||
.torrent-session-list {
|
||||
max-height: 148px;
|
||||
min-height: 96px;
|
||||
max-height: none;
|
||||
min-height: 0;
|
||||
}
|
||||
|
||||
.torrent-manager-sidebar {
|
||||
flex: 0 0 178px;
|
||||
}
|
||||
|
||||
.torrent-progress-head {
|
||||
@@ -2753,6 +3057,14 @@ button.user-stat:hover {
|
||||
gap: 4px;
|
||||
}
|
||||
|
||||
.torrent-progress-details {
|
||||
grid-template-columns: repeat(2, minmax(0, 1fr));
|
||||
}
|
||||
|
||||
.torrent-progress-details.completed {
|
||||
grid-template-columns: minmax(0, 1fr);
|
||||
}
|
||||
|
||||
.torrent-modal h3 {
|
||||
margin-bottom: 12px;
|
||||
}
|
||||
@@ -2790,8 +3102,8 @@ button.user-stat:hover {
|
||||
}
|
||||
|
||||
.torrent-file-tree {
|
||||
min-height: 120px;
|
||||
max-height: min(32dvh, 260px);
|
||||
min-height: 0;
|
||||
max-height: none;
|
||||
}
|
||||
|
||||
.torrent-tree-row {
|
||||
|
||||
Reference in New Issue
Block a user