ab/furumusic
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases Activity

Reworked admin
Build and Publish / Build and Publish Docker Image (push) Successful in 3m11s
Details

Browse Source
This commit is contained in:
Hills Eternity
2026-05-26 00:19:11 +03:00
parent a3a3f5368d
commit aafb364eb8
11 changed files with 4192 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/admin/mod.rs
+284 -7
View File
@@ -1,3 +1,4 @@
mod v2;
pub mod views;
use std::sync::Arc;
@@ -131,20 +132,296 @@ impl App for AdminApp {
),
"admin_setup",
),
// -- Admin v2 -----------------------------------------------------
Route::with_handler_and_name(
"/v2",
|session: Session, db: Database, i18n: I18n| async move {
let count = User::count_all(&db).await.unwrap_or(0);
if count == 0 {
return Ok(auth::redirect("/admin/setup"));
}
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
v2::page(admin, i18n).await?.into_response()
},
"admin_v2",
),
Route::with_handler_and_name(
"/v2/api/dashboard",
{
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
let registry = Arc::clone(&self.registry);
get(move |session: Session, db: Database| {
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
let registry = Arc::clone(&registry);
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::dashboard(session, db, pg_pool, &registry).await
}
})
},
"admin_v2_dashboard",
),
Route::with_handler_and_name(
"/v2/api/reviews",
{
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
get(move |session: Session, db: Database,
query: UrlQuery<v2::ReviewsQuery>| {
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::reviews(session, db, pg_pool, query.0).await
}
})
},
"admin_v2_reviews",
),
Route::with_handler_and_name(
"/v2/api/reviews/bulk",
{
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
cot::router::method::post(
move |session: Session,
db: Database,
json: Json<v2::BulkReviewsRequest>| {
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::bulk_reviews(session, db, pg_pool, json).await
}
},
)
},
"admin_v2_reviews_bulk",
),
Route::with_handler_and_name(
"/v2/api/jobs",
{
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
let registry = Arc::clone(&self.registry);
get(move |session: Session, db: Database| {
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
let registry = Arc::clone(&registry);
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::jobs(session, db, pg_pool, &registry).await
}
})
},
"admin_v2_jobs",
),
Route::with_handler_and_name(
"/v2/api/jobs/{name}/run",
cot::router::method::post({
let handle = Arc::clone(&self.scheduler_handle);
move |session: Session, db: Database, path: Path<PathName>| {
let handle = Arc::clone(&handle);
async move { v2::run_job(session, db, &handle, &path.0.name).await }
}
}),
"admin_v2_job_run",
),
Route::with_handler_and_name(
"/v2/api/jobs/{name}/toggle",
cot::router::method::post({
let handle = Arc::clone(&self.scheduler_handle);
move |session: Session, db: Database, path: Path<PathName>| {
let handle = Arc::clone(&handle);
async move { v2::toggle_job(session, db, &handle, &path.0.name).await }
}
}),
"admin_v2_job_toggle",
),
Route::with_handler_and_name(
"/v2/api/jobs/{name}/runs",
{
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
get(move |session: Session, db: Database, path: Path<PathName>| {
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::job_runs(session, db, pg_pool, &path.0.name).await
}
})
},
"admin_v2_job_runs",
),
Route::with_handler_and_name(
"/v2/api/jobs/{name}/runs/{run_id}",
{
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
get(
move |session: Session, db: Database, path: Path<PathNameRunId>| {
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::job_run_detail(session, db, pg_pool, path.0.run_id).await
}
},
)
},
"admin_v2_job_run_detail",
),
Route::with_handler_and_name(
"/v2/api/library",
{
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
get(move |session: Session, db: Database,
query: UrlQuery<v2::LibraryQuery>| {
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(session, db, pg_pool, query.0).await
}
})
},
"admin_v2_library",
),
Route::with_handler_and_name(
"/v2/api/library/item",
{
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
cot::router::method::post(
move |session: Session,
db: Database,
json: Json<v2::UpdateLibraryItemRequest>| {
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::update_library_item(session, db, pg_pool, json).await
}
},
)
},
"admin_v2_library_item",
),
Route::with_handler_and_name(
"/v2/api/library/bulk",
{
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
cot::router::method::post(
move |session: Session,
db: Database,
json: Json<v2::BulkLibraryRequest>| {
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::bulk_library(session, db, pg_pool, json).await
}
},
)
},
"admin_v2_library_bulk",
),
// -- Dashboard ----------------------------------------------------
Route::with_handler_and_name(
"/",
|session: Session, db: Database, i18n: I18n| async move {
let count = User::count_all(&db).await.unwrap_or(0);
if count == 0 {
return Ok(auth::redirect("/admin/setup"));
return Ok::<cot::response::Response, cot::Error>(auth::redirect(
"/admin/setup",
));
}
let admin =
match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::admin_index(admin, i18n).await?.into_response()
let _admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
let _ = i18n;
Ok::<cot::response::Response, cot::Error>(auth::redirect("/admin/v2"))
},
"admin_index",
),
src/admin/v2.rs
+1766
View File
File diff suppressed because it is too large Load Diff
src/admin/views.rs
-17
View File
@@ -211,23 +211,6 @@ pub async fn debug_handler(
Ok(Html::new(template.render()?))
}
#[derive(Debug, Template)]
#[template(path = "admin/index.html")]
struct AdminIndexTemplate {
t: &'static Translations,
user_name: String,
user_role: String,
}
pub async fn admin_index(admin: AuthenticatedUser, i18n: I18n) -> cot::Result<Html> {
let template = AdminIndexTemplate {
t: i18n.t,
user_name: admin.name,
user_role: admin.role.code().to_owned(),
};
Ok(Html::new(template.render()?))
}
// ---------------------------------------------------------------------------
// Settings page
// ---------------------------------------------------------------------------
src/player/dto.rs
+6
View File
@@ -108,6 +108,9 @@ pub(super) struct PlaylistCard {
pub(super) title: String,
pub(super) track_count: i64,
pub(super) is_own: bool,
pub(super) owner_name: Option<String>,
pub(super) is_public: bool,
pub(super) is_saved: bool,
pub(super) kind: String,
}
@@ -128,6 +131,9 @@ pub(super) struct PlaylistDetail {
pub(super) title: String,
pub(super) description: Option<String>,
pub(super) is_own: bool,
pub(super) owner_name: Option<String>,
pub(super) is_public: bool,
pub(super) is_saved: bool,
pub(super) kind: String,
pub(super) tracks: Vec<TrackItem>,
}
src/player/mod.rs
+41 -4
View File
@@ -546,18 +546,33 @@ async fn playlists_handler(
title: "Likes".to_string(),
track_count: likes_count.0,
is_own: true,
owner_name: None,
is_public: false,
is_saved: false,
kind: "likes".to_string(),
}];
let rows = sqlx::query_as::<_, PlaylistRow>(
r#"SELECT p.id, p.title::text as title,
COALESCE((SELECT COUNT(*) FROM furumusic__playlist_track pt WHERE pt.playlist_id = p.id), 0) as track_count,
(p.owner_id = $1) as is_own
(p.owner_id = $1) as is_own,
COALESCE(NULLIF(u.display_name, ''), u.username)::text as owner_name,
p.is_public,
EXISTS (
SELECT 1 FROM furumusic__saved_playlist sp
WHERE sp.user_id = $1 AND sp.playlist_id = p.id
) as is_saved
FROM furumusic__playlist p
JOIN furumusic__user u ON u.id = p.owner_id
WHERE p.owner_id = $1
OR p.id IN (SELECT sp.playlist_id FROM furumusic__saved_playlist sp WHERE sp.user_id = $1)
OR EXISTS (
SELECT 1 FROM furumusic__saved_playlist sp
WHERE sp.user_id = $1 AND sp.playlist_id = p.id
)
OR p.is_public = true
ORDER BY p.title"#,
ORDER BY
CASE WHEN p.owner_id = $1 THEN 0 WHEN p.is_public THEN 2 ELSE 1 END,
p.title"#,
)
.bind(user.id)
.fetch_all(pool)
@@ -569,6 +584,9 @@ async fn playlists_handler(
title: r.title,
track_count: r.track_count,
is_own: r.is_own,
owner_name: Some(r.owner_name),
is_public: r.is_public,
is_saved: r.is_saved,
kind: "user".to_string(),
}));
@@ -597,9 +615,19 @@ async fn playlist_detail_handler(
}
let info = sqlx::query_as::<_, PlaylistInfoRow>(
"SELECT id, title::text as title, description, owner_id FROM furumusic__playlist WHERE id = $1",
r#"SELECT p.id, p.title::text as title, p.description, p.owner_id,
COALESCE(NULLIF(u.display_name, ''), u.username)::text as owner_name,
p.is_public,
EXISTS (
SELECT 1 FROM furumusic__saved_playlist sp
WHERE sp.user_id = $2 AND sp.playlist_id = p.id
) as is_saved
FROM furumusic__playlist p
JOIN furumusic__user u ON u.id = p.owner_id
WHERE p.id = $1"#,
)
.bind(playlist_id)
.bind(user.id)
.fetch_optional(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
@@ -637,6 +665,9 @@ async fn playlist_detail_handler(
title: info.title,
description: info.description,
is_own: info.owner_id == user.id,
owner_name: Some(info.owner_name),
is_public: info.is_public,
is_saved: info.is_saved,
kind: "user".to_string(),
tracks: track_items,
})
@@ -748,6 +779,9 @@ async fn likes_playlist_handler(
title: "Likes".to_string(),
description: None,
is_own: true,
owner_name: None,
is_public: false,
is_saved: false,
kind: "likes".to_string(),
tracks: track_items,
})
@@ -1429,6 +1463,9 @@ async fn create_playlist_handler(
title,
track_count: 0,
is_own: true,
owner_name: Some(user.name),
is_public: false,
is_saved: false,
kind: "user".to_string(),
})
.into_response()
src/player/rows.rs
+6
View File
@@ -77,6 +77,9 @@ pub(super) struct PlaylistRow {
pub(super) title: String,
pub(super) track_count: i64,
pub(super) is_own: bool,
pub(super) owner_name: String,
pub(super) is_public: bool,
pub(super) is_saved: bool,
}
#[derive(sqlx::FromRow)]
@@ -85,6 +88,9 @@ pub(super) struct PlaylistInfoRow {
pub(super) title: String,
pub(super) description: Option<String>,
pub(super) owner_id: i64,
pub(super) owner_name: String,
pub(super) is_public: bool,
pub(super) is_saved: bool,
}
#[derive(sqlx::FromRow)]
src/scheduler/mod.rs
+73
View File
@@ -1124,6 +1124,34 @@ pub struct SchedulerHandle {
}
impl SchedulerHandle {
/// Start a job immediately in the background and return the created run id.
pub async fn trigger_job_now_background(
self: Arc<Self>,
job_name: &str,
) -> anyhow::Result<i64> {
self.registry
.get(job_name)
.ok_or_else(|| anyhow::anyhow!("unknown job: {job_name}"))?;
let db = self.shared_db.clone();
let pool = self.shared_pool.clone();
let (live_config, _) = AppConfig::load_with_db(&db).await;
let run = JobRun::create_running(&db, job_name, "manual")
.await
.map_err(|e| anyhow::anyhow!("failed to create job run: {e}"))?;
let run_id = run.id_val();
let job_name = job_name.to_owned();
let handle = Arc::clone(&self);
tokio::spawn(async move {
handle
.finish_manual_run(job_name, live_config, db, pool, run)
.await;
});
Ok(run_id)
}
/// Execute a job immediately (manual or programmatic trigger).
pub async fn trigger_job_now(&self, job_name: &str) -> anyhow::Result<i64> {
let job_impl = self
@@ -1172,6 +1200,51 @@ impl SchedulerHandle {
Ok(run.id_val())
}
async fn finish_manual_run(
self: Arc<Self>,
job_name: String,
live_config: AppConfig,
db: Database,
pool: sqlx::PgPool,
mut run: JobRun,
) {
let Some(job_impl) = self.registry.get(&job_name) else {
let _ = run
.set_failed(&db, 0, "", &format!("unknown job: {job_name}"))
.await;
return;
};
let start = std::time::Instant::now();
let ctx = JobContext {
config: Arc::new(live_config),
db: db.clone(),
pool: pool.clone(),
run_id: run.id_val(),
registry: Arc::clone(&self.registry),
};
let mut log = JobLog::with_live_flush(pool, run.id_val());
match job_impl.run(&ctx, &mut log).await {
Ok(()) => {
let duration_ms = start.elapsed().as_millis() as i64;
let _ = run.set_completed(&db, duration_ms, &log.output()).await;
}
Err(e) => {
let duration_ms = start.elapsed().as_millis() as i64;
let _ = run
.set_failed(&db, duration_ms, &log.output(), &e.to_string())
.await;
}
}
if let Ok(Some(mut sched_job)) = ScheduledJob::get_by_name(&db, &job_name).await {
sched_job.last_run_at = Some(now_iso().to_string());
sched_job.updated_at = now_iso();
let _ = sched_job.save(&db).await;
}
}
/// Remove a cron job from the scheduler and re-add it with a new cron
/// expression. Also updates the DB row.
pub async fn reschedule_job(&self, job_name: &str, new_cron: &str) -> anyhow::Result<()> {