Compare commits

...
6 Commits
Author SHA1 Message Date
Aleksandr Bogomiakov 9b923851ae Fixed build. Reworked mobile admin UI
Build and Publish / Build and Publish Docker Image (push) Successful in 7m46s
2026-11-18 15:17:50 +00:00
Aleksandr Bogomiakov 939fc00e4c Reworked new users login, improved share feature, enabled track downloads
Build and Publish / Build and Publish Docker Image (push) Failing after 4m21s
2026-11-18 14:40:16 +00:00
Aleksandr Bogomiakov 2b7117a4f6 Fixed metadata AI assistant
Build and Publish / Build and Publish Docker Image (push) Successful in 4m28s
2026-11-16 01:10:59 +00:00
Aleksandr Bogomiakov 3d886d1acd Improved metadata AI Assistant.
Build and Publish / Build and Publish Docker Image (push) Successful in 5m54s
2026-11-16 00:32:33 +00:00
Aleksandr Bogomiakov 4141562e33 Added stat page
Build and Publish / Build and Publish Docker Image (push) Successful in 9m49s
2026-11-12 11:52:38 +00:00
Aleksandr Bogomiakov bcb5d378c8 Add bulk approval for selected admin reviews
Build and Publish / Build and Publish Docker Image (push) Successful in 6m10s
2026-10-23 01:12:54 +01:00
77 changed files with 7623 additions and 8280 deletions

No files matched your search

+1
View File
@@ -48,4 +48,5 @@ jobs:
push: ${{ github.event_name != 'pull_request' }}
tags: ${{ steps.meta.outputs.docker_tags }}
cache-from: type=registry,ref=${{ env.IMAGE_NAME }}:buildcache
# Export intermediate stages, including cargo-chef's compiled dependencies.
cache-to: type=registry,ref=${{ env.IMAGE_NAME }}:buildcache,mode=max
Generated
+1 -1
View File
@@ -1988,7 +1988,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
[[package]]
name = "furumusic"
version = "0.12.0"
version = "0.12.4"
dependencies = [
"anyhow",
"async-stream",
+7 -1
View File
@@ -1,9 +1,15 @@
[package]
name = "furumusic"
version = "0.12.0"
version = "0.12.4"
edition = "2024"
description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
# Unoptimized dependencies overflow macOS compact unwind's 24-bit DWARF offset
# (16 MiB of __eh_frame). Keep dependency code small while leaving application
# code unoptimized and retaining debug symbols, assertions and panic unwinding.
[profile.dev.package."*"]
opt-level = 1
# macOS 27 rejects some stripped proc-macro dylibs with a misaligned LINKEDIT
# string pool. Build scripts and proc macros are compile-time artifacts only.
[profile.release.build-override]
+16 -3
View File
@@ -1,18 +1,31 @@
FROM rust:1-bookworm AS builder
FROM rust:1.97.0-bookworm AS chef
RUN apt-get update \
&& apt-get install -y --no-install-recommends pkg-config libssl-dev ca-certificates \
&& rm -rf /var/lib/apt/lists/*
RUN cargo install cargo-chef --version 0.1.74 --locked
WORKDIR /app
COPY Cargo.toml Cargo.lock* ./
FROM chef AS planner
COPY Cargo.toml Cargo.lock ./
COPY build.rs ./build.rs
COPY src ./src
RUN cargo chef prepare --recipe-path recipe.json
FROM chef AS builder
COPY --from=planner /app/recipe.json ./recipe.json
# Keep compiled dependencies in an ordinary layer exported by CI's registry cache.
RUN cargo chef cook --release --locked --recipe-path recipe.json
COPY Cargo.toml Cargo.lock ./
COPY build.rs ./build.rs
COPY prompts ./prompts
COPY src ./src
COPY templates ./templates
RUN cargo build --release
RUN cargo build --release --locked --bin furumusic
FROM denoland/deno:bin-2.8.3 AS deno
+35 -148
View File
@@ -2,165 +2,52 @@
**Your library. Your users. Your network.**
Furumusic is a self-hosted, multi-user music server with a full web player and
support for the Furumi federated network. It turns a collection of music files
into a shared library that is available from any modern browser, while every
user keeps their own playlists, likes, listening history, and playback state.
Furumusic is a self-hosted music server with a full web player. Bring your music,
share a library with friends, and keep your own playlists, likes, and listening
history. Listen from a desktop or phone, or connect independent servers through
the Furumi federated network.
Music can be uploaded directly, imported from a `.torrent` file, or downloaded
from a magnet link. An optional AI-assisted import pipeline reads the available
tags and path information, reconstructs inconsistent metadata, finds artwork,
and organizes the result into artists, releases, and tracks. Uncertain matches
are kept for review instead of silently entering the library with bad data.
## What you can do
## Why Furumusic?
- **Listen anywhere.** Browse artists and releases, search your collection, build
queues, and manage playlists in a responsive web player.
- **Bring your collection.** Upload files and folders, or import music from
YouTube, torrents, and magnet links directly into your library or a playlist.
- **Organize your music.** Optional AI assistance recognizes metadata, finds
artwork, and helps repair messy releases. Review proposed changes before
applying them.
- **Share a song.** Send a track or queue link that anyone can play and download
without creating an account.
- **Welcome your people.** Use password login or SSO. Instance admins can approve
new users without needing access to the identity provider.
- **Discover more.** Find similar tracks and connect Last.fm for scrobbling.
- **Connect your players.** Pair trusted Furumi devices to synchronize playlists,
likes, playback state, and playback controls.
- **Join a network.** Discover and stream music from other participating peers
while keeping your own library independent.
- **Manage from any screen.** Review imports, manage users and background tasks,
and explore listening statistics in a desktop and mobile admin console.
Furumusic is for a household, a small community, or anyone who wants one music
library without handing it to a subscription service. The server owns the
catalog and media files; the browser is only the player.
AI assistance, federation, similarity search, Last.fm, and SSO are optional.
You choose which features to enable.
- one shared library with separate user accounts;
- a responsive web player with artists, releases, search, queue, and playlists;
- direct file uploads and imports from YouTube, torrent files, or magnet links;
- optional AI-assisted recognition and normalization of metadata;
- password login or OIDC/SSO with group-based access control;
- optional federation without a central catalog or search service;
- trusted-device pairing, playback handoff, and synchronization between Furumi
players;
- Last.fm scrobbling and similarity-based discovery when configured.
## Quick start
Furumusic does not include music. Import only media you are allowed to store and
share.
## Importing music
Users can add audio files from the web interface or ask the server to download
selected files from a torrent. Both routes feed the same import pipeline, so a
library remains consistent regardless of where its files came from.
The importer combines embedded tags, filenames, folder structure, and existing
catalog context. With an OpenAI-compatible language model configured, it can
normalize artist and release names, separate featured artists, recover track
numbers and release types, and flag ambiguous results for a user to approve.
Cover art is taken from nearby image files or embedded artwork when available.
The inbox and permanent library are separate directories. New files are first
processed in the inbox and are moved into the organized library only after
their metadata has been accepted.
## Federation
Federation is optional. Independent Furumusic and Furumi players that use the
same Network ID discover one another as a logical network. Each peer keeps its
own library and can continue working alone.
When federation is enabled, local and remote artists, releases, and tracks can
appear in the same search and library views. Missing audio is streamed from an
available peer and can optionally be retained locally. Similarity search also
stays decentralized: embeddings and exact ranking remain on the instance that
owns the music.
Trusted-device pairing is separate from public catalog discovery. It connects
a user's own Furumi players so likes, playlists, playback state, and control can
move between approved devices.
## Build and run
Furumusic requires PostgreSQL and a Rust toolchain with Rust 2024 edition
support. Create an empty database, provide its connection URL, and start the
server:
With Rust and PostgreSQL installed, create an empty database and start the server:
```bash
export FURU_DATABASE_URL='postgresql://furumusic:password@127.0.0.1/furumusic'
cargo run --release --locked
```
Open <http://127.0.0.1:8000/admin/setup> to create the first administrator.
After setup, configure the inbox and library directories under **Admin →
Settings** before importing music.
Open <http://127.0.0.1:8000/admin/setup> to create your administrator account,
then configure the inbox and music library directories in **Admin → Settings**.
To listen on another address or port:
## Documentation
```bash
cargo run --release --locked -- -l 0.0.0.0:8000
```
- [Installation and configuration](docs/setup.md)
- [Using and administering Furumusic](docs/administration.md)
- [Development, architecture, and tests](docs/development.md)
- [Admin UI conventions](docs/admin-ui.md)
A Nix development shell is included for Linux and macOS:
```bash
nix develop
cargo run --locked
```
The repository also contains a multi-stage `Dockerfile` for building a small
runtime image. A deployment must provide PostgreSQL plus persistent, writable
volumes for the inbox and music library.
## Configuration
Most settings can be changed from the administration interface. Every setting
also has a `FURU_`-prefixed environment variable; environment values take
priority over values stored in PostgreSQL.
The settings needed for a useful first installation are:
| Setting | Purpose |
| --- | --- |
| `FURU_DATABASE_URL` | PostgreSQL connection URL; required to run the service |
| `FURU_AGENT_INBOX_DIR` | Temporary inbox for uploads and downloaded files |
| `FURU_AGENT_STORAGE_DIR` | Permanent, organized music library |
| `FURU_AGENT_ENABLED` | Enables the background metadata import pipeline |
| `FURU_AGENT_LLM_URL` | Base URL of an OpenAI-compatible model server |
| `FURU_AGENT_LLM_MODEL` | Model used to recognize and normalize metadata |
| `FURU_FEDERATION_ENABLED` | Publishes the library and enables peer discovery |
| `FURU_FEDERATION_NETWORK_ID` | Joins peers with the same value into one logical network |
AI recognition, federation, similarity search, Last.fm, and OIDC are optional.
A local password-authenticated server can be used without any of them.
## Architecture
Furumusic is written in Rust on the
[Cot](https://cot.rs) web framework. PostgreSQL stores the catalog, accounts,
playlists, configuration, and background-job state. Audio inspection uses
Symphonia, torrent downloads use librqbit, and the shared `music-dht`/Frid
protocol stack provides decentralized catalog search, media transfer, and
connected-device synchronization.
The browser interface and JSON API are served by the same application. Import,
artwork, metadata enrichment, similarity indexing, and maintenance run as
durable background jobs rather than blocking playback requests.
The `lastfm_popularity` job defaults to **light** mode: it requests popularity
only for tracks without a completed lookup or with a changed title or primary
artist. Both matches (including zero counts) and explicit Last.fm “Track not
found” results are skipped on subsequent light runs. HTTP errors, timeouts,
invalid responses, and other API errors remain eligible for retry. A failed
full refresh also makes that track eligible for the next light run.
Choose **Full: refresh all visible tracks** in the task's admin parameters to
refresh existing statistics and retry previous misses. The options endpoint
`POST /admin/v2/api/jobs/lastfm_popularity/run-options` accepts
`{"refresh_existing": true}`; an empty object, scheduled runs, and the ordinary
run endpoint use light mode. Neither mode limits the number of tracks processed.
An authoritative miss clears current statistics while preserving their history.
The migration preserves existing popularity; legacy misses need one more lookup
because older versions did not persist them.
## Contributing
Bug reports, design discussions, and patches are welcome. Before submitting a
change, run:
```bash
cargo fmt --all -- --check
cargo clippy --all-targets -- -D warnings
cargo test --all-targets
```
Last.fm database tests use temporary tables on a disposable PostgreSQL database:
```bash
FURUMUSIC_LASTFM_TEST_DATABASE_URL=postgres://user:pass@localhost/test_db \
cargo test lastfm_popularity -- --include-ignored
```
Bug reports, ideas, and contributions are welcome.
+100
View File
@@ -0,0 +1,100 @@
# Admin interface conventions
[Project overview](../README.md) · [Development](development.md)
The admin UI uses one Alpine application and shared layout primitives for every
section. Add features to this model rather than introducing a separate mobile
page or section-specific navigation.
## Ownership
- `templates/admin/navigation.html`: the single navigation tree, grouped into
Operations (reviews/tasks), Music (library/tools/statistics), and Instance
(users/settings). Existing hash routes remain the source of navigation state.
- `templates/admin/styles.html`: colors, typography and component appearance.
- `templates/admin/responsive.html`: shared layout, breakpoints, touch targets,
scroll regions, table cards and dialog sizing. Put responsive rules here.
- `templates/admin/ui.html`: viewport state, task tabs, settings navigation and
the shared overlay lifecycle. Business data and API actions remain in
`adminV2()` in `v2.html`.
## Layout
| Width | Navigation | Workspaces | Lists and dialogs |
| --- | --- | --- | --- |
| 1280 px and above | Persistent sidebar | Task list/detail/log side by side | Tables, centered bounded dialogs |
| 1024–1279 px | Persistent sidebar | Task tabs; settings in one column | Tables, bounded dialogs |
| 768–1023 px | Drawer | Task tabs; settings section picker | Tables in contained scroll areas |
| Below 768 px | Drawer | Single column | Table cards, full viewport dialogs |
Keep CSS and `matchMedia` breakpoints in `ui.html` synchronized. The main panel
owns page scrolling. Use `minmax(0, 1fr)` and `min-width:0` for grid/flex children;
never restore a global minimum page width. The top bar stays available while
content scrolls. Navigation closes after route changes and when switching to
the desktop layout. It retains the active section and the existing URL routes.
Use `.panel`, `.panel-head`, `.panel-title`, `.toolbar`, `.action-strip`, `.field`
and `.editor-grid` for new content. Toolbars wrap, inputs fill available space,
and mobile controls use 44 px touch targets and 16 px input text. Long identifiers,
paths and names must wrap. Avoid fixed column widths and inline grid definitions.
For tabular lists, add `.responsive-table`, a `data-label` to every cell, and
`data-primary` to its identifying cell. Mobile CSS presents the same DOM as cards;
do not duplicate rows or hide actions. Give clickable row titles real buttons
using `.row-link`, so the operation also works with a keyboard. Dense comparisons,
charts and logs may scroll inside a named, keyboard-focusable region; horizontal
scrolling must never propagate to the page. Keep these exceptions intentional.
Task tabs change presentation only: configuration and selected run stay in memory
when switching tabs or rotating the device. In settings, add a section ID and a
matching entry to the section picker. Put related controls in `.settings-grid`.
## Dialogs
Every dialog uses the same hierarchy and lifecycle:
```html
<div class="modal-backdrop" x-show="exampleOpen"
x-effect="adminOverlay.sync($el, !!exampleOpen)"
@keydown="adminOverlay.keydown($event, $el)"
@click.self="closeExample()">
<section class="modal" role="dialog" aria-modal="true"
aria-labelledby="example-title" tabindex="-1">
<div class="modal-head">
<strong id="example-title">Edit item</strong>
<button class="icon-btn" data-dialog-close
aria-label="Close dialog" @click="closeExample()">…</button>
</div>
<form class="modal-body" @submit.prevent="saveExample()">
<!-- .field and .editor-grid -->
<div class="dialog-actions"><button type="submit" class="btn primary">Save</button></div>
</form>
</section>
</div>
```
The helper locks the background with `inert`, moves focus into the dialog, traps
Tab/Shift+Tab, handles Escape through the existing close button, and restores
focus on close. Keep business rules in the close handler and disable that button
when closing is not allowed (for example, while merging). Nested pickers consume
Escape with `.stop` before the dialog handles it. Headers remain fixed while the
body scrolls; `.dialog-actions` keeps actions available at the bottom. On mobile,
dialogs use `100dvh` and safe-area padding. Reuse the helper for new overlays.
For content gated by an asynchronous load inside an animated dialog, use
`:hidden="loading"` instead of nesting competing `x-show` transitions. Loading
and content should not both stay hidden when a response arrives during opening.
## Verification
Run `node --test tests/*.test.cjs` and build the Rust application (templates are
compiled into the binary). `tests/browser-admin-responsive.cjs` checks all seven
sections at 320, 390, 768, 1024 and 1440 px, navigation focus, task state retention,
settings jumps, all five dialogs, long content and landscape geometry. It uses a
disposable running instance with an admin and at least one release containing a
track; browser fixtures do not modify server data. Supply `FURU_TEST_URL`,
`FURU_TEST_USERNAME`, `FURU_TEST_PASSWORD`, `PLAYWRIGHT_MODULE`, and `CHROME_PATH`
as appropriate. Set `FURU_TEST_SCREENSHOTS` to inspect screenshots visually.
Check both populated and empty views, long names/paths, loading states, keyboard
navigation, reachable Save/Close controls, and resize while an overlay is open.
+131
View File
@@ -0,0 +1,131 @@
# Using and administering Furumusic
[Project overview](../README.md) · [Installation](setup.md) · [Development and tests](development.md)
## Access and public sharing
OIDC identifies accounts by issuer and subject. Matching admin groups take
precedence over matching user groups, and either SSO grant takes precedence over
a local role. Without matching groups (including an empty group configuration),
a new account waits for approval in **Admin → Users**. Any instance administrator
can approve it as a user or administrator. The waiting page updates automatically.
On subsequent SSO logins the group grant is refreshed: if it disappears, only an
independently assigned local role preserves access. Existing password accounts
keep their local roles; existing OIDC-only accounts retain their last SSO grant
until the next login, without receiving an implicit local approval.
Sharing creates an unguessable `/share/{token}` link to a snapshot of track IDs,
including their order and repetitions. Guests and accounts awaiting approval can
play and download only the tracks in that snapshot, using the regular player.
They cannot browse the library, search, use recommendations, or write personal
history. Signing in from a share returns to that share; signing in from the root
shows only the approval page until access is granted. Track info offers a browser
download of the original audio file. The old radio implementation is removed.
Migration `m_0053_local_approval_and_public_shares` deletes the old share records.
Old track/release/playlist URL routes are removed, with no compatibility layer.
Link expiry, cleanup, and revocation are not part of this implementation.
## Importing music
Users can add audio files from the web interface or ask the server to download
selected files from a torrent. Both routes feed the same import pipeline, so a
library remains consistent regardless of where its files came from.
The importer combines embedded tags, filenames, folder structure, and existing
catalog context. With an OpenAI-compatible language model configured, it can
normalize artist and release names, separate featured artists, recover track
numbers and release types, and flag ambiguous results for a user to approve.
Cover art is taken from nearby image files or embedded artwork when available.
The inbox and permanent library are separate directories. New files are first
processed in the inbox and are moved into the organized library only after
their metadata has been accepted.
## Importing into playlists
The player's download manager offers **Add downloads to a playlist** for file
and folder uploads and torrents, as well as YouTube. Choose an existing owned
playlist or create one before starting; leaving the choice empty imports only
into the library. Selected audio tracks are appended after processing or manual
approval, including files resolved to tracks already in the library.
Migration `m_0052_add_import_playlist_destinations` persists the destination and
completion receipts. Retries and restarts retain the choice, avoid duplicates,
and do not re-add tracks subsequently removed by the user. A started batch keeps
its destination for its remaining files.
## Federation
Federation is optional. Independent Furumusic and Furumi players that use the
same Network ID discover one another as a logical network. Each peer keeps its
own library and can continue working alone.
When federation is enabled, local and remote artists, releases, and tracks can
appear in the same search and library views. Missing audio is streamed from an
available peer and can optionally be retained locally. Similarity search also
stays decentralized: embeddings and exact ranking remain on the instance that
owns the music.
Trusted-device pairing is separate from public catalog discovery. It connects
a user's own Furumi players so likes, playlists, playback state, and control can
move between approved devices.
## Admin statistics
The only admin interface is `/admin/v2`, also reachable from `/admin/`.
**Statistics** shows listening totals, a timeline, artist/track/release rankings,
and paginated history. Select an artist or track to see its listeners, then a
listener to see their history within the same filters. The **Users** list links
to each user's full statistics.
Periods use UTC. Counts come from the synchronized `listen_event` history: a
natural finish, half of a track, or four minutes qualifies as a play. Interrupted
sessions under five seconds are not retained. Short retained sessions contribute
to listened time but not play counts. The source filter separates this instance
from synchronized devices. Artist rankings use recorded artist names, including
featured credits; the same artist is counted once per event. Existing history
remains available when its local audio file is deleted. Library and service
cards show current instance totals, independently of the listening filters.
Migration `m_0051_add_listen_statistics_indexes` adds time and content indexes.
The old admin pages and `/admin/debug` are removed; first-run setup remains at
`/admin/setup`.
## Metadata Repair
Admin → Library Tools provides a chat for editing the selected library resources.
Use **Show related**, then **Deselect all** to choose only the resources needed
for the task. Selecting a release includes its tracks; individual tracks can
then be unchecked to exclude them. Unselected artists remain read-only context
and their IDs can still be used in credits. Releases show their years; tracks
show their source release.
The assistant sees the complete selected scope and replaces the proposed plan
after every clarification. Expand **Proposed changes** in the chat to review or
edit it before applying. Plans support moving tracks, creating releases, merging
releases, and deleting artists, releases, or tracks. Release deletion requires
explicit moves or deletion of all its tracks. Artist deletion detaches credits
and requires all credited releases and tracks to be included.
Applied plans are transactional and can be undone from History. Metadata Repair
retains audio and artwork files for Undo. Undo refuses to overwrite subsequent
metadata, playback, or federation changes.
## Last.fm popularity updates
The `lastfm_popularity` job defaults to **light** mode: it requests popularity
only for tracks without a completed lookup or with a changed title or primary
artist. Both matches (including zero counts) and explicit Last.fm “Track not
found” results are skipped on subsequent light runs. HTTP errors, timeouts,
invalid responses, and other API errors remain eligible for retry. A failed
full refresh also makes that track eligible for the next light run.
Choose **Full: refresh all visible tracks** in the task's admin parameters to
refresh existing statistics and retry previous misses. The options endpoint
`POST /admin/v2/api/jobs/lastfm_popularity/run-options` accepts
`{"refresh_existing": true}`; an empty object, scheduled runs, and the ordinary
run endpoint use light mode. Neither mode limits the number of tracks processed.
An authoritative miss clears current statistics while preserving their history.
The migration preserves existing popularity; legacy misses need one more lookup
because older versions did not persist them.
+122
View File
@@ -0,0 +1,122 @@
# Development
[Project overview](../README.md) · [Installation](setup.md) · [Admin UI conventions](admin-ui.md)
## Architecture
Furumusic is written in Rust on the
[Cot](https://cot.rs) web framework. PostgreSQL stores the catalog, accounts,
playlists, configuration, and background-job state. Audio inspection uses
Symphonia, torrent downloads use librqbit, and the shared `music-dht`/Frid
protocol stack provides decentralized catalog search, media transfer, and
connected-device synchronization.
The browser interface and JSON API are served by the same application. Import,
artwork, metadata enrichment, similarity indexing, and maintenance run as
durable background jobs rather than blocking playback requests.
## Build profiles
Development and test builds use basic optimization (`opt-level = 1`) for
dependencies to keep macOS unwind tables below the compact-unwind size limit.
Application code stays unoptimized; debug symbols, assertions and panic
unwinding remain enabled. The first build compiles dependencies with these
settings, then reuses them from Cargo's cache. Dependency stepping in a debugger
can be less exact because of optimization. Release settings are independent.
See the [Cargo profile override documentation](https://doc.rust-lang.org/cargo/reference/profiles.html#overrides) for dependency-specific settings.
## Container builds and CI
CI uses Rust 1.97.0 and cargo-chef 0.1.74 to cache compiled dependencies separately
from application sources. Buildx imports and exports intermediate layers through
`ultradesu/furumusic:buildcache` (`mode=max`). After the first build, changes to
source code, templates or prompts reuse the dependency layer when its recipe and
toolchain are unchanged. Both dependency and application builds use `--locked`.
Update the pinned build tools in `Dockerfile`; changing them rebuilds the cache.
## Contributing
Bug reports, design discussions, and patches are welcome. Before submitting a
change, run:
```bash
cargo fmt --all -- --check
cargo clippy --all-targets -- -D warnings
cargo test --all-targets
```
Last.fm database tests use temporary tables on a disposable PostgreSQL database:
```bash
FURUMUSIC_LASTFM_TEST_DATABASE_URL=postgres://user:pass@localhost/test_db \
cargo test lastfm_popularity -- --include-ignored
```
## Access and sharing tests
The access regression suite uses a disposable migrated database and a local OIDC
provider with signed tokens and PKCE:
```bash
node --test tests/*.test.cjs
FURU_ACCESS_TEST_DATABASE_URL=postgresql://... cargo test postgres_approval_survives_sso_changes_without_implicit_grants -- --ignored
# Fresh disposable instance on :18048, media root /tmp/furumi-access-media,
# PostgreSQL container furumi-access-test-pg, database furumi_access_test:
node tests/browser-access-sharing.cjs
```
The browser test requires Playwright (`PLAYWRIGHT_MODULE`) and Chrome
(`CHROME_PATH`), and uses local port 18049 for its OIDC provider. It checks
approval, SSO precedence and group removal, guest playback and downloads,
unauthorized track substitution, and desktop/mobile player behavior.
## Statistics tests
```bash
node --test tests/*.test.cjs
cargo test admin:: -- --skip postgres_statistics_drilldown_and_pagination
# Use a disposable PostgreSQL; this test creates connection-local temporary tables.
FURU_STATISTICS_TEST_DATABASE_URL=postgresql://... cargo test postgres_statistics_drilldown_and_pagination -- --ignored
```
`tests/browser-statistics.cjs` additionally exercises a fresh disposable instance
at `FURU_TEST_URL` (default `http://127.0.0.1:3018`) and seeds the disposable Docker
container `furumi-statistics-test-pg`. It requires Playwright (or
`PLAYWRIGHT_MODULE`) and Chrome (or `CHROME_PATH`). Never point this test at a
live service.
## Metadata Repair tests
```bash
node --test tests/admin_metadata_repair.test.cjs
cargo test admin::metadata_fix::tests
```
`tests/browser-metadata-repair.cjs` checks the chat and plan updates, a four-release
merge, deletion and restoration of tracks and artist credits, playlists, playback
queues, and undo conflicts. Run it only against a disposable instance and a
PostgreSQL container named `furumi-repair-test-pg`, with database
`furumi_repair_test`. Set `FURU_TEST_URL`, `FURU_REPAIR_TEST_PG`, `CHROME_PATH`, and
`PLAYWRIGHT_MODULE` as needed. It seeds `tests/metadata_repair_fixture.sql` after
creating the test administrator. Set `FURU_REPAIR_SKIP_SEED=1` for a seeded database.
With `FURU_REPAIR_TEST_MODEL=1`, it additionally checks the reported release-only
selection and full ordered tracklist against the configured model, applies and
undoes that plan, and verifies individual track exclusions.
## Import destination tests
```bash
node --test tests/import_playlists.test.cjs
# Disposable PostgreSQL; both tests use temporary tables.
FURU_IMPORT_TEST_DATABASE_URL=postgresql://... cargo test import_destinations -- --ignored
FURU_IMPORT_TEST_DATABASE_URL=postgresql://... cargo test torrent_playlist -- --ignored
```
`tests/browser-import-playlists.cjs` checks the file upload flow, database
reconciliation and the torrent picker on desktop and mobile. It requires a fresh
migrated instance with the import agent disabled at `FURU_TEST_URL` (default
`http://127.0.0.1:3019`), the disposable PostgreSQL container
`furumi-import-playlist-test-pg` with database `furumi_import_test`, and Playwright
and Chrome configured as above. It uses a local torrent preview fixture and
simulated imported tracks, without downloading external torrents.
+57
View File
@@ -0,0 +1,57 @@
# Installation and configuration
[Project overview](../README.md) · [Administration guide](administration.md)
## Build and run
Furumusic requires PostgreSQL and a Rust toolchain with Rust 2024 edition
support. Create an empty database, provide its connection URL, and start the
server:
```bash
export FURU_DATABASE_URL='postgresql://furumusic:password@127.0.0.1/furumusic'
cargo run --release --locked
```
Open <http://127.0.0.1:8000/admin/setup> to create the first administrator.
After setup, configure the inbox and library directories under **Admin →
Settings** before importing music.
To listen on another address or port:
```bash
cargo run --release --locked -- -l 0.0.0.0:8000
```
A Nix development shell is included for Linux and macOS:
```bash
nix develop
cargo run --locked
```
The repository also contains a multi-stage `Dockerfile` for building a small
runtime image. A deployment must provide PostgreSQL plus persistent, writable
volumes for the inbox and music library.
## Configuration
Most settings can be changed from the administration interface. Every setting
also has a `FURU_`-prefixed environment variable; environment values take
priority over values stored in PostgreSQL.
The settings needed for a useful first installation are:
| Setting | Purpose |
| --- | --- |
| `FURU_DATABASE_URL` | PostgreSQL connection URL; required to run the service |
| `FURU_AGENT_INBOX_DIR` | Temporary inbox for uploads and downloaded files |
| `FURU_AGENT_STORAGE_DIR` | Permanent, organized music library |
| `FURU_AGENT_ENABLED` | Enables the background metadata import pipeline |
| `FURU_AGENT_LLM_URL` | Base URL of an OpenAI-compatible model server |
| `FURU_AGENT_LLM_MODEL` | Model used to recognize and normalize metadata |
| `FURU_FEDERATION_ENABLED` | Publishes the library and enables peer discovery |
| `FURU_FEDERATION_NETWORK_ID` | Joins peers with the same value into one logical network |
AI recognition, federation, similarity search, Last.fm, and OIDC are optional.
A local password-authenticated server can be used without any of them.
+179
View File
@@ -0,0 +1,179 @@
use super::v2::{json_error, require_admin_json};
use crate::{auth::Role, user::User};
use cot::{db::Database, http::StatusCode, json::Json, response::IntoResponse, session::Session};
use serde::Deserialize;
#[derive(Debug, Deserialize)]
pub(super) struct UserRequest {
action: String,
id: Option<i64>,
#[serde(default)]
username: String,
#[serde(default)]
email: String,
#[serde(default)]
display_name: String,
#[serde(default)]
password: String,
#[serde(default)]
role: String,
}
pub(super) async fn manage_user(
session: Session,
db: Database,
Json(body): Json<UserRequest>,
) -> cot::Result<cot::response::Response> {
let admin = match require_admin_json(&session, &db).await {
Ok(u) => u,
Err(r) => return Ok(r),
};
if body.action == "approve" {
let Some(id) = body.id.filter(|id| *id > 0) else {
return Ok(json_error(StatusCode::BAD_REQUEST, "Invalid user"));
};
if Role::from_code(&body.role).is_none() || (id == admin.id && body.role != "admin") {
return Ok(json_error(StatusCode::BAD_REQUEST, "Invalid role"));
}
let Some(mut user) = User::get_by_id(&db, id).await? else {
return Ok(json_error(StatusCode::NOT_FOUND, "User not found"));
};
user.approve(&db, &body.role, admin.id).await?;
} else if body.action == "delete" {
let Some(id) = body.id.filter(|id| *id > 0) else {
return Ok(json_error(StatusCode::BAD_REQUEST, "Invalid user"));
};
if id == admin.id {
return Ok(json_error(
StatusCode::BAD_REQUEST,
"You cannot delete your own account",
));
}
User::delete_by_id(&db, id).await?;
} else {
if !["create", "update"].contains(&body.action.as_str())
|| body.username.trim().is_empty()
|| body.username.chars().count() > 255
|| (Role::from_code(&body.role).is_none()
&& !(body.action == "update" && body.role.is_empty()))
|| (body.action == "create" && body.password.is_empty())
{
return Ok(json_error(
StatusCode::BAD_REQUEST,
"Provide a username, valid role, and a password for new accounts",
));
}
let optional = |s: String| if s.trim().is_empty() { None } else { Some(s) };
let email = optional(body.email);
let display_name = optional(body.display_name);
if body.action == "create" {
if User::get_by_username(&db, body.username.trim())
.await?
.is_some()
{
return Ok(json_error(StatusCode::CONFLICT, "Username already exists"));
}
User::create(
&db,
body.username.trim(),
email.as_deref(),
display_name.as_deref(),
&body.password,
&body.role,
)
.await?;
} else {
let Some(id) = body.id.filter(|id| *id > 0) else {
return Ok(json_error(StatusCode::BAD_REQUEST, "Invalid user"));
};
let Some(mut user) = User::get_by_id(&db, id).await? else {
return Ok(json_error(StatusCode::NOT_FOUND, "User not found"));
};
if id == admin.id && body.role != "admin" && !user.has_sso_admin_role() {
return Ok(json_error(
StatusCode::BAD_REQUEST,
"You cannot remove your own administrator role",
));
}
if User::get_by_username(&db, body.username.trim())
.await?
.is_some_and(|u| u.id_val() != id)
{
return Ok(json_error(StatusCode::CONFLICT, "Username already exists"));
}
user.update_fields(
&db,
body.username.trim(),
email.as_deref(),
display_name.as_deref(),
(!body.password.is_empty()).then_some(body.password.as_str()),
&body.role,
)
.await?;
}
}
Json(serde_json::json!({"ok": true})).into_response()
}
#[derive(Debug, Deserialize)]
pub(super) struct ScheduleRequest {
cron: String,
}
pub(super) async fn schedule(
session: Session,
db: Database,
handle: &std::sync::Arc<
tokio::sync::OnceCell<std::sync::Arc<crate::scheduler::SchedulerHandle>>,
>,
name: &str,
Json(body): Json<ScheduleRequest>,
) -> cot::Result<cot::response::Response> {
if let Err(response) = require_admin_json(&session, &db).await {
return Ok(response);
}
let cron = body.cron.trim();
if !valid_schedule(cron) {
return Ok(json_error(
StatusCode::BAD_REQUEST,
"Invalid cron schedule: include the seconds field",
));
}
if crate::scheduler::ScheduledJob::get_by_name(&db, name)
.await?
.is_none()
{
return Ok(json_error(StatusCode::NOT_FOUND, "Job not found"));
}
let Some(handle) = handle.get() else {
return Ok(json_error(
StatusCode::SERVICE_UNAVAILABLE,
"Scheduler is not ready",
));
};
handle
.reschedule_job(name, cron)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
Json(serde_json::json!({"ok": true})).into_response()
}
fn valid_schedule(cron: &str) -> bool {
cron.len() <= 100
&& croner::parser::CronParser::builder()
.seconds(croner::parser::Seconds::Required)
.build()
.parse(cron)
.is_ok()
&& crate::scheduler::compute_next_run(cron).is_some()
}
#[cfg(test)]
mod tests {
#[test]
fn schedules_use_the_same_seconds_field_as_the_scheduler() {
assert!(super::valid_schedule("0 17 3 * * *"));
assert!(!super::valid_schedule("17 3 * * *"));
assert!(!super::valid_schedule("invalid"));
}
}
+713 -182
View File
File diff suppressed because it is too large. Load diff
+47 -717
View File
@@ -1,6 +1,8 @@
mod management;
mod metadata_fix;
mod setup;
mod statistics;
mod v2;
pub mod views;
use std::sync::Arc;
@@ -20,15 +22,7 @@ use crate::config::AppConfig;
use crate::i18n::I18n;
use crate::scheduler::{JobRegistry, SchedulerHandle};
use crate::user::User;
use views::{
ArtistForm, CronForm, MetadataBackfillForm, OidcSettingsForm, ReleaseForm, ReviewApproveForm,
ReviewsBulkForm, SetImageBody, SetupForm, UploadImageBody, UserForm,
};
#[derive(Debug, Deserialize)]
struct ReviewsQuery {
status: Option<String>,
}
use setup::SetupForm;
/// Build-time metadata baked in by `build.rs` and Cargo env vars.
#[derive(Debug)]
@@ -72,11 +66,6 @@ impl AdminApp {
}
}
#[derive(Debug, Deserialize)]
struct SettingsQuery {
saved: Option<String>,
}
#[derive(Debug, Deserialize)]
struct PathId {
id: i64,
@@ -98,11 +87,6 @@ struct PathNameRunId {
run_id: i64,
}
#[derive(Debug, Deserialize)]
struct ReleasesQuery {
artist_id: Option<i64>,
}
impl App for AdminApp {
fn name(&self) -> &'static str {
"admin"
@@ -122,7 +106,7 @@ impl App for AdminApp {
if count > 0 {
return Ok(auth::redirect("/admin/"));
}
views::setup_page(i18n, String::new())
setup::setup_page(i18n, String::new())
.await?
.into_response()
})
@@ -133,7 +117,7 @@ impl App for AdminApp {
if count > 0 {
return Ok(auth::redirect("/admin/"));
}
views::setup_submit(i18n, &db, &session, form).await
setup::setup_submit(i18n, &db, &session, form).await
},
),
"admin_setup",
@@ -180,6 +164,26 @@ impl App for AdminApp {
},
"admin_v2_dashboard",
),
Route::with_handler_and_name(
"/v2/api/statistics",
{
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
get(move |session: Session, db: Database,
query: UrlQuery<statistics::StatisticsQuery>| {
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;
statistics::statistics(session, db, pg_pool, query.0).await
}
})
},
"admin_statistics",
),
Route::with_handler_and_name(
"/v2/api/reviews",
{
@@ -233,6 +237,25 @@ impl App for AdminApp {
},
"admin_v2_reviews_bulk",
),
Route::with_handler_and_name(
"/v2/api/users/manage",
cot::router::method::post(management::manage_user),
"admin_manage_user",
),
Route::with_handler_and_name(
"/v2/api/jobs/{name}/schedule",
cot::router::method::post({
let handle = Arc::clone(&self.scheduler_handle);
move |session: Session, db: Database, path: Path<PathName>,
json: Json<management::ScheduleRequest>| {
let handle = Arc::clone(&handle);
async move {
management::schedule(session, db, &handle, &path.0.name, json).await
}
}
}),
"admin_job_schedule",
),
Route::with_handler_and_name(
"/v2/api/users",
{
@@ -584,7 +607,7 @@ impl App for AdminApp {
.expect("admin pool")
})
.await;
v2::job_run_detail(session, db, pg_pool, path.0.run_id).await
v2::job_run_detail(session, db, pg_pool, &path.0.name, path.0.run_id).await
}
},
)
@@ -907,699 +930,6 @@ impl App for AdminApp {
},
"admin_index",
),
// -- Debug --------------------------------------------------------
Route::with_handler_and_name(
"/debug",
{
let config = Arc::clone(&self.config);
move |session: Session, db: Database, i18n: I18n| {
let config = Arc::clone(&config);
async move {
let admin =
match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::debug_handler(admin, i18n, &config, &db)
.await?
.into_response()
}
}
},
"admin_debug",
),
// -- Settings -----------------------------------------------------
Route::with_handler_and_name(
"/settings",
get({
let config = Arc::clone(&self.config);
move |session: Session, db: Database, i18n: I18n,
query: UrlQuery<SettingsQuery>| {
let config = Arc::clone(&config);
async move {
let admin =
match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
let saved = query.0.saved.as_deref() == Some("1");
views::settings_handler(admin, i18n, &config, &db, saved)
.await?
.into_response()
}
}
})
.post({
let config = Arc::clone(&self.config);
move |session: Session, db: Database, i18n: I18n,
form: RequestForm<OidcSettingsForm>| {
let config = Arc::clone(&config);
async move {
let admin =
match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::settings_submit(admin, i18n, &config, &db, form).await
}
}
}),
"admin_settings",
),
// -- Settings probe (HTMX fragment) -----------------------------------
Route::with_handler_and_name(
"/settings/probe",
{
let config = Arc::clone(&self.config);
move |session: Session, db: Database, i18n: I18n| {
let config = Arc::clone(&config);
async move {
let admin =
match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::settings_probe_handler(admin, i18n, &config, &db)
.await?
.into_response()
}
}
},
"admin_settings_probe",
),
// -- Users --------------------------------------------------------
Route::with_handler_and_name(
"/users",
|session: Session, db: Database, i18n: I18n| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::users_list(admin, i18n, &db).await?.into_response()
},
"admin_users",
),
Route::with_handler_and_name(
"/users/new",
get(|session: Session, db: Database, i18n: I18n| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::users_new(admin, i18n).await?.into_response()
})
.post(
|session: Session, db: Database, form: RequestForm<UserForm>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::users_create(admin, &db, form).await
},
),
"admin_users_new",
),
Route::with_handler_and_name(
"/users/{id}/edit",
get(
|session: Session, db: Database, i18n: I18n,
path: Path<PathId>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::users_edit(admin, i18n, &db, path.0.id)
.await?
.into_response()
},
)
.post(
|session: Session, db: Database, path: Path<PathId>,
form: RequestForm<UserForm>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::users_update(admin, &db, path.0.id, form).await
},
),
"admin_users_edit",
),
Route::with_handler_and_name(
"/users/{id}/delete",
cot::router::method::post(
|session: Session, db: Database, path: Path<PathId>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::users_delete(admin, &db, path.0.id).await
},
),
"admin_users_delete",
),
// -- Artists ------------------------------------------------------
Route::with_handler_and_name(
"/artists",
|session: Session, db: Database, i18n: I18n| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::artists_list(admin, i18n, &db).await?.into_response()
},
"admin_artists",
),
Route::with_handler_and_name(
"/artists/new",
get(|session: Session, db: Database, i18n: I18n| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::artists_new(admin, i18n).await?.into_response()
})
.post(
|session: Session, db: Database, form: RequestForm<ArtistForm>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::artists_create(admin, &db, form).await
},
),
"admin_artists_new",
),
Route::with_handler_and_name(
"/artists/{id}/edit",
get(
|session: Session, db: Database, i18n: I18n,
path: Path<PathId>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::artists_edit(admin, i18n, &db, path.0.id)
.await?
.into_response()
},
)
.post(
|session: Session, db: Database, path: Path<PathId>,
form: RequestForm<ArtistForm>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::artists_update(admin, &db, path.0.id, form).await
},
),
"admin_artists_edit",
),
Route::with_handler_and_name(
"/artists/{id}/delete",
cot::router::method::post(
|session: Session, db: Database, path: Path<PathId>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::artists_delete(admin, &db, path.0.id).await
},
),
"admin_artists_delete",
),
Route::with_handler_and_name(
"/artists/{id}/available-covers",
get(
|session: Session, db: Database, path: Path<PathId>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::artists_available_covers(admin, &db, path.0.id).await
},
),
"admin_artists_available_covers",
),
Route::with_handler_and_name(
"/artists/{id}/set-image",
cot::router::method::post(
|session: Session, db: Database, path: Path<PathId>,
json: Json<SetImageBody>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::artists_set_image(admin, &db, path.0.id, json.0).await
},
),
"admin_artists_set_image",
),
Route::with_handler_and_name(
"/artists/{id}/upload-image",
cot::router::method::post({
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
move |session: Session, db: Database, path: Path<PathId>,
json: Json<UploadImageBody>| {
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
let pg_pool = pool.get_or_init(|| async {
sqlx::postgres::PgPoolOptions::new()
.max_connections(3)
.connect(&pool_config.database_url)
.await
.expect("admin pool")
}).await;
let (live_config, _) = AppConfig::load_with_db(&db).await;
views::artists_upload_image(admin, &db, pg_pool, &live_config, path.0.id, json.0).await
}
}
}),
"admin_artists_upload_image",
),
// -- Releases -----------------------------------------------------
Route::with_handler_and_name(
"/releases",
|session: Session, db: Database, i18n: I18n,
query: UrlQuery<ReleasesQuery>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::releases_list(admin, i18n, &db, query.0.artist_id)
.await?
.into_response()
},
"admin_releases",
),
Route::with_handler_and_name(
"/releases/new",
get(|session: Session, db: Database, i18n: I18n| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::releases_new(admin, i18n, &db).await?.into_response()
})
.post(
|session: Session, db: Database,
form: RequestForm<ReleaseForm>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::releases_create(admin, &db, form).await
},
),
"admin_releases_new",
),
Route::with_handler_and_name(
"/releases/{id}/edit",
get(
|session: Session, db: Database, i18n: I18n,
path: Path<PathId>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::releases_edit(admin, i18n, &db, path.0.id)
.await?
.into_response()
},
)
.post(
|session: Session, db: Database, path: Path<PathId>,
form: RequestForm<ReleaseForm>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::releases_update(admin, &db, path.0.id, form).await
},
),
"admin_releases_edit",
),
{
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
Route::with_handler_and_name(
"/releases/{id}/delete",
cot::router::method::post(move |session: Session, db: Database, path: Path<PathId>| {
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
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;
views::releases_delete(admin, &db, pg_pool, path.0.id).await
}
}),
"admin_releases_delete",
)
},
// -- Media Files --------------------------------------------------
Route::with_handler_and_name(
"/media-files",
|session: Session, db: Database, i18n: I18n| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::media_files_list(admin, i18n, &db).await?.into_response()
},
"admin_media_files",
),
Route::with_handler_and_name(
"/media-files/{id}/delete",
cot::router::method::post(
|session: Session, db: Database, path: Path<PathId>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::media_files_delete(admin, &db, path.0.id).await
},
),
"admin_media_files_delete",
),
// -- Jobs ---------------------------------------------------------
Route::with_handler_and_name(
"/jobs",
{
let registry = Arc::clone(&self.registry);
move |session: Session, db: Database, i18n: I18n| {
let registry = Arc::clone(&registry);
async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::jobs_list(admin, i18n, &db, &registry).await?.into_response()
}
}
},
"admin_jobs",
),
Route::with_handler_and_name(
"/jobs/metadata_backfill/run-options",
cot::router::method::post({
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
move |session: Session, db: Database,
form: RequestForm<MetadataBackfillForm>| {
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
let pg_pool = pool.get_or_init(|| async {
sqlx::postgres::PgPoolOptions::new()
.max_connections(3)
.connect(&pool_config.database_url)
.await
.expect("admin pool")
}).await;
views::metadata_backfill_run(admin, &db, pg_pool, form).await
}
}
}),
"admin_metadata_backfill_run",
),
Route::with_handler_and_name(
"/jobs/lastfm_popularity/run-options",
cot::router::method::post({
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
move |session: Session, db: Database,
form: RequestForm<views::LastfmPopularityForm>| {
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
let pg_pool = pool.get_or_init(|| async {
sqlx::postgres::PgPoolOptions::new()
.max_connections(3)
.connect(&pool_config.database_url)
.await
.expect("admin pool")
}).await;
views::lastfm_popularity_run(admin, &db, pg_pool, form).await
}
}
}),
"admin_lastfm_popularity_run",
),
Route::with_handler_and_name(
"/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 {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::job_run_now(admin, &handle, &path.0.name).await
}
}
}),
"admin_job_run",
),
Route::with_handler_and_name(
"/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 {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::job_toggle_enabled(admin, &db, &handle, &path.0.name).await
}
}
}),
"admin_job_toggle",
),
Route::with_handler_and_name(
"/jobs/{name}/cron",
cot::router::method::post({
let handle = Arc::clone(&self.scheduler_handle);
move |session: Session, db: Database, path: Path<PathName>,
form: RequestForm<CronForm>| {
let handle = Arc::clone(&handle);
async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::job_update_cron(admin, &db, &handle, &path.0.name, form).await
}
}
}),
"admin_job_cron",
),
Route::with_handler_and_name(
"/jobs/{name}/runs/{run_id}",
{
move |session: Session, db: Database, i18n: I18n,
path: Path<PathNameRunId>| {
async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::job_run_detail(admin, i18n, &db, &path.0.name, path.0.run_id)
.await?
.into_response()
}
}
},
"admin_job_run_detail",
),
Route::with_handler_and_name(
"/jobs/{name}",
{
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
move |session: Session, db: Database, i18n: I18n,
path: Path<PathName>| {
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
let pg_pool = pool.get_or_init(|| async {
sqlx::postgres::PgPoolOptions::new()
.max_connections(3)
.connect(&pool_config.database_url)
.await
.expect("admin pool")
}).await;
views::job_detail(admin, i18n, &db, pg_pool, &path.0.name)
.await?
.into_response()
}
}
},
"admin_job_detail",
),
// -- Reviews: clear -----------------------------------------------
Route::with_handler_and_name(
"/reviews/clear",
cot::router::method::post(
|session: Session, db: Database,
query: UrlQuery<ReviewsQuery>| async move {
let admin =
match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::reviews_clear(admin, &db, query.0.status.as_deref()).await
},
),
"admin_reviews_clear",
),
Route::with_handler_and_name(
"/reviews/bulk",
cot::router::method::post(
|session: Session, db: Database,
form: RequestForm<ReviewsBulkForm>| async move {
let admin =
match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::reviews_bulk(admin, &db, form).await
},
),
"admin_reviews_bulk",
),
// -- Reviews ------------------------------------------------------
Route::with_handler_and_name(
"/reviews",
{
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
move |session: Session, db: Database, i18n: I18n,
query: UrlQuery<ReviewsQuery>| {
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
let pg_pool = pool.get_or_init(|| async {
sqlx::postgres::PgPoolOptions::new()
.max_connections(3)
.connect(&pool_config.database_url)
.await
.expect("admin pool")
}).await;
views::reviews_list(admin, i18n, &db, pg_pool, query.0.status.as_deref())
.await?
.into_response()
}
}
},
"admin_reviews",
),
Route::with_handler_and_name(
"/reviews/{id}",
|session: Session, db: Database, i18n: I18n,
path: Path<PathId>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::review_detail(admin, i18n, &db, path.0.id)
.await?
.into_response()
},
"admin_review_detail",
),
Route::with_handler_and_name(
"/reviews/{id}/approve",
cot::router::method::post({
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>,
form: RequestForm<ReviewApproveForm>| {
let config = Arc::clone(&config);
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
let pg_pool = pool.get_or_init(|| async {
sqlx::postgres::PgPoolOptions::new()
.max_connections(3)
.connect(&pool_config.database_url)
.await
.expect("admin pool")
}).await;
views::review_approve(admin, &config, &db, pg_pool, path.0.id, form).await
}
}
}),
"admin_review_approve",
),
Route::with_handler_and_name(
"/reviews/{id}/reject",
cot::router::method::post(
|session: Session, db: Database, path: Path<PathId>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::review_reject(admin, &db, path.0.id).await
},
),
"admin_review_reject",
),
Route::with_handler_and_name(
"/reviews/{id}/requeue",
cot::router::method::post(
|session: Session, db: Database, path: Path<PathId>| async move {
let admin = match auth::require_admin_or_redirect(&session, &db).await {
Ok(u) => u,
Err(resp) => return Ok(resp),
};
views::review_requeue(admin, &db, path.0.id).await
},
),
"admin_review_requeue",
),
])
}
@@ -1625,7 +955,7 @@ impl App for AdminApp {
}
}
/// Start an options-based run for both admin interfaces. Ordinary scheduler
/// Start an options-based run for the admin interface. Ordinary scheduler
/// entry points continue to call Job::run with light-mode defaults.
async fn start_lastfm_popularity(
db: &Database,
+56
View File
@@ -0,0 +1,56 @@
use crate::auth;
use crate::i18n::{I18n, Translations};
use crate::user::User;
use cot::Template;
use cot::db::Database;
use cot::form::{Form, FormResult};
use cot::html::Html;
use cot::request::extractors::RequestForm;
use cot::response::IntoResponse;
use cot::session::Session;
#[derive(Debug, Template)]
#[template(path = "admin/setup.html")]
struct SetupTemplate {
t: &'static Translations,
message: String,
}
pub async fn setup_page(i18n: I18n, message: String) -> cot::Result<Html> {
let template = SetupTemplate { t: i18n.t, message };
Ok(Html::new(template.render()?))
}
#[derive(Debug, Form)]
pub struct SetupForm {
username: String,
password: String,
confirm_password: String,
}
pub async fn setup_submit(
i18n: I18n,
db: &Database,
session: &Session,
form: RequestForm<SetupForm>,
) -> cot::Result<cot::response::Response> {
let RequestForm(result) = form;
let data = match result {
FormResult::Ok(data) => data,
FormResult::ValidationError(_) => {
return setup_page(i18n, String::new()).await?.into_response();
}
};
if data.password != data.confirm_password {
let msg = i18n.t.setup_mismatch.to_owned();
return setup_page(i18n, msg).await?.into_response();
}
let user = User::create(db, &data.username, None, None, &data.password, "admin")
.await
.map_err(|e| cot::Error::internal(format!("failed to create admin: {e}")))?;
auth::login(session, user.id_val()).await?;
Ok(auth::redirect("/admin/"))
}
+22
View File
@@ -0,0 +1,22 @@
WITH listens AS (
SELECT le.*, COALESCE(NULLIF(u.display_name, ''), u.username::text, 'Deleted user #' || le.user_id) AS user_name,
COALESCE(NULLIF(le.metadata_json->>'title', ''), 'Unknown track') AS title,
COALESCE(le.metadata_json->>'release_title', '') AS release_title,
ARRAY(SELECT DISTINCT trim(name) FROM jsonb_array_elements_text(
COALESCE(le.metadata_json->'artist_names', '[]'::jsonb) ||
COALESCE(le.metadata_json->'featured_artist_names', '[]'::jsonb)
) AS names(name) WHERE trim(name) <> '' ORDER BY trim(name)) AS artist_names,
CASE WHEN le.origin_device_id = ident.device_id THEN 'instance' ELSE 'synced' END AS source,
COALESCE(NULLIF(d.name, ''), le.origin_device_id) AS device_name
FROM furumusic__listen_event le
LEFT JOIN furumusic__user u ON u.id = le.user_id
LEFT JOIN furumusic__fed_device_identity ident ON ident.user_id = le.user_id
LEFT JOIN furumusic__fed_device d ON d.user_id = le.user_id AND d.device_id = le.origin_device_id
WHERE le.started_at_ms >= $1 AND le.started_at_ms < $2
AND ($3::bigint IS NULL OR le.user_id = $3)
AND ($4::text IS NULL OR le.content_id = $4)
), filtered AS (
SELECT * FROM listens
WHERE ($5::text IS NULL OR EXISTS (SELECT 1 FROM unnest(artist_names) n WHERE lower(n) = lower($5)))
AND ($6 = 'all' OR source = $6)
)
+403
View File
@@ -0,0 +1,403 @@
use chrono::{NaiveDate, Utc};
use cot::{db::Database, http::StatusCode, json::Json, response::IntoResponse, session::Session};
use serde::Deserialize;
use serde_json::Value;
use sqlx::PgPool;
use super::v2::{json_error, require_admin_json};
const LISTENS: &str = include_str!("sql/listens.sql");
const PAGE_SIZE: i64 = 25;
#[derive(Debug, Default, Deserialize)]
pub(super) struct StatisticsQuery {
pub from: Option<String>,
pub to: Option<String>,
pub user_id: Option<i64>,
pub content_id: Option<String>,
pub artist: Option<String>,
pub source: Option<String>,
pub kind: Option<String>,
pub search: Option<String>,
pub rank_page: Option<i64>,
pub history_page: Option<i64>,
pub history_kind: Option<String>,
}
struct Filter {
from: i64,
to: i64,
user_id: Option<i64>,
content_id: Option<String>,
artist: Option<String>,
source: String,
}
impl Filter {
fn parse(query: &StatisticsQuery) -> Result<Self, String> {
fn date(value: &str) -> Result<i64, String> {
NaiveDate::parse_from_str(value, "%Y-%m-%d")
.ok()
.and_then(|d| d.and_hms_opt(0, 0, 0))
.map(|d| d.and_utc().timestamp_millis())
.filter(|d| *d >= 0)
.ok_or_else(|| "Use dates in YYYY-MM-DD format (1970 or later)".to_owned())
}
let to = match query.to.as_deref().filter(|s| !s.is_empty()) {
Some(value) => date(value)?
.checked_add(86_400_000)
.ok_or("Invalid end date")?,
None => Utc::now().timestamp_millis(),
};
let from = match query.from.as_deref().filter(|s| !s.is_empty()) {
Some("all") => 0,
Some(value) => date(value)?,
None => to.saturating_sub(30 * 86_400_000),
};
if from >= to {
return Err("Start date must not be after end date".into());
}
let source = query.source.as_deref().unwrap_or("all");
if !["all", "instance", "synced"].contains(&source) {
return Err("Unknown playback source".into());
}
if query.user_id.is_some_and(|id| id <= 0) {
return Err("Invalid user".into());
}
if query.artist.as_ref().is_some_and(|s| s.len() > 1024)
|| query.content_id.as_ref().is_some_and(|s| s.len() > 256)
|| query.search.as_ref().is_some_and(|s| s.len() > 1024)
{
return Err("Filter is too long".into());
}
Ok(Self {
from,
to,
user_id: query.user_id,
content_id: query.content_id.clone(),
artist: query.artist.clone(),
source: source.into(),
})
}
async fn query(&self, pool: &PgPool, suffix: &str) -> anyhow::Result<Value> {
let sql = format!("{LISTENS}{suffix}");
Ok(sqlx::query_scalar(&sql)
.bind(self.from)
.bind(self.to)
.bind(self.user_id)
.bind(&self.content_id)
.bind(&self.artist)
.bind(&self.source)
.fetch_one(pool)
.await?)
}
}
pub(super) async fn statistics(
session: Session,
db: Database,
pool: &PgPool,
query: StatisticsQuery,
) -> cot::Result<cot::response::Response> {
if let Err(response) = require_admin_json(&session, &db).await {
return Ok(response);
}
let filter = match Filter::parse(&query) {
Ok(filter) => filter,
Err(message) => return Ok(json_error(StatusCode::BAD_REQUEST, &message)),
};
let kind = query.kind.as_deref().unwrap_or("artists");
if !["artists", "tracks", "releases", "users"].contains(&kind) {
return Ok(json_error(StatusCode::BAD_REQUEST, "Unknown ranking"));
}
let history_kind = query.history_kind.as_deref().unwrap_or("all");
if !["all", "plays", "short"].contains(&history_kind) {
return Ok(json_error(
StatusCode::BAD_REQUEST,
"Unknown history filter",
));
}
let result = load(pool, &filter, &query, kind, history_kind)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
Json(result).into_response()
}
async fn load(
pool: &PgPool,
filter: &Filter,
query: &StatisticsQuery,
kind: &str,
history_kind: &str,
) -> anyhow::Result<Value> {
let summary_sql = r#"
SELECT to_jsonb(s) FROM (
SELECT COUNT(*) AS events, COUNT(*) FILTER (WHERE qualified) AS plays,
COUNT(*) FILTER (WHERE NOT qualified) AS short_listens,
COUNT(*) FILTER (WHERE trim(both '"' from ended_reason) = 'finished') AS completed,
COALESCE(SUM(listened_ms), 0)::bigint / 1000 AS listened_seconds,
COUNT(DISTINCT user_id) FILTER (WHERE qualified) AS listeners,
COUNT(DISTINCT content_id) FILTER (WHERE qualified) AS tracks,
COUNT(*) FILTER (WHERE qualified AND source = 'instance') AS instance_plays,
COUNT(*) FILTER (WHERE qualified AND source = 'synced') AS synced_plays
FROM filtered
) s"#;
let daily_sql = r#",
bounds AS (
SELECT COALESCE(MIN(started_at_ms), $2) AS first_ms FROM filtered
), granularity AS (
SELECT CASE WHEN $2 - GREATEST($1, first_ms) > 120::bigint * 86400000
THEN 'month' ELSE 'day' END AS unit FROM bounds
), daily AS (
SELECT date_trunc(g.unit, to_timestamp(started_at_ms / 1000.0) AT TIME ZONE 'UTC') AS bucket,
COUNT(*) FILTER (WHERE qualified) AS plays,
COUNT(DISTINCT user_id) FILTER (WHERE qualified) AS listeners,
COALESCE(SUM(listened_ms), 0)::bigint / 1000 AS listened_seconds
FROM filtered CROSS JOIN granularity g GROUP BY bucket
), series AS (
SELECT generate_series((SELECT MIN(bucket) FROM daily), (SELECT MAX(bucket) FROM daily),
CASE WHEN unit = 'month' THEN interval '1 month' ELSE interval '1 day' END) AS bucket
FROM granularity
), filled AS (
SELECT s.bucket, COALESCE(d.plays, 0) AS plays, COALESCE(d.listeners, 0) AS listeners,
COALESCE(d.listened_seconds, 0) AS listened_seconds
FROM series s LEFT JOIN daily d USING (bucket)
)
SELECT jsonb_build_object('unit', (SELECT unit FROM granularity), 'items',
COALESCE((SELECT jsonb_agg(to_jsonb(d) ORDER BY bucket) FROM filled d), '[]'::jsonb))"#;
let (summary, daily, ranking, history, instance) = tokio::try_join!(
filter.query(pool, summary_sql),
filter.query(pool, daily_sql),
ranking(pool, filter, query, kind),
history(pool, filter, query, history_kind),
instance(pool),
)?;
Ok(
serde_json::json!({"summary": summary, "daily": daily, "ranking": ranking,
"history": history, "instance": instance, "from_ms": filter.from, "to_ms": filter.to}),
)
}
async fn ranking(
pool: &PgPool,
filter: &Filter,
query: &StatisticsQuery,
kind: &str,
) -> anyhow::Result<Value> {
// Only fixed SQL fragments are interpolated; every user filter is bound.
let (key, label, extra, join) = match kind {
"users" => ("user_id::text", "MIN(user_name)", "''::text", ""),
"tracks" => (
"content_id",
"MIN(title)",
"MIN(array_to_string(artist_names, ', '))",
"",
),
"releases" => (
"jsonb_build_array(release_title, artist_names)::text",
"MIN(NULLIF(release_title, ''))",
"MIN(array_to_string(artist_names, ', '))",
"",
),
_ => (
"lower(artist.name)",
"MIN(artist.name)",
"''::text",
"CROSS JOIN LATERAL (SELECT DISTINCT ON (lower(n)) n AS name FROM unnest(artist_names) n ORDER BY lower(n), n) artist",
),
};
let sql = format!(
r#"{LISTENS}, ranked AS (
SELECT {key} AS key, {label} AS label, {extra} AS detail, COUNT(*) AS plays,
COUNT(DISTINCT user_id) AS listeners,
SUM(listened_ms)::bigint / 1000 AS listened_seconds, MAX(started_at_ms) AS last_play_ms
FROM filtered {join} WHERE qualified GROUP BY {key}
), searched AS (
SELECT * FROM ranked WHERE label IS NOT NULL
AND ($7::text IS NULL OR strpos(lower(label || ' ' || detail), lower($7)) > 0)
), page AS (SELECT * FROM searched ORDER BY plays DESC, key LIMIT $8 OFFSET $9)
SELECT jsonb_build_object('total', (SELECT COUNT(*) FROM searched),
'items', COALESCE((SELECT jsonb_agg(to_jsonb(p) ORDER BY plays DESC, key) FROM page p), '[]'::jsonb))"#
);
let page = query.rank_page.unwrap_or(1).clamp(1, 1_000_000);
let mut result: Value = sqlx::query_scalar(&sql)
.bind(filter.from)
.bind(filter.to)
.bind(filter.user_id)
.bind(&filter.content_id)
.bind(&filter.artist)
.bind(&filter.source)
.bind(query.search.as_deref().filter(|s| !s.is_empty()))
.bind(PAGE_SIZE)
.bind((page - 1) * PAGE_SIZE)
.fetch_one(pool)
.await?;
result["page"] = page.into();
result["limit"] = PAGE_SIZE.into();
result["kind"] = kind.into();
Ok(result)
}
async fn history(
pool: &PgPool,
filter: &Filter,
query: &StatisticsQuery,
kind: &str,
) -> anyhow::Result<Value> {
let sql = format!(
r#"{LISTENS}, selected AS (
SELECT user_id, user_name, listen_id, content_id, title, artist_names, release_title,
started_at_ms, listened_ms, track_duration_ms, qualified,
trim(both '"' from ended_reason) AS ended_reason, device_name, source
FROM filtered WHERE $7 = 'all' OR ($7 = 'plays' AND qualified) OR ($7 = 'short' AND NOT qualified)
), page AS (SELECT * FROM selected ORDER BY started_at_ms DESC, user_id, listen_id LIMIT $8 OFFSET $9)
SELECT jsonb_build_object('total', (SELECT COUNT(*) FROM selected),
'items', COALESCE((SELECT jsonb_agg(to_jsonb(p) ORDER BY started_at_ms DESC, user_id, listen_id) FROM page p), '[]'::jsonb))"#
);
let page = query.history_page.unwrap_or(1).clamp(1, 1_000_000);
let mut result: Value = sqlx::query_scalar(&sql)
.bind(filter.from)
.bind(filter.to)
.bind(filter.user_id)
.bind(&filter.content_id)
.bind(&filter.artist)
.bind(&filter.source)
.bind(kind)
.bind(PAGE_SIZE)
.bind((page - 1) * PAGE_SIZE)
.fetch_one(pool)
.await?;
result["page"] = page.into();
result["limit"] = PAGE_SIZE.into();
Ok(result)
}
async fn instance(pool: &PgPool) -> anyhow::Result<Value> {
Ok(sqlx::query_scalar(r#"SELECT jsonb_build_object(
'users', (SELECT COUNT(*) FROM furumusic__user),
'tracks', (SELECT COUNT(*) FROM furumusic__track),
'releases', (SELECT COUNT(*) FROM furumusic__release),
'artists', (SELECT COUNT(*) FROM furumusic__artist),
'playlists', (SELECT COUNT(*) FROM furumusic__playlist),
'media_bytes', (SELECT COALESCE(SUM(file_size_bytes), 0)::bigint FROM furumusic__media_file),
'formats', (SELECT COALESCE(jsonb_agg(to_jsonb(f)), '[]'::jsonb) FROM (
SELECT COALESCE(audio_format, 'unknown') AS label, COUNT(*) AS count
FROM furumusic__media_file WHERE file_type = 'audio' GROUP BY audio_format ORDER BY count DESC
) f),
'reviews', (SELECT COALESCE(jsonb_agg(to_jsonb(r)), '[]'::jsonb) FROM (
SELECT status::text AS label, COUNT(*) AS count FROM furumusic__pending_review GROUP BY status ORDER BY status
) r),
'jobs', (SELECT COALESCE(jsonb_agg(to_jsonb(j)), '[]'::jsonb) FROM (
SELECT status::text AS label, COUNT(*) AS count FROM furumusic__job_run GROUP BY status ORDER BY status
) j),
'scrobbles', (SELECT COALESCE(jsonb_agg(to_jsonb(s)), '[]'::jsonb) FROM (
SELECT status::text AS label, COUNT(*) AS count FROM furumusic__lastfm_scrobble_outbox GROUP BY status ORDER BY status
) s)
)"#).fetch_one(pool).await?)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn dates_are_inclusive_utc_and_filters_are_validated() {
let q = StatisticsQuery {
from: Some("2026-11-01".into()),
to: Some("2026-11-01".into()),
..Default::default()
};
let f = Filter::parse(&q).unwrap();
assert_eq!(f.to - f.from, 86_400_000);
assert!(
Filter::parse(&StatisticsQuery {
from: Some("broken".into()),
..q
})
.is_err()
);
assert!(
Filter::parse(&StatisticsQuery {
source: Some("invalid".into()),
..Default::default()
})
.is_err()
);
}
#[tokio::test]
#[ignore = "requires FURU_STATISTICS_TEST_DATABASE_URL pointing at a disposable PostgreSQL"]
async fn postgres_statistics_drilldown_and_pagination() {
let url = std::env::var("FURU_STATISTICS_TEST_DATABASE_URL").expect("test database URL");
// Temporary tables are isolated to this one connection and disappear on close.
let pool = sqlx::postgres::PgPoolOptions::new()
.max_connections(1)
.connect(&url)
.await
.unwrap();
sqlx::raw_sql(include_str!("../../tests/statistics_fixture.sql"))
.execute(&pool)
.await
.unwrap();
let mut q = StatisticsQuery {
from: Some("2026-11-01".into()),
to: Some("2026-11-03".into()),
..Default::default()
};
let result = load(&pool, &Filter::parse(&q).unwrap(), &q, "artists", "all")
.await
.unwrap();
assert_eq!(result["summary"]["plays"], 32);
assert_eq!(result["summary"]["short_listens"], 1);
assert_eq!(result["summary"]["listeners"], 2);
assert_eq!(result["summary"]["listened_seconds"], 5618);
assert_eq!(result["summary"]["synced_plays"], 1);
assert_eq!(result["ranking"]["items"][0]["label"], "Artist A");
assert_eq!(result["ranking"]["items"][0]["plays"], 31); // duplicate artist credits never multiply plays
assert_eq!(result["ranking"]["items"][0]["listeners"], 2);
assert_eq!(result["history"]["total"], 33);
assert_eq!(result["history"]["items"].as_array().unwrap().len(), 25);
assert_eq!(result["daily"]["items"].as_array().unwrap().len(), 3);
assert_eq!(result["daily"]["items"][1]["plays"], 0); // fill the silent day
q.artist = Some("artist a".into());
let result = load(&pool, &Filter::parse(&q).unwrap(), &q, "users", "all")
.await
.unwrap();
assert_eq!(result["ranking"]["total"], 2);
assert_eq!(result["ranking"]["items"][0]["label"], "Alice");
assert_eq!(result["ranking"]["items"][0]["plays"], 30);
q.user_id = Some(2);
let result = load(&pool, &Filter::parse(&q).unwrap(), &q, "tracks", "short")
.await
.unwrap();
assert_eq!(result["summary"]["plays"], 1);
assert_eq!(result["history"]["total"], 1);
assert_eq!(result["history"]["items"][0]["ended_reason"], "skipped");
assert_eq!(result["ranking"]["items"][0]["label"], "First song"); // no local track exists
q.user_id = None;
q.artist = None;
q.history_page = Some(2);
let result = load(&pool, &Filter::parse(&q).unwrap(), &q, "releases", "all")
.await
.unwrap();
assert_eq!(result["history"]["items"].as_array().unwrap().len(), 8);
q.source = Some("synced".into());
let result = load(&pool, &Filter::parse(&q).unwrap(), &q, "users", "all")
.await
.unwrap();
assert_eq!(result["summary"]["plays"], 1);
q.source = Some("instance".into());
q.search = Some("' OR 1=1 --".into());
let result = load(&pool, &Filter::parse(&q).unwrap(), &q, "artists", "all")
.await
.unwrap();
assert_eq!(result["summary"]["plays"], 31);
assert_eq!(result["ranking"]["total"], 0);
q.user_id = Some(3);
let result = load(&pool, &Filter::parse(&q).unwrap(), &q, "users", "all")
.await
.unwrap();
assert_eq!(result["summary"]["plays"], 0);
assert_eq!(result["history"]["total"], 0);
pool.close().await;
}
}
+193 -69
View File
@@ -230,8 +230,13 @@ struct AdminUserRowDto {
email: Option<String>,
role: String,
is_active: bool,
local_role: Option<String>,
sso_role: Option<String>,
is_online: bool,
last_seen_ms: Option<i64>,
plays: i64,
listened_seconds: i64,
last_play_ms: Option<i64>,
}
#[derive(Debug, Serialize, JsonSchema)]
@@ -257,7 +262,7 @@ struct AdminUserStatsDto {
#[derive(Debug, Serialize, JsonSchema)]
struct AdminUserPlayDto {
history_id: i64,
history_id: String,
played_at: String,
duration_listened: Option<i32>,
completed: bool,
@@ -432,6 +437,8 @@ struct JobRunDetailDto {
struct BulkReviewsResponse {
ok: bool,
affected: u64,
failed: u64,
skipped: u64,
}
#[derive(Debug, Serialize, JsonSchema)]
@@ -989,10 +996,14 @@ pub async fn bulk_reviews(
}
let action = body.action.trim();
if action != "delete" && action != "requeue" {
if action != "delete" && action != "requeue" && action != "approve" {
return Ok(json_error(StatusCode::BAD_REQUEST, "unknown bulk action"));
}
if action == "approve" {
return Json(approve_selected_reviews(&db, pool, &body).await?).into_response();
}
let mode = body.mode.as_deref().unwrap_or("ids");
let affected = if mode == "filter" {
apply_review_filter_action(pool, action, body.filter.unwrap_or_default()).await?
@@ -1016,7 +1027,99 @@ pub async fn bulk_reviews(
}
};
Json(BulkReviewsResponse { ok: true, affected }).into_response()
Json(BulkReviewsResponse {
ok: true,
affected,
failed: 0,
skipped: 0,
})
.into_response()
}
fn selected_reviews_query(body: &BulkReviewsRequest) -> QueryBuilder<'static, Postgres> {
let mut qb = QueryBuilder::new("SELECT id FROM furumusic__pending_review WHERE 1=1");
if body.mode.as_deref() == Some("filter") {
let filter = body.filter.clone().unwrap_or_default();
push_review_filters(
&mut qb,
normalize_status(filter.status.as_deref()),
clean_search(filter.search.as_deref()).map(|s| format!("%{s}%")),
);
} else {
qb.push(" AND id = ANY(");
qb.push_bind(body.ids.clone().unwrap_or_default());
qb.push(")");
}
qb.push(" ORDER BY id");
qb
}
async fn approve_selected_reviews(
db: &Database,
pool: &PgPool,
body: &BulkReviewsRequest,
) -> cot::Result<BulkReviewsResponse> {
let ids = selected_reviews_query(body)
.build_query_as::<IdRow>()
.fetch_all(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
let (config, _) = AppConfig::load_with_db(db).await;
let mut result = BulkReviewsResponse {
ok: true,
affected: 0,
failed: 0,
skipped: 0,
};
for row in ids {
let Some(mut review) = crate::scheduler::PendingReview::get_by_id(db, row.id)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?
else {
result.skipped += 1;
continue;
};
if review.status_str() != "pending" {
result.skipped += 1;
continue;
}
// Claim one row at a time so overlapping bulk requests cannot import it twice.
let claimed = sqlx::query(
"UPDATE furumusic__pending_review SET status = 'processing', updated_at = $2 \
WHERE id = $1 AND status = 'pending'",
)
.bind(row.id)
.bind(chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string())
.execute(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
if claimed.rows_affected() == 0 {
result.skipped += 1;
continue;
}
let approval = async {
let normalized = serde_json::from_str::<crate::agent::dto::NormalizedFields>(
review.result_json_str(),
)?;
finalize_review_approval(db, pool, &config, &mut review, &normalized).await
}
.await;
match approval {
Ok(()) => result.affected += 1,
Err(error) => {
tracing::error!(review_id = row.id, ?error, "bulk review approval failed");
review
.set_failed(db, &format!("Review approval failed: {error:#}"))
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
result.failed += 1;
}
}
}
result.ok = result.failed == 0;
Ok(result)
}
pub async fn approve_review(
@@ -1042,31 +1145,9 @@ pub async fn approve_review(
.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()
}
match finalize_review_approval(&db, pool, &live_config, &mut review, &normalized).await {
Ok(()) => Json(serde_json::json!({ "ok": true })).into_response(),
Err(error) => {
tracing::error!(?error, "review approval failed");
let _ = review.set_rejected(&db).await;
@@ -1078,6 +1159,36 @@ pub async fn approve_review(
}
}
async fn finalize_review_approval(
db: &Database,
pool: &PgPool,
config: &AppConfig,
review: &mut crate::scheduler::PendingReview,
normalized: &crate::agent::dto::NormalizedFields,
) -> anyhow::Result<()> {
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 stats = crate::scheduler::ProcessingStats::get_by_review_id(db, review.id_val())
.await
.unwrap_or(None);
let model_name = stats.as_ref().map(|s| s.model_name.to_string());
crate::jobs::inbox_process::finalize_approved(
db,
pool,
config,
&input_path,
normalized,
&context,
&config.agent_storage_dir,
model_name.as_deref(),
)
.await?;
review.set_approved(db).await?;
Ok(())
}
pub async fn jobs(
session: Session,
db: Database,
@@ -1852,6 +1963,7 @@ pub async fn job_run_detail(
session: Session,
db: Database,
pool: &PgPool,
job_name: &str,
run_id: i64,
) -> cot::Result<cot::response::Response> {
if let Err(response) = require_admin_json(&session, &db).await {
@@ -1861,9 +1973,10 @@ pub async fn job_run_detail(
"SELECT id, job_name::text AS job_name, status::text AS status, started_at::text AS started_at, \
finished_at, duration_ms, trigger::text AS trigger, error_message, \
LEFT(COALESCE(log_output, ''), 1600) AS log_excerpt, log_output \
FROM furumusic__job_run WHERE id = $1",
FROM furumusic__job_run WHERE id = $1 AND job_name = $2",
)
.bind(run_id)
.bind(job_name)
.fetch_optional(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
@@ -2556,6 +2669,11 @@ struct AdminUserSqlRow {
email: Option<String>,
role: String,
is_active: bool,
local_role: Option<String>,
sso_role: Option<String>,
plays: i64,
listened_seconds: i64,
last_play_ms: Option<i64>,
}
async fn load_admin_users_page(
@@ -2586,7 +2704,11 @@ async fn load_admin_users_page(
let total: i64 = count_qb.build_query_scalar().fetch_one(pool).await?;
let mut qb = QueryBuilder::<Postgres>::new(
"SELECT id, username::text, display_name, email, role::text, is_active FROM furumusic__user WHERE 1=1",
"SELECT id, username::text, display_name, email, role::text, is_active, local_role, sso_role, \
(SELECT COUNT(*) FROM furumusic__listen_event le WHERE le.user_id = furumusic__user.id AND qualified) AS plays, \
(SELECT (COALESCE(SUM(listened_ms), 0) / 1000)::bigint FROM furumusic__listen_event le WHERE le.user_id = furumusic__user.id) AS listened_seconds, \
(SELECT MAX(started_at_ms) FROM furumusic__listen_event le WHERE le.user_id = furumusic__user.id AND qualified) AS last_play_ms \
FROM furumusic__user WHERE 1=1",
);
if let Some(pattern) = pattern.as_ref() {
qb.push(" AND (username ILIKE ");
@@ -2597,7 +2719,7 @@ async fn load_admin_users_page(
qb.push_bind(pattern);
qb.push(")");
}
qb.push(" ORDER BY username ASC LIMIT ");
qb.push(" ORDER BY is_active ASC, username ASC LIMIT ");
qb.push_bind(limit);
qb.push(" OFFSET ");
qb.push_bind(offset);
@@ -2629,7 +2751,11 @@ async fn load_admin_user_detail(
user_id: i64,
) -> anyhow::Result<Option<AdminUserDetailDto>> {
let row = sqlx::query_as::<_, AdminUserSqlRow>(
"SELECT id, username::text, display_name, email, role::text, is_active FROM furumusic__user WHERE id = $1",
"SELECT id, username::text, display_name, email, role::text, is_active, local_role, sso_role, \
(SELECT COUNT(*) FROM furumusic__listen_event le WHERE le.user_id = furumusic__user.id AND qualified) AS plays, \
(SELECT (COALESCE(SUM(listened_ms), 0) / 1000)::bigint FROM furumusic__listen_event le WHERE le.user_id = furumusic__user.id) AS listened_seconds, \
(SELECT MAX(started_at_ms) FROM furumusic__listen_event le WHERE le.user_id = furumusic__user.id AND qualified) AS last_play_ms \
FROM furumusic__user WHERE id = $1",
)
.bind(user_id)
.fetch_optional(pool)
@@ -2653,17 +2779,17 @@ async fn load_admin_user_detail(
lastfm_connected,
) = tokio::try_join!(
sqlx::query_scalar::<_, i64>(
"SELECT COUNT(*) FROM furumusic__play_history WHERE user_id = $1"
"SELECT COUNT(*) FROM furumusic__listen_event WHERE user_id = $1 AND qualified"
)
.bind(user_id)
.fetch_one(pool),
sqlx::query_scalar::<_, i64>(
"SELECT COUNT(*) FROM furumusic__play_history WHERE user_id = $1 AND completed"
"SELECT COUNT(*) FROM furumusic__listen_event WHERE user_id = $1 AND qualified AND ended_reason = '\"finished\"'"
)
.bind(user_id)
.fetch_one(pool),
sqlx::query_scalar::<_, i64>(
"SELECT COALESCE(SUM(duration_listened), 0)::bigint FROM furumusic__play_history WHERE user_id = $1"
"SELECT (COALESCE(SUM(listened_ms), 0) / 1000)::bigint FROM furumusic__listen_event WHERE user_id = $1"
)
.bind(user_id)
.fetch_one(pool),
@@ -2729,34 +2855,27 @@ async fn load_admin_user_recent_plays(
limit: i64,
) -> anyhow::Result<Vec<AdminUserPlayDto>> {
let rows = sqlx::query_as::<_, AdminUserPlaySqlRow>(
r#"SELECT ph.id AS history_id,
ph.played_at::text AS played_at,
ph.duration_listened,
ph.completed,
t.id AS track_id,
t.title::text AS title,
COALESCE(NULLIF(STRING_AGG(a.name::text, ', ' ORDER BY ta.position), ''), 'Unknown artist') AS artists,
t.release_id,
COALESCE(r.title::text, '') AS release_title,
r.year AS release_year,
t.cover_file_id,
r.cover_file_id AS release_cover_file_id,
t.duration_seconds AS track_duration_seconds,
COALESCE(mf.uploader_name, 'UFO')::text AS uploader_name,
mf.audio_format,
mf.audio_bitrate
FROM furumusic__play_history ph
JOIN furumusic__track t ON t.id = ph.track_id
r#"SELECT le.listen_id AS history_id,
to_timestamp(le.started_at_ms / 1000.0)::text AS played_at,
LEAST(le.listened_ms / 1000, 2147483647)::integer AS duration_listened,
le.ended_reason = '"finished"' AS completed,
COALESCE(t.id, 0) AS track_id,
COALESCE(le.metadata_json->>'title', 'Unknown track') AS title,
COALESCE((SELECT string_agg(name, ', ') FROM jsonb_array_elements_text(
COALESCE(le.metadata_json->'artist_names', '[]'::jsonb)) names(name)), 'Unknown artist') AS artists,
COALESCE(t.release_id, 0) AS release_id,
COALESCE(le.metadata_json->>'release_title', '') AS release_title,
r.year AS release_year, t.cover_file_id, r.cover_file_id AS release_cover_file_id,
COALESCE(le.track_duration_ms / 1000.0, 0)::float8 AS track_duration_seconds,
COALESCE(mf.uploader_name, '')::text AS uploader_name,
mf.audio_format, mf.audio_bitrate
FROM furumusic__listen_event le
LEFT JOIN furumusic__track_ref tr ON tr.content_id = le.content_id
LEFT JOIN furumusic__track t ON t.id = COALESCE(le.local_track_id, tr.local_track_id)
LEFT JOIN furumusic__release r ON r.id = t.release_id
LEFT JOIN furumusic__media_file mf ON mf.id = t.audio_file_id
LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id AND ta.role = 'main'
LEFT JOIN furumusic__artist a ON a.id = ta.artist_id
WHERE ph.user_id = $1
GROUP BY ph.id, ph.played_at, ph.duration_listened, ph.completed, t.id, t.title,
t.release_id, r.title, r.year, t.cover_file_id, r.cover_file_id,
t.duration_seconds, mf.uploader_name, mf.audio_format, mf.audio_bitrate
ORDER BY ph.played_at DESC, ph.id DESC
LIMIT $2"#,
WHERE le.user_id = $1 AND le.qualified
ORDER BY le.started_at_ms DESC, le.listen_id DESC LIMIT $2"#,
)
.bind(user_id)
.bind(limit)
@@ -2787,7 +2906,7 @@ async fn load_admin_user_recent_plays(
#[derive(Debug, sqlx::FromRow)]
struct AdminUserPlaySqlRow {
history_id: i64,
history_id: String,
played_at: String,
duration_listened: Option<i32>,
completed: bool,
@@ -2824,6 +2943,11 @@ fn admin_user_row(
email: row.email,
role: row.role,
is_active: row.is_active,
local_role: row.local_role,
sso_role: row.sso_role,
plays: row.plays,
listened_seconds: row.listened_seconds,
last_play_ms: row.last_play_ms,
is_online: last_seen_ms.is_some_and(|value| value <= online_cutoff_ms),
last_seen_ms,
}
@@ -3443,13 +3567,13 @@ async fn fetch_library_item(
(COALESCE(NULLIF(STRING_AGG(DISTINCT a.name::text, ', '), ''), 'Unknown artist') || COALESCE(' / ' || r.year::text, '')) AS subtitle, \
r.is_hidden, COUNT(DISTINCT t.id)::bigint AS primary_count, \
COUNT(DISTINCT ra.artist_id)::bigint AS secondary_count, \
COUNT(DISTINCT ph.id)::bigint AS tertiary_count, \
COUNT(DISTINCT (ph.user_id, ph.listen_id)) FILTER (WHERE ph.listen_id IS NOT NULL)::bigint AS tertiary_count, \
r.updated_at::text AS updated_at \
FROM furumusic__release r \
LEFT JOIN furumusic__track t ON t.release_id = r.id \
LEFT JOIN furumusic__release_artist ra ON ra.release_id = r.id \
LEFT JOIN furumusic__artist a ON a.id = ra.artist_id \
LEFT JOIN furumusic__play_history ph ON ph.track_id = t.id \
LEFT JOIN furumusic__track_ref playback_ref ON playback_ref.local_track_id = t.id LEFT JOIN furumusic__listen_event ph ON ph.content_id = playback_ref.content_id AND ph.qualified \
WHERE r.id = $1 \
GROUP BY r.id",
)
@@ -3479,13 +3603,13 @@ async fn fetch_library_item(
"SELECT t.id, t.title::text AS title, \
CONCAT(COALESCE(r.title::text, 'No release'), COALESCE(' / #' || t.track_number::text, '')) AS subtitle, \
t.is_hidden, COUNT(DISTINCT ta.artist_id)::bigint AS primary_count, \
COUNT(DISTINCT ph.id)::bigint AS secondary_count, \
COUNT(DISTINCT (ph.user_id, ph.listen_id)) FILTER (WHERE ph.listen_id IS NOT NULL)::bigint AS secondary_count, \
COUNT(DISTINCT pt.playlist_id)::bigint AS tertiary_count, \
t.updated_at::text AS updated_at \
FROM furumusic__track t \
LEFT JOIN furumusic__release r ON r.id = t.release_id \
LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id \
LEFT JOIN furumusic__play_history ph ON ph.track_id = t.id \
LEFT JOIN furumusic__track_ref playback_ref ON playback_ref.local_track_id = t.id LEFT JOIN furumusic__listen_event ph ON ph.content_id = playback_ref.content_id AND ph.qualified \
LEFT JOIN furumusic__playlist_track pt ON pt.track_id = t.id \
WHERE t.id = $1 \
GROUP BY t.id, r.title",
@@ -4256,13 +4380,13 @@ async fn load_release_items(
(COALESCE(NULLIF(STRING_AGG(DISTINCT a.name::text, ', '), ''), 'Unknown artist') || COALESCE(' / ' || r.year::text, '')) AS subtitle, \
r.is_hidden, COUNT(DISTINCT t.id)::bigint AS primary_count, \
COUNT(DISTINCT ra.artist_id)::bigint AS secondary_count, \
COUNT(DISTINCT ph.id)::bigint AS tertiary_count, \
COUNT(DISTINCT (ph.user_id, ph.listen_id)) FILTER (WHERE ph.listen_id IS NOT NULL)::bigint AS tertiary_count, \
r.updated_at::text AS updated_at \
FROM furumusic__release r \
LEFT JOIN furumusic__track t ON t.release_id = r.id \
LEFT JOIN furumusic__release_artist ra ON ra.release_id = r.id \
LEFT JOIN furumusic__artist a ON a.id = ra.artist_id \
LEFT JOIN furumusic__play_history ph ON ph.track_id = t.id \
LEFT JOIN furumusic__track_ref playback_ref ON playback_ref.local_track_id = t.id LEFT JOIN furumusic__listen_event ph ON ph.content_id = playback_ref.content_id AND ph.qualified \
WHERE 1=1",
);
if let Some(pattern) = search_pattern {
@@ -4292,14 +4416,14 @@ async fn load_track_items(
"SELECT t.id, t.title::text AS title, \
CONCAT(COALESCE(r.title::text, 'No release'), COALESCE(' / #' || t.track_number::text, '')) AS subtitle, \
t.is_hidden, COUNT(DISTINCT ta.artist_id)::bigint AS primary_count, \
COUNT(DISTINCT ph.id)::bigint AS secondary_count, \
COUNT(DISTINCT (ph.user_id, ph.listen_id)) FILTER (WHERE ph.listen_id IS NOT NULL)::bigint AS secondary_count, \
COUNT(DISTINCT pt.playlist_id)::bigint AS tertiary_count, \
t.updated_at::text AS updated_at \
FROM furumusic__track t \
LEFT JOIN furumusic__release r ON r.id = t.release_id \
LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id \
LEFT JOIN furumusic__artist a ON a.id = ta.artist_id \
LEFT JOIN furumusic__play_history ph ON ph.track_id = t.id \
LEFT JOIN furumusic__track_ref playback_ref ON playback_ref.local_track_id = t.id LEFT JOIN furumusic__listen_event ph ON ph.content_id = playback_ref.content_id AND ph.qualified \
LEFT JOIN furumusic__playlist_track pt ON pt.track_id = t.id \
WHERE 1=1",
);
-2170
View File
File diff suppressed because it is too large. Load diff
+8 -2
View File
@@ -443,6 +443,9 @@ pub async fn merge_existing(
}
// A repeated YouTube import must still resolve to this existing media ID.
if let Some(sha) = context["sha256"].as_str() {
if let Err(error) = crate::import_playlists::link_media(pool, sha, candidate.media_id).await {
tracing::warn!(%error, "could not link deduplicated import to destination playlists");
}
if let Err(error) = sqlx::query(
r#"INSERT INTO furumusic__youtube_import_media (item_id, media_file_id)
SELECT DISTINCT item.id, $1
@@ -794,7 +797,7 @@ mod tests {
CREATE TABLE furumusic__track_embedding (track_id bigint);
CREATE TABLE test_likes (track_id bigint REFERENCES furumusic__track(id));
CREATE TABLE test_playlist_tracks (track_id bigint REFERENCES furumusic__track(id));
CREATE TABLE furumusic__local_upload (id text PRIMARY KEY, user_id bigint,
CREATE TABLE furumusic__local_upload (target_playlist_id bigint, id text PRIMARY KEY, user_id bigint,
filename text, size_bytes bigint, status text, inbox_path text, error text,
created_at text, updated_at text, completed_at text);
INSERT INTO furumusic__artist VALUES (1, 'Artist', 'artist');
@@ -969,6 +972,7 @@ mod tests {
"song.mp3",
3,
"user_uploads/6/batch/song.mp3",
None,
)
.await
.unwrap();
@@ -979,6 +983,7 @@ mod tests {
"song.mp3",
3,
"user_uploads/6/batch/song.mp3",
None,
)
.await
.unwrap();
@@ -1014,7 +1019,8 @@ mod tests {
7,
"song.mp3",
3,
"user_uploads/7/song.mp3"
"user_uploads/7/song.mp3",
None,
)
.await
.is_err()
+7 -2
View File
@@ -72,8 +72,13 @@ fn authenticated_user_from_user(user: User) -> Option<AuthenticatedUser> {
})
}
/// Read `user_id` from the session, fetch the `User` from DB, return
/// `AuthenticatedUser` if the user exists and is active.
/// Return the signed-in identity, including an account awaiting approval.
pub async fn get_session_identity(session: &Session, db: &Database) -> Option<User> {
let user_id: i64 = session.get(SESSION_USER_ID).await.ok()??;
User::get_by_id(db, user_id).await.ok()?
}
/// Return a session user only when access to the instance has been granted.
pub async fn get_session_user(session: &Session, db: &Database) -> Option<AuthenticatedUser> {
let user_id: i64 = session.get(SESSION_USER_ID).await.ok()??;
let user = User::get_by_id(db, user_id).await.ok()??;
+9 -3
View File
@@ -1,6 +1,12 @@
use super::translations;
translations! {
approval_heading: "Awaiting approval", "Ожидается одобрение";
approval_message: "You are signed in. An instance administrator must approve your account before you can access the library.", "Вы вошли в аккаунт. Для доступа к библиотеке нужно одобрение администратора инстанса.";
guest_login: "Sign in / register", "Войти / зарегистрироваться";
guest_label: "Shared music", "Музыка по ссылке";
share_unavailable: "This link is unavailable or contains no playable tracks.", "Ссылка недоступна или не содержит доступных треков.";
track_download: "Download", "Скачать";
// Global
site_name: "furumusic" , "furumusic";
@@ -71,7 +77,7 @@ translations! {
settings_oidc_admin_groups: "Admin groups" , "Группы администраторов";
settings_oidc_admin_groups_help: "Comma-separated OIDC group names that grant admin role (e.g. /admin,/furumusic-admins)" , "OIDC группы через запятую, дающие роль администратора (напр. /admin,/furumusic-admins)";
settings_oidc_user_groups: "User groups" , "Группы пользователей";
settings_oidc_user_groups_help: "Comma-separated OIDC group names allowed to access the service. If empty, any authenticated SSO user is allowed." , "OIDC группы через запятую, которым разрешён доступ к сервису. Если пусто, разрешён любой SSO пользователь.";
settings_oidc_user_groups_help: "Comma-separated OIDC groups granting automatic user access. Everyone else needs local administrator approval." , "OIDC группы через запятую, дающие автоматический доступ. Остальным нужно локальное одобрение администратора.";
// User management
nav_users: "Users" , "Пользователи";
@@ -360,8 +366,6 @@ translations! {
player_play: "Play" , "Играть";
player_listen: "Listen" , "Слушать";
player_listen_artist: "Listen to artist" , "Слушать артиста";
player_start_radio: "Start radio" , "Запустить радио";
player_radio_failed: "Could not start radio" , "Не удалось запустить радио";
player_played_at: "Played" , "Прослушано";
player_like: "Like" , "Лайк";
player_add_to_queue: "Add to queue" , "Добавить в очередь";
@@ -408,6 +412,8 @@ translations! {
player_youtube_select_all: "Select all" , "Отметить все";
player_youtube_clear_selection: "Clear selection" , "Снять все";
player_youtube_selected_count: "selected" , "выбрано";
player_import_destination: "Add downloads to a playlist" , "Добавить загруженное в плейлист";
player_import_destination_hint: "Selected audio tracks will be added automatically after processing, including tracks already in the library." , "Выбранные аудиотреки будут добавлены автоматически после обработки, включая уже имеющиеся в библиотеке.";
player_youtube_destination: "Add imported tracks to playlist" , "Добавить импортированные треки в плейлист";
player_youtube_no_destination: "Do not add to a playlist" , "Не добавлять в плейлист";
player_youtube_create_playlist: "Create a new playlist" , "Создать новый плейлист";
+280
View File
@@ -0,0 +1,280 @@
//! Durable playlist destinations for file and torrent imports.
use anyhow::{Context, bail};
use sqlx::PgPool;
pub async fn validate_target(
pool: &PgPool,
user_id: i64,
playlist_id: Option<i64>,
) -> anyhow::Result<()> {
if let Some(id) = playlist_id {
let owned: bool = sqlx::query_scalar(
"SELECT EXISTS(SELECT 1 FROM furumusic__playlist WHERE id=$1 AND owner_id=$2)",
)
.bind(id)
.bind(user_id)
.fetch_one(pool)
.await?;
if id <= 0 || !owned {
bail!("selected playlist does not exist or is not yours");
}
}
Ok(())
}
pub async fn register(
pool: &PgPool,
user_id: i64,
playlist_id: i64,
input_path: &str,
sha256: &str,
) -> anyhow::Result<()> {
validate_target(pool, user_id, Some(playlist_id)).await?;
let result = sqlx::query(
r#"INSERT INTO furumusic__import_playlist_target
(user_id, playlist_id, input_path, source_sha256)
VALUES ($1,$2,$3,$4)
ON CONFLICT (user_id, input_path) DO UPDATE SET source_sha256=EXCLUDED.source_sha256
WHERE furumusic__import_playlist_target.playlist_id=EXCLUDED.playlist_id
AND furumusic__import_playlist_target.source_sha256=EXCLUDED.source_sha256"#,
)
.bind(user_id)
.bind(playlist_id)
.bind(input_path)
.bind(sha256)
.execute(pool)
.await?;
if result.rows_affected() == 0 {
bail!("this upload already has a different playlist destination");
}
Ok(())
}
/// Fingerprint deduplication may resolve a differently encoded file to an existing media ID.
pub async fn link_media(pool: &PgPool, source_sha256: &str, media_id: i64) -> anyhow::Result<()> {
if source_sha256.is_empty() {
return Ok(());
}
sqlx::query("UPDATE furumusic__import_playlist_target SET media_file_id=$2 WHERE source_sha256=$1 AND fulfilled_at IS NULL")
.bind(source_sha256).bind(media_id).execute(pool).await?;
reconcile(pool, None).await
}
/// Runs after imports and from background discovery, including after a restart.
/// Fulfilled requests are retained as receipts so later user removals stay removed.
pub async fn reconcile(pool: &PgPool, user_id: Option<i64>) -> anyhow::Result<()> {
let requests: Vec<(i64, i64, String)> = sqlx::query_as(
"SELECT user_id,playlist_id,input_path FROM furumusic__import_playlist_target WHERE fulfilled_at IS NULL AND ($1::bigint IS NULL OR user_id=$1) ORDER BY user_id,playlist_id,input_path"
).bind(user_id).fetch_all(pool).await?;
for (user_id, playlist_id, path) in requests {
let mut transaction = pool.begin().await?;
let pending: Option<String> = sqlx::query_scalar(
"SELECT input_path FROM furumusic__import_playlist_target WHERE user_id=$1 AND input_path=$2 AND fulfilled_at IS NULL FOR UPDATE"
).bind(user_id).bind(&path).fetch_optional(&mut *transaction).await?;
if pending.is_none() {
continue;
}
let track_ids: Vec<i64> = sqlx::query_scalar(r#"
SELECT DISTINCT track.id FROM furumusic__import_playlist_target request
JOIN furumusic__media_file media ON media.id=request.media_file_id
OR (request.media_file_id IS NULL AND media.sha256_hash=request.source_sha256 AND media.file_type='audio')
JOIN furumusic__track track ON track.audio_file_id=media.id
WHERE request.user_id=$1 AND request.input_path=$2 ORDER BY track.id
"#).bind(user_id).bind(&path).fetch_all(&mut *transaction).await?;
if track_ids.is_empty() {
continue;
}
let mut added = Vec::new();
for track_id in track_ids {
if append_in_transaction(&mut transaction, user_id, playlist_id, track_id).await? {
added.push(track_id);
}
}
sqlx::query("UPDATE furumusic__import_playlist_target SET fulfilled_at=$3 WHERE user_id=$1 AND input_path=$2")
.bind(user_id).bind(path).bind(now_string()).execute(&mut *transaction).await?;
transaction.commit().await?;
record_added(pool, user_id, playlist_id, &added).await;
}
Ok(())
}
fn now_string() -> String {
chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string()
}
pub(crate) async fn append_track_to_target_playlist(
pool: &PgPool,
user_id: i64,
playlist_id: i64,
track_id: i64,
) -> anyhow::Result<bool> {
let mut transaction = pool.begin().await?;
let added = append_in_transaction(&mut transaction, user_id, playlist_id, track_id).await?;
transaction.commit().await?;
if added {
record_added(pool, user_id, playlist_id, &[track_id]).await;
}
Ok(added)
}
async fn append_in_transaction(
transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
user_id: i64,
playlist_id: i64,
track_id: i64,
) -> anyhow::Result<bool> {
let playlist: Option<i64> = sqlx::query_scalar(
r#"SELECT id FROM furumusic__playlist
WHERE id = $1 AND owner_id = $2
FOR UPDATE"#,
)
.bind(playlist_id)
.bind(user_id)
.fetch_optional(&mut **transaction)
.await?;
if playlist.is_none() {
return Ok(false);
}
let already_present: bool = sqlx::query_scalar(
r#"SELECT EXISTS (
SELECT 1 FROM furumusic__playlist_track
WHERE playlist_id = $1 AND track_id = $2
)"#,
)
.bind(playlist_id)
.bind(track_id)
.fetch_one(&mut **transaction)
.await?;
if already_present {
return Ok(false);
}
let position: i64 = sqlx::query_scalar(
r#"SELECT COALESCE(MAX(position), -1)::bigint + 1
FROM furumusic__playlist_track WHERE playlist_id = $1"#,
)
.bind(playlist_id)
.fetch_one(&mut **transaction)
.await?;
let position = i32::try_from(position).context("target playlist has too many tracks")?;
let now = now_string();
sqlx::query(
r#"INSERT INTO furumusic__playlist_track
(playlist_id, track_id, position, added_at, added_by_user_id)
VALUES ($1, $2, $3, $4, $5)"#,
)
.bind(playlist_id)
.bind(track_id)
.bind(position)
.bind(&now)
.bind(user_id)
.execute(&mut **transaction)
.await?;
sqlx::query("UPDATE furumusic__playlist SET updated_at = $1 WHERE id = $2")
.bind(&now)
.bind(playlist_id)
.execute(&mut **transaction)
.await?;
Ok(true)
}
async fn record_added(pool: &PgPool, user_id: i64, playlist_id: i64, track_ids: &[i64]) {
if track_ids.is_empty() {
return;
}
if let Err(error) = crate::federation::devices::record_playlist_tracks_added(
pool,
user_id,
playlist_id,
track_ids,
)
.await
{
tracing::warn!(playlist_id, %error, "federation operation for an automatic import playlist addition was not recorded");
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
#[ignore = "requires disposable PostgreSQL in FURU_IMPORT_TEST_DATABASE_URL"]
async fn import_destinations_are_durable_owned_and_idempotent() {
let url = std::env::var("FURU_IMPORT_TEST_DATABASE_URL").unwrap();
let pool = sqlx::postgres::PgPoolOptions::new()
.max_connections(1)
.connect(&url)
.await
.unwrap();
sqlx::raw_sql(r#"
CREATE TEMP TABLE furumusic__playlist(id bigint PRIMARY KEY,owner_id bigint,updated_at text);
CREATE TEMP TABLE furumusic__media_file(id bigint PRIMARY KEY,sha256_hash text,file_type text);
CREATE TEMP TABLE furumusic__track(id bigint PRIMARY KEY,audio_file_id bigint);
CREATE TEMP TABLE furumusic__playlist_track(playlist_id bigint,track_id bigint,position int,added_at text,added_by_user_id bigint);
CREATE TEMP TABLE furumusic__import_playlist_target(user_id bigint,playlist_id bigint REFERENCES furumusic__playlist ON DELETE CASCADE,input_path text,source_sha256 text,media_file_id bigint,fulfilled_at text,PRIMARY KEY(user_id,input_path));
INSERT INTO furumusic__playlist VALUES (10,1,''),(20,2,'');
"#).execute(&pool).await.unwrap();
assert!(validate_target(&pool, 1, Some(20)).await.is_err());
assert!(validate_target(&pool, 1, Some(999)).await.is_err());
validate_target(&pool, 1, None).await.unwrap();
register(&pool, 1, 10, "batch/a.flac", "hash-a")
.await
.unwrap();
register(&pool, 1, 10, "batch/a.flac", "hash-a")
.await
.unwrap();
assert!(
register(&pool, 1, 10, "batch/a.flac", "changed-hash")
.await
.is_err()
);
reconcile(&pool, None).await.unwrap();
let count = || {
sqlx::query_scalar::<_, i64>("SELECT count(*) FROM furumusic__playlist_track")
.fetch_one(&pool)
};
assert_eq!(count().await.unwrap(), 0);
sqlx::raw_sql("INSERT INTO furumusic__media_file VALUES (100,'hash-a','audio'); INSERT INTO furumusic__track VALUES (101,100),(102,100);").execute(&pool).await.unwrap();
reconcile(&pool, Some(2)).await.unwrap();
assert_eq!(count().await.unwrap(), 0);
reconcile(&pool, Some(1)).await.unwrap();
assert_eq!(count().await.unwrap(), 2);
// A second upload of identical audio must not append duplicates.
register(&pool, 1, 10, "torrent/b.flac", "hash-a")
.await
.unwrap();
reconcile(&pool, None).await.unwrap();
assert_eq!(count().await.unwrap(), 2);
sqlx::query("DELETE FROM furumusic__playlist_track WHERE track_id=101")
.execute(&pool)
.await
.unwrap();
reconcile(&pool, None).await.unwrap();
assert_eq!(count().await.unwrap(), 1);
// Fingerprint matching can map a differently encoded upload to the same media.
register(&pool, 2, 20, "batch/a.mp3", "different-encoding")
.await
.unwrap();
link_media(&pool, "different-encoding", 100).await.unwrap();
assert_eq!(count().await.unwrap(), 3);
let positions: Vec<i32> = sqlx::query_scalar(
"SELECT position FROM furumusic__playlist_track WHERE playlist_id=20 ORDER BY position",
)
.fetch_all(&pool)
.await
.unwrap();
assert_eq!(positions, vec![0, 1]);
// Deleting a destination removes pending work without blocking future imports.
register(&pool, 2, 20, "batch/pending.wav", "pending")
.await
.unwrap();
sqlx::query("DELETE FROM furumusic__playlist WHERE id=20")
.execute(&pool)
.await
.unwrap();
reconcile(&pool, None).await.unwrap();
pool.close().await;
}
}
+3
View File
@@ -75,6 +75,9 @@ impl Job for InboxDiscoverJob {
outcome: run_outcome,
};
if let Err(error) = crate::import_playlists::reconcile(&ctx.pool, None).await {
log.warn(&format!("Could not reconcile import playlists: {error}"));
}
let config = &ctx.config;
if config.agent_inbox_dir.is_empty() {
+4
View File
@@ -1271,6 +1271,10 @@ pub async fn finalize_approved(
}
}
if let Err(error) = crate::import_playlists::link_media(pool, sha256, media_file.id_val()).await {
tracing::warn!(%error, "could not add imported tracks to destination playlists; will retry");
}
if let Err(error) =
crate::youtube::sync_target_playlists_for_imported_media(pool, media_file.id_val()).await
{
+14 -7
View File
@@ -103,6 +103,7 @@ pub struct LocalUploadDto {
pub created_at: String,
pub updated_at: String,
pub completed_at: Option<String>,
pub target_playlist_id: Option<i64>,
}
#[derive(Debug, Clone, FromRow)]
@@ -117,6 +118,7 @@ struct LocalUploadRow {
created_at: String,
updated_at: String,
completed_at: Option<String>,
target_playlist_id: Option<i64>,
}
impl LocalUploadRow {
@@ -130,6 +132,7 @@ impl LocalUploadRow {
created_at: self.created_at.clone(),
updated_at: self.updated_at.clone(),
completed_at: self.completed_at.clone(),
target_playlist_id: self.target_playlist_id,
}
}
}
@@ -141,18 +144,20 @@ pub async fn create(
filename: &str,
size_bytes: u64,
inbox_path: &str,
target_playlist_id: Option<i64>,
) -> anyhow::Result<()> {
let now = now_string();
let created = sqlx::query(
r#"INSERT INTO furumusic__local_upload
(id, user_id, filename, size_bytes, status, inbox_path, error,
created_at, updated_at, completed_at)
VALUES ($1, $2, $3, $4, 'uploading', $5, NULL, $6, $6, NULL)
created_at, updated_at, completed_at, target_playlist_id)
VALUES ($1, $2, $3, $4, 'uploading', $5, NULL, $6, $6, NULL, $7)
ON CONFLICT (id) DO UPDATE SET status='uploading', error=NULL, updated_at=$6
WHERE furumusic__local_upload.user_id=$2
AND furumusic__local_upload.inbox_path=$5
AND furumusic__local_upload.size_bytes=$4
AND furumusic__local_upload.status IN ('uploading', 'failed')"#,
AND furumusic__local_upload.status IN ('uploading', 'failed')
AND furumusic__local_upload.target_playlist_id IS NOT DISTINCT FROM $7"#,
)
.bind(id)
.bind(user_id)
@@ -160,6 +165,7 @@ pub async fn create(
.bind(i64::try_from(size_bytes).unwrap_or(i64::MAX))
.bind(inbox_path)
.bind(now)
.bind(target_playlist_id)
.execute(pool)
.await?;
if created.rows_affected() == 0 {
@@ -178,7 +184,7 @@ pub async fn successful_receipt(
) -> anyhow::Result<Option<LocalUploadDto>> {
let row = sqlx::query_as::<_, LocalUploadRow>(
r#"SELECT id, user_id, filename, size_bytes, status, inbox_path, error,
created_at, updated_at, completed_at
created_at, updated_at, completed_at, target_playlist_id
FROM furumusic__local_upload WHERE id=$1 AND user_id=$2 AND inbox_path=$3
AND status NOT IN ('uploading','failed')"#,
)
@@ -205,9 +211,10 @@ pub async fn list(
inbox_dir: &str,
) -> anyhow::Result<Vec<LocalUploadDto>> {
sync_statuses(pool, user_id, inbox_dir).await?;
crate::import_playlists::reconcile(pool, Some(user_id)).await?;
let rows: Vec<LocalUploadRow> = sqlx::query_as(
r#"SELECT id, user_id, filename, size_bytes, status, inbox_path, error,
created_at, updated_at, completed_at
created_at, updated_at, completed_at, target_playlist_id
FROM furumusic__local_upload
WHERE user_id = $1
ORDER BY created_at DESC, id DESC
@@ -244,7 +251,7 @@ async fn sync_statuses(pool: &PgPool, user_id: i64, inbox_dir: &str) -> anyhow::
let rows: Vec<LocalUploadRow> = sqlx::query_as(
r#"SELECT id, user_id, filename, size_bytes, status, inbox_path, error,
created_at, updated_at, completed_at
created_at, updated_at, completed_at, target_playlist_id
FROM furumusic__local_upload
WHERE user_id = $1 AND status <> 'complete'"#,
)
@@ -353,7 +360,7 @@ async fn update_status(
async fn load(pool: &PgPool, user_id: i64, id: &str) -> anyhow::Result<LocalUploadRow> {
sqlx::query_as(
r#"SELECT id, user_id, filename, size_bytes, status, inbox_path, error,
created_at, updated_at, completed_at
created_at, updated_at, completed_at, target_playlist_id
FROM furumusic__local_upload WHERE id = $1 AND user_id = $2"#,
)
.bind(id)
+83 -108
View File
@@ -5,6 +5,7 @@ mod auth;
mod config;
mod federation;
mod i18n;
mod import_playlists;
mod jobs;
mod lastfm;
mod library_cleanup;
@@ -69,59 +70,64 @@ fn build_registry() -> Arc<JobRegistry> {
// Handlers
// ---------------------------------------------------------------------------
#[derive(Deserialize)]
struct IndexQuery {
track: Option<i64>,
release: Option<i64>,
playlist_share: Option<String>,
async fn index(session: Session, db: Database, i18n: I18n) -> cot::Result<cot::response::Response> {
render_player(session, db, i18n, String::new()).await
}
async fn index(
async fn render_player(
session: Session,
db: Database,
i18n: I18n,
UrlQuery(query): UrlQuery<IndexQuery>,
share_token: String,
) -> cot::Result<cot::response::Response> {
let _user = match auth::get_session_user(&session, &db).await {
Some(u) => u,
None => {
if let Some(location) = share_query_redirect(&query) {
auth::remember_post_login_redirect(&session, &location).await?;
}
return Ok(auth::redirect("/login"));
let guest = auth::get_session_user(&session, &db).await.is_none();
if guest && share_token.is_empty() {
if auth::get_session_identity(&session, &db).await.is_some() {
return Html::new(PendingTemplate { t: i18n.t }.render()?).into_response();
}
};
return Ok(auth::redirect("/login"));
}
let (config, _) = AppConfig::load_with_db(&db).await;
let template = player::PlayerPageTemplate {
t: i18n.t,
downloads_enabled: config.downloads_enabled,
torrent_downloads_enabled: config.downloads_enabled && config.torrent_downloads_enabled,
youtube_downloads_enabled: config.downloads_enabled && config.youtube_downloads_enabled,
};
Html::new(template.render()?).into_response()
Html::new(
player::PlayerPageTemplate {
t: i18n.t,
guest,
share_token,
downloads_enabled: !guest && config.downloads_enabled,
torrent_downloads_enabled: !guest
&& config.downloads_enabled
&& config.torrent_downloads_enabled,
youtube_downloads_enabled: !guest
&& config.downloads_enabled
&& config.youtube_downloads_enabled,
}
.render()?,
)
.into_response()
}
fn share_query_redirect(query: &IndexQuery) -> Option<String> {
if let Some(track_id) = query.track.filter(|id| *id > 0) {
return Some(format!("/?track={track_id}"));
}
if let Some(release_id) = query.release.filter(|id| *id > 0) {
return Some(format!("/?release={release_id}"));
}
let token = query.playlist_share.as_deref()?.trim();
if is_share_token(token) {
Some(format!("/?playlist_share={token}"))
} else {
None
}
#[derive(Debug, Template)]
#[template(path = "pending.html")]
struct PendingTemplate {
t: &'static Translations,
}
async fn access_status(session: Session, db: Database) -> cot::Result<cot::response::Response> {
let identity = auth::get_session_identity(&session, &db).await;
let status = match identity {
Some(user) if user.is_active() => "active",
Some(_) => "pending",
None => "anonymous",
};
let mut response = cot::json::Json(serde_json::json!({"status": status})).into_response()?;
response
.headers_mut()
.insert("Cache-Control", "private, no-store".parse().unwrap());
Ok(response)
}
fn is_share_token(token: &str) -> bool {
!token.is_empty()
&& token.len() <= 64
&& token
.bytes()
.all(|b| b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_'))
token.len() == 32 && token.bytes().all(|b| b.is_ascii_hexdigit())
}
#[derive(Deserialize)]
@@ -186,11 +192,7 @@ struct LoginForm {
#[derive(Deserialize)]
struct LoginQuery {
error: Option<String>,
}
#[derive(Deserialize)]
struct SharePathId {
id: i64,
next: Option<String>,
}
#[derive(Deserialize)]
@@ -235,56 +237,26 @@ async fn metrics_handler(
.expect("valid response"))
}
async fn share_track_handler(
session: Session,
db: Database,
Path(path): Path<SharePathId>,
) -> cot::Result<cot::response::Response> {
let location = if path.id > 0 {
format!("/?track={}", path.id)
} else {
"/".to_string()
};
if auth::get_session_user(&session, &db).await.is_none() {
auth::remember_post_login_redirect(&session, &location).await?;
return Ok(auth::redirect("/login"));
}
Ok(auth::redirect(&location))
}
async fn share_release_handler(
session: Session,
db: Database,
Path(path): Path<SharePathId>,
) -> cot::Result<cot::response::Response> {
let location = if path.id > 0 {
format!("/?release={}", path.id)
} else {
"/".to_string()
};
if auth::get_session_user(&session, &db).await.is_none() {
auth::remember_post_login_redirect(&session, &location).await?;
return Ok(auth::redirect("/login"));
}
Ok(auth::redirect(&location))
}
async fn share_playlist_handler(
async fn share_handler(
session: Session,
db: Database,
i18n: I18n,
Path(path): Path<SharePathToken>,
) -> cot::Result<cot::response::Response> {
let token = path.token.trim();
let location = if is_share_token(token) {
format!("/?playlist_share={token}")
} else {
"/".to_string()
};
if auth::get_session_user(&session, &db).await.is_none() {
auth::remember_post_login_redirect(&session, &location).await?;
return Ok(auth::redirect("/login"));
if !is_share_token(&path.token) {
return Ok(cot::http::Response::builder()
.status(cot::http::StatusCode::NOT_FOUND)
.body(Body::fixed("Shared music not found"))
.expect("valid response"));
}
Ok(auth::redirect(&location))
let mut response = render_player(session, db, i18n, path.token).await?;
response
.headers_mut()
.insert("Referrer-Policy", "no-referrer".parse().unwrap());
response
.headers_mut()
.insert("Cache-Control", "private, no-store".parse().unwrap());
Ok(response)
}
// ---------------------------------------------------------------------------
@@ -315,26 +287,13 @@ impl App for FuruApp {
),
Route::with_handler_and_name(
"/",
|session: Session, db: Database, i18n: I18n, query: UrlQuery<IndexQuery>| async move {
index(session, db, i18n, query).await
|session: Session, db: Database, i18n: I18n| async move {
index(session, db, i18n).await
},
"index",
),
Route::with_handler_and_name(
"/share/track/{id}",
get(share_track_handler),
"share_track",
),
Route::with_handler_and_name(
"/share/release/{id}",
get(share_release_handler),
"share_release",
),
Route::with_handler_and_name(
"/share/playlist/{token}",
get(share_playlist_handler),
"share_playlist",
),
Route::with_handler_and_name("/share/{token}", get(share_handler), "share"),
Route::with_handler_and_name("/auth/status", get(access_status), "access_status"),
Route::with_handler_and_name(
"/metrics",
get({
@@ -352,13 +311,29 @@ impl App for FuruApp {
"/login",
get({
let config = Arc::clone(&self.config);
move |i18n: I18n, db: Database, query: UrlQuery<LoginQuery>| {
move |i18n: I18n,
db: Database,
session: Session,
query: UrlQuery<LoginQuery>| {
let config = Arc::clone(&config);
async move {
// No users at all → redirect to first-run setup
if User::count_all(&db).await.unwrap_or(0) == 0 {
return Ok(auth::redirect("/admin/setup"));
}
if let Some(next) = query.0.next.as_deref() {
if next.strip_prefix("/share/").is_some_and(is_share_token) {
auth::remember_post_login_redirect(&session, next).await?;
}
} else {
auth::clear_post_login_redirect(&session).await?;
}
if auth::get_session_identity(&session, &db).await.is_some() {
let destination = auth::get_post_login_redirect(&session)
.await?
.unwrap_or_else(|| "/".into());
return Ok(auth::redirect(&destination));
}
let message = query.0.error.unwrap_or_default();
login_page_handler(i18n, &config, db, message)
.await?
+20 -49
View File
@@ -607,7 +607,7 @@ async fn render_db_metrics(out: &mut String, pool: &PgPool) {
out,
pool,
"furumusic_play_history_total",
"SELECT COUNT(*) FROM furumusic__play_history",
"SELECT COUNT(*) FROM furumusic__listen_event WHERE qualified",
)
.await;
}
@@ -808,9 +808,8 @@ const KNOWN_HTTP_ROUTES: &[&str] = &[
"/admin",
"/swagger",
"/swagger/openapi.json",
"/share/track/{id}",
"/share/release/{id}",
"/share/playlist/{token}",
"/share/{token}",
"/auth/status",
"/metrics",
"/login",
"/logout",
@@ -821,6 +820,9 @@ const KNOWN_HTTP_ROUTES: &[&str] = &[
"/admin/setup",
"/admin/v2",
"/admin/v2/api/dashboard",
"/admin/v2/api/statistics",
"/admin/v2/api/users/manage",
"/admin/v2/api/jobs/{name}/schedule",
"/admin/v2/api/reviews",
"/admin/v2/api/reviews/bulk",
"/admin/v2/api/users",
@@ -844,40 +846,6 @@ const KNOWN_HTTP_ROUTES: &[&str] = &[
"/admin/v2/api/library/item/upload-image",
"/admin/v2/api/library/bulk",
"/admin/v2/api/library/releases/merge",
"/admin/debug",
"/admin/settings",
"/admin/settings/probe",
"/admin/users",
"/admin/users/new",
"/admin/users/{id}/edit",
"/admin/users/{id}/delete",
"/admin/artists",
"/admin/artists/new",
"/admin/artists/{id}/edit",
"/admin/artists/{id}/delete",
"/admin/artists/{id}/available-covers",
"/admin/artists/{id}/set-image",
"/admin/artists/{id}/upload-image",
"/admin/releases",
"/admin/releases/new",
"/admin/releases/{id}/edit",
"/admin/releases/{id}/delete",
"/admin/media-files",
"/admin/media-files/{id}/delete",
"/admin/jobs",
"/admin/jobs/metadata_backfill/run-options",
"/admin/jobs/{name}/run",
"/admin/jobs/{name}/toggle",
"/admin/jobs/{name}/cron",
"/admin/jobs/{name}/runs/{run_id}",
"/admin/jobs/{name}",
"/admin/reviews/clear",
"/admin/reviews/bulk",
"/admin/reviews",
"/admin/reviews/{id}",
"/admin/reviews/{id}/approve",
"/admin/reviews/{id}/reject",
"/admin/reviews/{id}/requeue",
"/api/player/me",
"/api/player/lastfm/status",
"/api/player/lastfm/connect",
@@ -911,10 +879,11 @@ const KNOWN_HTTP_ROUTES: &[&str] = &[
"/api/player/artists",
"/api/player/artists/{id}",
"/api/player/releases/{id}",
"/api/player/radio/{kind}/{id}",
"/api/player/playlists",
"/api/player/share-playlist",
"/api/player/share-playlist/{id}",
"/api/player/shares",
"/api/player/shares/{id}",
"/api/player/shares/{token}/{action}/{track_id}",
"/api/player/download/{track_id}",
"/api/player/playlists/{id}",
"/api/player/playlists/{id}/tracks",
"/api/player/likes",
@@ -946,21 +915,23 @@ mod tests {
#[test]
fn known_http_route_matches_declared_dynamic_routes() {
assert_eq!(known_http_route("/admin/debug"), None);
assert_eq!(
known_http_route("/admin/v2/api/statistics"),
Some("/admin/v2/api/statistics")
);
assert_eq!(
known_http_route("/api/player/stream/42"),
Some("/api/player/stream/{track_id}")
);
assert_eq!(
known_http_route("/admin/jobs/metadata_backfill/runs/123"),
Some("/admin/jobs/{name}/runs/{run_id}")
known_http_route("/admin/v2/api/jobs/metadata_backfill/runs/123"),
Some("/admin/v2/api/jobs/{name}/runs/{run_id}")
);
assert_eq!(known_http_route("/share/abcDEF123"), Some("/share/{token}"));
assert_eq!(
known_http_route("/share/playlist/abcDEF123"),
Some("/share/playlist/{token}")
);
assert_eq!(
known_http_route("/share/release/42"),
Some("/share/release/{id}")
known_http_route("/api/player/shares/abcDEF123/stream/42"),
Some("/api/player/shares/{token}/{action}/{track_id}")
);
assert_eq!(
known_http_route("/api/player/youtube/start"),
+49 -84
View File
@@ -78,10 +78,6 @@ impl Artist {
Self::objects().all(db).await
}
pub async fn get_by_id(db: &Database, artist_id: i64) -> cot::db::Result<Option<Self>> {
Self::get_by_primary_key(db, Auto::Fixed(artist_id)).await
}
pub async fn create(
db: &Database,
name: &str,
@@ -102,41 +98,9 @@ impl Artist {
Ok(artist)
}
pub async fn update_name(&mut self, db: &Database, name: &str) -> cot::db::Result<()> {
self.name = LimitedString::new(name).unwrap();
self.name_sort = LimitedString::new(&normalize_name(name)).unwrap();
self.updated_at = now_iso();
self.save(db).await
}
pub async fn set_image_file_id(
&mut self,
db: &Database,
file_id: Option<i64>,
) -> cot::db::Result<()> {
self.image_file_id = file_id;
self.updated_at = now_iso();
self.save(db).await
}
pub async fn delete_by_id(db: &Database, artist_id: i64) -> cot::db::Result<()> {
cot::db::query!(Artist, $id == Auto::Fixed(artist_id))
.delete(db)
.await?;
Ok(())
}
pub fn id_val(&self) -> i64 {
self.id.unwrap()
}
pub fn name_str(&self) -> &str {
&self.name
}
pub fn is_hidden(&self) -> bool {
self.is_hidden
}
}
// ---------------------------------------------------------------------------
@@ -286,47 +250,9 @@ impl ReleaseArtist {
.await
}
pub async fn find_by_artist(db: &Database, artist_id: i64) -> cot::db::Result<Vec<Self>> {
cot::db::query!(ReleaseArtist, $artist_id == artist_id)
.all(db)
.await
}
pub async fn count_by_artist(db: &Database, artist_id: i64) -> cot::db::Result<u64> {
cot::db::query!(ReleaseArtist, $artist_id == artist_id)
.count(db)
.await
}
pub async fn set_artists(
db: &Database,
release_id: i64,
artist_ids: &[i64],
) -> cot::db::Result<()> {
// Remove existing links
cot::db::query!(ReleaseArtist, $release_id == release_id)
.delete(db)
.await?;
// Insert new links
for (pos, &aid) in artist_ids.iter().enumerate() {
let mut link = Self {
id: Auto::auto(),
release_id,
artist_id: aid,
position: pos as i32,
};
link.insert(db).await?;
}
Ok(())
}
pub fn artist_id(&self) -> i64 {
self.artist_id
}
pub fn release_id(&self) -> i64 {
self.release_id
}
}
// ---------------------------------------------------------------------------
@@ -377,12 +303,6 @@ pub struct TrackArtist {
}
impl TrackArtist {
pub async fn count_by_artist(db: &Database, artist_id: i64) -> cot::db::Result<u64> {
cot::db::query!(TrackArtist, $artist_id == artist_id)
.count(db)
.await
}
pub async fn create(
db: &Database,
track_id: i64,
@@ -556,10 +476,6 @@ pub struct PlaybackState {
}
impl Track {
pub async fn list_all(db: &Database) -> cot::db::Result<Vec<Self>> {
Self::objects().all(db).await
}
pub async fn create(
db: &Database,
title: &str,
@@ -2875,6 +2791,53 @@ pub mod db_migrations {
&[Operation::custom(create_metadata_fix_history).build()];
}
#[cot::db::migrations::migration_op]
async fn add_listen_statistics_indexes(
ctx: migrations::MigrationContext<'_>,
) -> cot::db::Result<()> {
ctx.db.raw("CREATE INDEX IF NOT EXISTS idx_listen_event_time ON furumusic__listen_event (started_at_ms DESC)").await?;
ctx.db.raw("CREATE INDEX IF NOT EXISTS idx_listen_event_content_plays ON furumusic__listen_event (content_id) WHERE qualified").await?;
Ok(())
}
#[derive(Debug, Copy, Clone)]
pub struct M0051AddListenStatisticsIndexes;
impl migrations::Migration for M0051AddListenStatisticsIndexes {
const APP_NAME: &'static str = "furumusic";
const MIGRATION_NAME: &'static str = "m_0051_add_listen_statistics_indexes";
const DEPENDENCIES: &'static [migrations::MigrationDependency] =
&[migrations::MigrationDependency::migration(
"furumusic",
"m_0050_create_metadata_fix_history",
)];
const OPERATIONS: &'static [Operation] =
&[Operation::custom(add_listen_statistics_indexes).build()];
}
#[cot::db::migrations::migration_op]
async fn add_import_playlist_destinations(
ctx: migrations::MigrationContext<'_>,
) -> cot::db::Result<()> {
ctx.db.raw("ALTER TABLE furumusic__torrent_session ADD COLUMN target_playlist_id BIGINT REFERENCES furumusic__playlist(id) ON DELETE SET NULL").await?;
ctx.db.raw("ALTER TABLE furumusic__local_upload ADD COLUMN target_playlist_id BIGINT REFERENCES furumusic__playlist(id) ON DELETE SET NULL").await?;
ctx.db.raw("CREATE TABLE furumusic__import_playlist_target (user_id BIGINT NOT NULL, playlist_id BIGINT NOT NULL REFERENCES furumusic__playlist(id) ON DELETE CASCADE, input_path TEXT NOT NULL, source_sha256 TEXT NOT NULL, media_file_id BIGINT REFERENCES furumusic__media_file(id) ON DELETE SET NULL, fulfilled_at TEXT, PRIMARY KEY(user_id,input_path))").await?;
ctx.db.raw("CREATE INDEX idx_import_playlist_pending_hash ON furumusic__import_playlist_target(source_sha256) WHERE fulfilled_at IS NULL").await?;
Ok(())
}
#[derive(Debug, Copy, Clone)]
pub struct M0052AddImportPlaylistDestinations;
impl migrations::Migration for M0052AddImportPlaylistDestinations {
const APP_NAME: &'static str = "furumusic";
const MIGRATION_NAME: &'static str = "m_0052_add_import_playlist_destinations";
const DEPENDENCIES: &'static [migrations::MigrationDependency] =
&[migrations::MigrationDependency::migration(
"furumusic",
"m_0051_add_listen_statistics_indexes",
)];
const OPERATIONS: &'static [Operation] =
&[Operation::custom(add_import_playlist_destinations).build()];
}
pub const MIGRATIONS: &[&SyncDynMigration] = &[
&M0006CreateMediaFile,
&M0007CreateArtist,
@@ -2916,5 +2879,7 @@ pub mod db_migrations {
&M0048AddPlaybackCoordinationColumns,
&M0049AddLastfmLookupState,
&M0050CreateMetadataFixHistory,
&M0051AddListenStatisticsIndexes,
&M0052AddImportPlaylistDestinations,
];
}
+135 -84
View File
@@ -418,16 +418,6 @@ pub async fn oidc_callback_handler(
config.oidc_user_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,
config.oidc_admin_groups,
);
crate::metrics::record_auth_attempt("oidc", "failure", "not_in_group");
return redirect_login_with_error(i18n.t.login_access_denied);
}
// User provisioning logic.
let user = match provision_user(
&db,
@@ -437,6 +427,7 @@ pub async fn oidc_callback_handler(
name.as_deref(),
&groups,
&config.oidc_admin_groups,
&config.oidc_user_groups,
)
.await
{
@@ -728,17 +719,6 @@ pub async fn oidc_mobile_callback_handler(
.map(|n| n.to_string());
let groups = extract_groups_from_jwt(&id_token.to_string());
if !is_allowed_by_groups(&groups, &config.oidc_user_groups, &config.oidc_admin_groups) {
tracing::warn!(
"Mobile OIDC login denied by group allowlist: sub={sub}, groups={groups:?}, user_groups={:?}, admin_groups={:?}",
config.oidc_user_groups,
config.oidc_admin_groups,
);
crate::metrics::record_auth_attempt("mobile_oidc", "failure", "not_in_group");
clear_mobile_oidc_session(&session).await?;
return Ok(mobile_redirect_error(&app_redirect_uri, "access_denied"));
}
let user = match provision_user(
&db,
&issuer,
@@ -747,6 +727,7 @@ pub async fn oidc_mobile_callback_handler(
name.as_deref(),
&groups,
&config.oidc_admin_groups,
&config.oidc_user_groups,
)
.await
{
@@ -759,6 +740,11 @@ pub async fn oidc_mobile_callback_handler(
}
};
if !user.is_active() {
clear_mobile_oidc_session(&session).await?;
return Ok(mobile_redirect_error(&app_redirect_uri, "approval_pending"));
}
let exchange_code = auth::create_mobile_exchange_code(&db, user.id_val())
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
@@ -773,48 +759,26 @@ pub async fn oidc_mobile_callback_handler(
// User provisioning
// ---------------------------------------------------------------------------
/// Resolve the role based on OIDC group membership.
/// If `admin_groups` is non-empty and any user group matches, return "admin";
/// otherwise return "user".
fn resolve_role(groups: &[String], admin_groups: &str) -> &'static str {
if admin_groups.is_empty() {
return auth::Role::User.code();
/// Group-derived access always takes precedence over local approval.
fn resolve_sso_role(
groups: &[String],
admin_groups: &str,
user_groups: &str,
) -> Option<&'static str> {
let matches = |configured: &str| {
configured
.split(',')
.map(str::trim)
.filter(|group| !group.is_empty())
.any(|group| groups.iter().any(|g| g == group))
};
if matches(admin_groups) {
Some("admin")
} else if matches(user_groups) {
Some("user")
} else {
None
}
let admin_set: std::collections::HashSet<&str> = admin_groups
.split(',')
.map(|s| s.trim())
.filter(|s| !s.is_empty())
.collect();
if admin_set.is_empty() {
return auth::Role::User.code();
}
for g in groups {
if admin_set.contains(g.as_str()) {
return auth::Role::Admin.code();
}
}
auth::Role::User.code()
}
fn parse_group_set(groups: &str) -> std::collections::HashSet<&str> {
groups
.split(',')
.map(str::trim)
.filter(|s| !s.is_empty())
.collect()
}
fn has_any_group(groups: &[String], allowed: &std::collections::HashSet<&str>) -> bool {
groups.iter().any(|g| allowed.contains(g.as_str()))
}
fn is_allowed_by_groups(groups: &[String], user_groups: &str, admin_groups: &str) -> bool {
let user_set = parse_group_set(user_groups);
if user_set.is_empty() {
return true;
}
let admin_set = parse_group_set(admin_groups);
has_any_group(groups, &user_set) || has_any_group(groups, &admin_set)
}
async fn provision_user(
@@ -825,8 +789,9 @@ async fn provision_user(
name: Option<&str>,
groups: &[String],
admin_groups: &str,
user_groups: &str,
) -> Result<User, String> {
let role = resolve_role(groups, admin_groups);
let role = resolve_sso_role(groups, admin_groups, user_groups);
// 1. Check for existing OIDC link.
if let Some(mut link) = OidcLink::find_by_issuer_sub(db, issuer, sub)
@@ -841,8 +806,8 @@ async fn provision_user(
.await
.map_err(|e| format!("DB error updating OIDC link: {e}"))?;
// Always update role on login.
user.update_role(db, role)
// Refresh only the SSO grant; preserve independent local approval.
user.sync_sso_role(db, role)
.await
.map_err(|e| format!("DB error updating user role: {e}"))?;
@@ -863,25 +828,6 @@ async fn provision_user(
}
}
// 2. No existing link — try to find a user by email.
if let Some(email_str) = email {
if let Some(mut user) = User::get_by_email(db, email_str)
.await
.map_err(|e| format!("DB error finding user by email: {e}"))?
{
// Create OIDC link for existing user.
OidcLink::create_link(db, user.id_val(), issuer, sub, email, name)
.await
.map_err(|e| format!("DB error creating OIDC link: {e}"))?;
user.update_role(db, role)
.await
.map_err(|e| format!("DB error updating user role: {e}"))?;
return Ok(user);
}
}
// 3. Create a brand-new user + OIDC link.
// Generate a unique username from the sub or email.
let username = if let Some(email_str) = email {
@@ -1300,3 +1246,108 @@ mod tests {
assert!(safe_mobile_redirect_uri(Some("http://127.0.0.1:notaport/x")).is_none());
}
}
#[cfg(test)]
mod approval_tests {
use super::*;
#[test]
fn matching_groups_are_required_and_admin_wins() {
let groups = vec!["listeners".into(), "admins".into()];
assert_eq!(
resolve_sso_role(&groups, " admins ", "listeners"),
Some("admin")
);
assert_eq!(
resolve_sso_role(&groups, "other", "listeners"),
Some("user")
);
assert_eq!(resolve_sso_role(&groups, "other", ""), None);
assert_eq!(resolve_sso_role(&[], "", ""), None);
}
#[tokio::test]
#[ignore = "requires a migrated disposable database in FURU_ACCESS_TEST_DATABASE_URL"]
async fn postgres_approval_survives_sso_changes_without_implicit_grants() {
let db = Database::new(std::env::var("FURU_ACCESS_TEST_DATABASE_URL").unwrap())
.await
.unwrap();
let subject = format!("approval-test-{}", uuid::Uuid::new_v4());
let provision = |groups: Vec<String>| {
let db = &db;
let subject = &subject;
async move {
provision_user(
db,
"https://test.example",
subject,
None,
Some("Test pending user"),
&groups,
"admins",
"listeners",
)
.await
.unwrap()
}
};
let first = provision(vec![]).await;
assert!(!first.is_active());
let mut again = provision(vec![]).await;
assert_eq!(again.id_val(), first.id_val());
again.approve(&db, "admin", 1).await.unwrap();
assert_eq!(provision(vec![]).await.role(), auth::Role::Admin);
assert_eq!(
provision(vec!["listeners".into()]).await.role(),
auth::Role::User
);
assert_eq!(
provision(vec!["admins".into()]).await.role(),
auth::Role::Admin
);
assert_eq!(provision(vec![]).await.role(), auth::Role::Admin);
let auto_sub = format!("auto-{subject}");
let automatic = provision_user(
&db,
"https://test.example",
&auto_sub,
None,
None,
&["listeners".into()],
"admins",
"listeners",
)
.await
.unwrap();
assert!(automatic.is_active());
let removed = provision_user(
&db,
"https://test.example",
&auto_sub,
None,
None,
&[],
"admins",
"listeners",
)
.await
.unwrap();
assert!(!removed.is_active());
assert_eq!(automatic.id_val(), removed.id_val());
// A stale User held by an OIDC callback must retain a newer local grant.
let mut stale = removed.clone();
let mut approving = removed.clone();
approving.approve(&db, "admin", 1).await.unwrap();
stale.sync_sso_role(&db, Some("user")).await.unwrap();
stale.sync_sso_role(&db, None).await.unwrap();
assert!(stale.is_active());
assert_eq!(stale.role(), auth::Role::Admin);
let username = stale.username_str().to_owned();
stale
.update_fields(&db, &username, None, Some("Renamed"), None, "")
.await
.unwrap();
assert!(!stale.is_active());
}
}
+1 -1
View File
@@ -324,7 +324,7 @@ pub(super) struct ShareLinkResponse {
}
#[derive(Debug, Serialize, JsonSchema)]
pub(super) struct PlaylistShareDetail {
pub(super) struct ShareDetail {
pub(super) token: String,
pub(super) title: String,
pub(super) tracks: Vec<TrackItem>,
+169 -563
View File
@@ -30,6 +30,7 @@ mod dto;
mod helpers;
mod queries;
mod rows;
mod sharing;
use dto::*;
use helpers::{cover_variant_url, load_release_uploaders, track_cover_variant_url};
@@ -114,9 +115,6 @@ const PLAYER_DEVICE_COMMAND_TTL_MS: i64 = 20_000;
const PLAYER_DEVICE_MAX_COMMANDS: usize = 32;
const PLAYER_JAM_IDLE_TTL_MS: i64 = 4 * 60 * 60 * 1000;
const PLAYER_JAM_MAX_INVITEES: usize = 25;
const PLAYER_RADIO_TRACK_LIMIT: usize = 40;
const PLAYER_RADIO_CANDIDATE_LIMIT: i64 = 220;
const PLAYER_RADIO_RELEASE_SEED_TRACKS: i64 = 4;
const FED_DEVICE_PREFIX: &str = "fed:";
#[derive(Debug, Clone)]
@@ -1641,6 +1639,8 @@ struct LastfmCallbackQuery {
#[template(path = "player.html")]
pub struct PlayerPageTemplate {
pub t: &'static Translations,
pub guest: bool,
pub share_token: String,
pub downloads_enabled: bool,
pub torrent_downloads_enabled: bool,
pub youtube_downloads_enabled: bool,
@@ -1655,6 +1655,8 @@ mod page_template_tests {
fn download_manager_button_follows_the_global_switch() {
let disabled = PlayerPageTemplate {
t: Translations::for_lang(Lang::En),
guest: false,
share_token: String::new(),
downloads_enabled: false,
torrent_downloads_enabled: false,
youtube_downloads_enabled: false,
@@ -1666,6 +1668,8 @@ mod page_template_tests {
let enabled = PlayerPageTemplate {
t: Translations::for_lang(Lang::En),
guest: false,
share_token: String::new(),
downloads_enabled: true,
torrent_downloads_enabled: true,
youtube_downloads_enabled: true,
@@ -4770,15 +4774,15 @@ async fn similarity_search_handler(
}
// ---------------------------------------------------------------------------
// POST /api/player/share-playlist
// POST /api/player/shares
// ---------------------------------------------------------------------------
async fn create_playlist_share_handler(
async fn create_share_handler(
auth_ctx: auth::AuthContext,
session: Session,
db: Database,
pool: &sqlx::PgPool,
Json(body): Json<CreatePlaylistShareRequest>,
Json(body): Json<CreateShareRequest>,
) -> cot::Result<cot::response::Response> {
let Some(user) = auth::get_request_user(&auth_ctx, &session, &db).await else {
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
@@ -4818,7 +4822,7 @@ async fn create_playlist_share_handler(
let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
sqlx::query(
r#"INSERT INTO furumusic__playlist_share_link
r#"INSERT INTO furumusic__share_link
(token, creator_user_id, title, track_ids_json, created_at)
VALUES ($1, $2, $3, $4, $5)"#,
)
@@ -4833,51 +4837,7 @@ async fn create_playlist_share_handler(
Json(ShareLinkResponse {
token: token.clone(),
url: format!("/share/playlist/{token}"),
})
.into_response()
}
// ---------------------------------------------------------------------------
// GET /api/player/share-playlist/{id}
// ---------------------------------------------------------------------------
async fn playlist_share_detail_handler(
auth_ctx: auth::AuthContext,
session: Session,
db: Database,
pool: &sqlx::PgPool,
path: Path<PathStringId>,
) -> cot::Result<cot::response::Response> {
let Some(_user) = auth::get_request_user(&auth_ctx, &session, &db).await else {
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
};
let token = path.0.id.trim().to_string();
let share: Option<(String, String)> = sqlx::query_as(
r#"SELECT title::text, track_ids_json::text
FROM furumusic__playlist_share_link
WHERE token = $1"#,
)
.bind(&token)
.fetch_optional(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
let Some((title, track_ids_json)) = share else {
return Ok(json_error(
StatusCode::NOT_FOUND,
"shared playlist not found",
));
};
let ids: Vec<i64> = serde_json::from_str(&track_ids_json).unwrap_or_default();
let tracks = load_track_items_by_ids(pool, &ids).await?;
Json(PlaylistShareDetail {
token,
title,
tracks,
url: format!("/share/{token}"),
})
.into_response()
}
@@ -4993,11 +4953,20 @@ async fn stream_handler(
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
};
let track_id = path.0.track_id;
audio_response(pool, config, request, path.0.track_id, false).await
}
async fn audio_response(
pool: &sqlx::PgPool,
config: &AppConfig,
request: &cot::http::Request<Body>,
track_id: i64,
download: bool,
) -> cot::Result<cot::http::Response<Body>> {
// Look up track → audio_file_id → MediaFile
let media = sqlx::query_as::<_, MediaFileRow>(
r#"SELECT mf.file_path,
mf.original_filename::text AS original_filename,
mf.mime_type::text as mime_type,
mf.file_size_bytes,
mf.sha256_hash::text AS sha256_hash,
@@ -5025,7 +4994,29 @@ async fn stream_handler(
));
}
let file_size = media.file_size_bytes as u64;
let file_size = tokio::fs::metadata(&full_path)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?
.len();
let filename = media
.original_filename
.rsplit(['/', '\\'])
.next()
.filter(|name| !name.is_empty())
.unwrap_or("track");
let disposition = if download {
format!(
"attachment; filename=\"track-{}\"; filename*=UTF-8''{}",
track_id,
filename
.as_bytes()
.iter()
.map(|b| format!("%{b:02X}"))
.collect::<String>()
)
} else {
"inline".to_owned()
};
let etag = media_etag("audio", track_id, &media.sha256_hash, None);
// Parse Range header
@@ -5037,40 +5028,61 @@ async fn stream_handler(
let (start, end) = range;
let chunk_size = end - start + 1;
let data = read_file_range(&full_path, start, chunk_size).await?;
use futures_util::TryStreamExt;
use tokio::io::{AsyncReadExt, AsyncSeekExt};
let mut file = tokio::fs::File::open(&full_path)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
file.seek(std::io::SeekFrom::Start(start))
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
let data = tokio_util::io::ReaderStream::new(file.take(chunk_size))
.map_err(|e| cot::Error::internal(e.to_string()));
crate::metrics::record_stream_request(true, chunk_size);
let response = cot::http::Response::builder()
.status(StatusCode::PARTIAL_CONTENT)
.header(CONTENT_TYPE, media.mime_type.as_str())
.header(ACCEPT_RANGES, "bytes")
.header("Content-Disposition", disposition.as_str())
.header("Cache-Control", "private, no-store")
.header(CONTENT_RANGE, format!("bytes {start}-{end}/{file_size}"))
.header(CONTENT_LENGTH, chunk_size.to_string())
.header("ETag", etag.as_str())
.header("X-Furumi-Content-Sha256", media.sha256_hash.as_str())
.header("X-Furumi-Content-Updated-At", media.created_at.as_str())
.body(Body::fixed(data))
.body(Body::streaming(data))
.expect("valid response");
return Ok(response);
}
return Ok(cot::http::Response::builder()
.status(StatusCode::RANGE_NOT_SATISFIABLE)
.header(CONTENT_RANGE, format!("bytes */{file_size}"))
.body(Body::fixed(""))
.expect("valid response"));
}
// No Range or invalid range: return full file
let data = tokio::fs::read(&full_path)
// No Range: stream the full file.
let file = tokio::fs::File::open(&full_path)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
use futures_util::TryStreamExt;
let data =
tokio_util::io::ReaderStream::new(file).map_err(|e| cot::Error::internal(e.to_string()));
crate::metrics::record_stream_request(false, file_size);
let response = cot::http::Response::builder()
.status(StatusCode::OK)
.header(CONTENT_TYPE, media.mime_type.as_str())
.header(ACCEPT_RANGES, "bytes")
.header("Content-Disposition", disposition.as_str())
.header("Cache-Control", "private, no-store")
.header(CONTENT_LENGTH, file_size.to_string())
.header("ETag", etag.as_str())
.header("X-Furumi-Content-Sha256", media.sha256_hash.as_str())
.header("X-Furumi-Content-Updated-At", media.created_at.as_str())
.body(Body::fixed(data))
.body(Body::streaming(data))
.expect("valid response");
Ok(response)
@@ -5157,6 +5169,29 @@ async fn local_upload_handler(
));
}
let target_playlist_id = match request.headers().get("x-furumusic-target-playlist-id") {
None => None,
Some(header) => match header
.to_str()
.ok()
.and_then(|s| s.parse::<i64>().ok())
.filter(|id| *id > 0)
{
Some(id) => Some(id),
None => {
return Ok(json_error(
StatusCode::BAD_REQUEST,
"invalid target playlist ID",
));
}
},
};
if let Err(error) =
crate::import_playlists::validate_target(pool, user.id, target_playlist_id).await
{
return Ok(json_error(StatusCode::BAD_REQUEST, &error.to_string()));
}
let batch_header_id = request
.headers()
.get("x-furumusic-upload-batch-id")
@@ -5273,6 +5308,12 @@ async fn local_upload_handler(
.await
.map_err(|err| cot::Error::internal(err.to_string()))?
{
if upload.target_playlist_id != target_playlist_id {
return Ok(json_error(
StatusCode::BAD_REQUEST,
"upload playlist destination cannot change on retry",
));
}
return Json(LocalUploadResponse { ok: true, upload }).into_response();
}
if let Err(err) = crate::local_uploads::create(
@@ -5282,12 +5323,24 @@ async fn local_upload_handler(
&display_name,
bytes.len() as u64,
&inbox_path,
target_playlist_id,
)
.await
{
return Ok(json_error(StatusCode::BAD_REQUEST, &err.to_string()));
}
if let Some(playlist_id) = target_playlist_id {
use sha2::{Digest, Sha256};
let sha256 = format!("{:x}", Sha256::digest(&bytes));
if let Err(error) =
crate::import_playlists::register(pool, user.id, playlist_id, &inbox_path, &sha256)
.await
{
return Ok(json_error(StatusCode::BAD_REQUEST, &error.to_string()));
}
}
let write_result = crate::local_uploads::save_file(&destination, &upload_id, &bytes).await;
if let Err(err) = write_result {
let message = format!("could not save uploaded file: {err}");
@@ -5415,6 +5468,9 @@ fn hex_value(byte: u8) -> Option<u8> {
}
fn parse_range(header: &str, file_size: u64) -> Option<(u64, u64)> {
if file_size == 0 {
return None;
}
let bytes_prefix = "bytes=";
if !header.starts_with(bytes_prefix) {
return None;
@@ -5522,8 +5578,18 @@ async fn cover_response(
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
};
cover_file_response(pool, config, media_file_id, variant_name).await
}
async fn cover_file_response(
pool: &sqlx::PgPool,
config: &AppConfig,
media_file_id: i64,
variant_name: Option<&str>,
) -> cot::Result<cot::http::Response<Body>> {
let media = sqlx::query_as::<_, MediaFileRow>(
r#"SELECT file_path,
original_filename::text AS original_filename,
mime_type::text as mime_type,
file_size_bytes,
sha256_hash::text AS sha256_hash,
@@ -8048,474 +8114,6 @@ async fn toggle_follow_artist_handler(
}
}
// ---------------------------------------------------------------------------
// GET /api/player/radio/{kind}/{id}
// ---------------------------------------------------------------------------
fn append_unique_track_ids(track_ids: &mut Vec<i64>, candidates: Vec<i64>, limit: usize) {
let mut seen: HashSet<i64> = track_ids.iter().copied().collect();
for candidate in candidates {
if track_ids.len() >= limit {
break;
}
if seen.insert(candidate) {
track_ids.push(candidate);
}
}
}
async fn track_primary_artist_ids(pool: &sqlx::PgPool, track_id: i64) -> cot::Result<Vec<i64>> {
sqlx::query_scalar::<_, i64>(
r#"SELECT artist_id
FROM furumusic__track_artist
WHERE track_id = $1 AND role <> 'featuring'
ORDER BY position, artist_id"#,
)
.bind(track_id)
.fetch_all(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))
}
async fn release_primary_artist_ids(pool: &sqlx::PgPool, release_id: i64) -> cot::Result<Vec<i64>> {
sqlx::query_scalar::<_, i64>(
r#"SELECT artist_id
FROM furumusic__release_artist
WHERE release_id = $1
ORDER BY position, artist_id"#,
)
.bind(release_id)
.fetch_all(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))
}
async fn fallback_radio_track_ids(
pool: &sqlx::PgPool,
user_id: i64,
artist_ids: &[i64],
excluded_ids: &[i64],
limit: i64,
) -> cot::Result<Vec<i64>> {
if limit <= 0 {
return Ok(Vec::new());
}
sqlx::query_scalar::<_, i64>(
r#"SELECT t.id
FROM furumusic__track t
JOIN furumusic__release r ON r.id = t.release_id
WHERE t.is_hidden = false
AND r.is_hidden = false
AND NOT (t.id = ANY($3::bigint[]))
ORDER BY (
CASE WHEN EXISTS (
SELECT 1 FROM furumusic__user_liked_track ult
WHERE ult.user_id = $1 AND ult.track_id = t.id
) THEN 9.0 ELSE 0.0 END
+ CASE WHEN EXISTS (
SELECT 1 FROM furumusic__track_artist ta
WHERE ta.track_id = t.id
AND ta.role <> 'featuring'
AND ta.artist_id = ANY($2::bigint[])
) THEN 5.0 ELSE 0.0 END
+ COALESCE(t.lastfm_rating, 0.0) * 0.7
+ ln(COALESCE(t.lastfm_playcount, 0)::double precision + 1.0) * 0.04
+ ln(COALESCE(t.lastfm_listeners, 0)::double precision + 1.0) * 0.03
+ random() * 2.0
) DESC, t.id
LIMIT $4"#,
)
.bind(user_id)
.bind(artist_ids)
.bind(excluded_ids)
.bind(limit)
.fetch_all(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))
}
async fn track_radio_candidate_ids(
pool: &sqlx::PgPool,
user_id: i64,
track_id: i64,
limit: i64,
) -> cot::Result<Vec<i64>> {
sqlx::query_scalar::<_, i64>(
r#"WITH seed_track AS (
SELECT t.id, t.release_id
FROM furumusic__track t
JOIN furumusic__release r ON r.id = t.release_id
WHERE t.id = $1 AND t.is_hidden = false AND r.is_hidden = false
),
seed_artists AS (
SELECT ta.artist_id
FROM furumusic__track_artist ta
JOIN seed_track st ON st.id = ta.track_id
WHERE ta.role <> 'featuring'
),
seed_tag_sources AS (
SELECT egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__entity_genre_tag egt
JOIN seed_track st ON egt.entity_kind = 'track' AND egt.entity_id = st.id
UNION ALL
SELECT tg.genre_id, 1.0 AS weight
FROM furumusic__track_genre tg
JOIN seed_track st ON st.id = tg.track_id
UNION ALL
SELECT egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__entity_genre_tag egt
JOIN seed_track st ON egt.entity_kind = 'release' AND egt.entity_id = st.release_id
),
seed_tags AS (
SELECT genre_id, max(weight) AS seed_weight
FROM seed_tag_sources
GROUP BY genre_id
),
candidate_tag_sources AS (
SELECT egt.entity_id AS track_id,
egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__entity_genre_tag egt
WHERE egt.entity_kind = 'track'
UNION ALL
SELECT tg.track_id, tg.genre_id, 1.0 AS weight
FROM furumusic__track_genre tg
UNION ALL
SELECT t.id AS track_id,
egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__track t
JOIN furumusic__entity_genre_tag egt
ON egt.entity_kind = 'release' AND egt.entity_id = t.release_id
),
candidate_tags AS (
SELECT track_id, genre_id, max(weight) AS weight
FROM candidate_tag_sources
GROUP BY track_id, genre_id
),
tag_scores AS (
SELECT ct.track_id, sum(st.seed_weight * ct.weight) AS tag_score
FROM candidate_tags ct
JOIN seed_tags st ON st.genre_id = ct.genre_id
GROUP BY ct.track_id
)
SELECT t.id
FROM furumusic__track t
JOIN furumusic__release r ON r.id = t.release_id
LEFT JOIN tag_scores score ON score.track_id = t.id
WHERE t.is_hidden = false
AND r.is_hidden = false
AND t.id <> $1
AND (
COALESCE(score.tag_score, 0.0) > 0.0
OR EXISTS (
SELECT 1
FROM furumusic__track_artist ta
JOIN seed_artists sa ON sa.artist_id = ta.artist_id
WHERE ta.track_id = t.id AND ta.role <> 'featuring'
)
OR EXISTS (
SELECT 1 FROM furumusic__user_liked_track ult
WHERE ult.user_id = $2 AND ult.track_id = t.id
)
)
ORDER BY (
COALESCE(score.tag_score, 0.0) * 12.0
+ CASE
WHEN EXISTS (
SELECT 1 FROM furumusic__user_liked_track ult
WHERE ult.user_id = $2 AND ult.track_id = t.id
) AND COALESCE(score.tag_score, 0.0) > 0.0 THEN 12.0
WHEN EXISTS (
SELECT 1 FROM furumusic__user_liked_track ult
WHERE ult.user_id = $2 AND ult.track_id = t.id
) THEN 3.0
ELSE 0.0
END
+ CASE WHEN EXISTS (
SELECT 1
FROM furumusic__track_artist ta
JOIN seed_artists sa ON sa.artist_id = ta.artist_id
WHERE ta.track_id = t.id AND ta.role <> 'featuring'
) THEN 4.0 ELSE 0.0 END
+ COALESCE(t.lastfm_rating, 0.0) * 0.65
+ ln(COALESCE(t.lastfm_playcount, 0)::double precision + 1.0) * 0.04
+ ln(COALESCE(t.lastfm_listeners, 0)::double precision + 1.0) * 0.03
+ random() * 1.6
) DESC, t.id
LIMIT $3"#,
)
.bind(track_id)
.bind(user_id)
.bind(limit)
.fetch_all(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))
}
async fn release_radio_candidate_ids(
pool: &sqlx::PgPool,
user_id: i64,
release_id: i64,
excluded_ids: &[i64],
limit: i64,
) -> cot::Result<Vec<i64>> {
sqlx::query_scalar::<_, i64>(
r#"WITH seed_release AS (
SELECT id
FROM furumusic__release
WHERE id = $1 AND is_hidden = false
),
seed_artists AS (
SELECT ra.artist_id
FROM furumusic__release_artist ra
JOIN seed_release sr ON sr.id = ra.release_id
),
seed_tag_sources AS (
SELECT egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__entity_genre_tag egt
JOIN seed_release sr ON egt.entity_kind = 'release' AND egt.entity_id = sr.id
UNION ALL
SELECT egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__track t
JOIN seed_release sr ON sr.id = t.release_id
JOIN furumusic__entity_genre_tag egt
ON egt.entity_kind = 'track' AND egt.entity_id = t.id
UNION ALL
SELECT tg.genre_id, 1.0 AS weight
FROM furumusic__track t
JOIN seed_release sr ON sr.id = t.release_id
JOIN furumusic__track_genre tg ON tg.track_id = t.id
),
seed_tags AS (
SELECT genre_id, max(weight) AS seed_weight
FROM seed_tag_sources
GROUP BY genre_id
),
candidate_release_tag_sources AS (
SELECT egt.entity_id AS release_id,
egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__entity_genre_tag egt
WHERE egt.entity_kind = 'release'
UNION ALL
SELECT t.release_id,
egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__track t
JOIN furumusic__entity_genre_tag egt
ON egt.entity_kind = 'track' AND egt.entity_id = t.id
UNION ALL
SELECT t.release_id, tg.genre_id, 1.0 AS weight
FROM furumusic__track t
JOIN furumusic__track_genre tg ON tg.track_id = t.id
),
candidate_release_tags AS (
SELECT release_id, genre_id, max(weight) AS weight
FROM candidate_release_tag_sources
GROUP BY release_id, genre_id
),
release_scores AS (
SELECT crt.release_id, sum(st.seed_weight * crt.weight) AS tag_score
FROM candidate_release_tags crt
JOIN seed_tags st ON st.genre_id = crt.genre_id
GROUP BY crt.release_id
),
candidate_tracks AS (
SELECT t.id,
t.release_id,
COALESCE(score.tag_score, 0.0) AS tag_score,
EXISTS (
SELECT 1 FROM furumusic__user_liked_track ult
WHERE ult.user_id = $2 AND ult.track_id = t.id
) AS liked,
EXISTS (
SELECT 1
FROM furumusic__release_artist ra
JOIN seed_artists sa ON sa.artist_id = ra.artist_id
WHERE ra.release_id = t.release_id
) AS same_artist,
COALESCE(t.lastfm_rating, 0.0) AS rating,
COALESCE(t.lastfm_playcount, 0)::double precision AS playcount,
COALESCE(t.lastfm_listeners, 0)::double precision AS listeners
FROM furumusic__track t
JOIN furumusic__release r ON r.id = t.release_id
LEFT JOIN release_scores score ON score.release_id = t.release_id
WHERE t.is_hidden = false
AND r.is_hidden = false
AND t.release_id <> $1
AND NOT (t.id = ANY($3::bigint[]))
AND (
COALESCE(score.tag_score, 0.0) > 0.0
OR EXISTS (
SELECT 1
FROM furumusic__release_artist ra
JOIN seed_artists sa ON sa.artist_id = ra.artist_id
WHERE ra.release_id = t.release_id
)
OR EXISTS (
SELECT 1 FROM furumusic__user_liked_track ult
WHERE ult.user_id = $2 AND ult.track_id = t.id
)
)
),
ranked_tracks AS (
SELECT *,
row_number() OVER (
PARTITION BY release_id
ORDER BY rating DESC, playcount DESC, listeners DESC, random() DESC, id
) AS release_rank
FROM candidate_tracks
)
SELECT id
FROM ranked_tracks
WHERE release_rank <= 4
ORDER BY (
tag_score * 12.0
+ CASE
WHEN liked AND tag_score > 0.0 THEN 11.0
WHEN liked THEN 3.0
ELSE 0.0
END
+ CASE WHEN same_artist THEN 3.5 ELSE 0.0 END
+ rating * 0.65
+ ln(playcount + 1.0) * 0.04
+ ln(listeners + 1.0) * 0.03
+ random() * 1.6
) DESC, id
LIMIT $4"#,
)
.bind(release_id)
.bind(user_id)
.bind(excluded_ids)
.bind(limit)
.fetch_all(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))
}
async fn build_track_radio_ids(
pool: &sqlx::PgPool,
user_id: i64,
track_id: i64,
) -> cot::Result<Option<Vec<i64>>> {
let seed_track = sqlx::query_scalar::<_, i64>(
r#"SELECT t.id
FROM furumusic__track t
JOIN furumusic__release r ON r.id = t.release_id
WHERE t.id = $1 AND t.is_hidden = false AND r.is_hidden = false"#,
)
.bind(track_id)
.fetch_optional(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
if seed_track.is_none() {
return Ok(None);
}
let mut ids = vec![track_id];
let candidate_ids =
track_radio_candidate_ids(pool, user_id, track_id, PLAYER_RADIO_CANDIDATE_LIMIT).await?;
append_unique_track_ids(&mut ids, candidate_ids, PLAYER_RADIO_TRACK_LIMIT);
let artist_ids = track_primary_artist_ids(pool, track_id).await?;
let remaining = PLAYER_RADIO_TRACK_LIMIT.saturating_sub(ids.len()) as i64;
let fallback_ids =
fallback_radio_track_ids(pool, user_id, &artist_ids, &ids, remaining).await?;
append_unique_track_ids(&mut ids, fallback_ids, PLAYER_RADIO_TRACK_LIMIT);
Ok(Some(ids))
}
async fn build_release_radio_ids(
pool: &sqlx::PgPool,
user_id: i64,
release_id: i64,
) -> cot::Result<Option<Vec<i64>>> {
let seed_release = sqlx::query_scalar::<_, i64>(
r#"SELECT id FROM furumusic__release WHERE id = $1 AND is_hidden = false"#,
)
.bind(release_id)
.fetch_optional(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
if seed_release.is_none() {
return Ok(None);
}
let mut ids = sqlx::query_scalar::<_, i64>(
r#"SELECT t.id
FROM furumusic__track t
JOIN furumusic__release r ON r.id = t.release_id
WHERE t.release_id = $1
AND t.is_hidden = false
AND r.is_hidden = false
ORDER BY COALESCE(t.lastfm_rating, 0.0) DESC,
COALESCE(t.lastfm_playcount, 0) DESC,
COALESCE(t.lastfm_listeners, 0) DESC,
t.disc_number NULLS FIRST,
t.track_number NULLS LAST,
t.id
LIMIT $2"#,
)
.bind(release_id)
.bind(PLAYER_RADIO_RELEASE_SEED_TRACKS)
.fetch_all(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
let candidate_ids = release_radio_candidate_ids(
pool,
user_id,
release_id,
&ids,
PLAYER_RADIO_CANDIDATE_LIMIT,
)
.await?;
append_unique_track_ids(&mut ids, candidate_ids, PLAYER_RADIO_TRACK_LIMIT);
let artist_ids = release_primary_artist_ids(pool, release_id).await?;
let remaining = PLAYER_RADIO_TRACK_LIMIT.saturating_sub(ids.len()) as i64;
let fallback_ids =
fallback_radio_track_ids(pool, user_id, &artist_ids, &ids, remaining).await?;
append_unique_track_ids(&mut ids, fallback_ids, PLAYER_RADIO_TRACK_LIMIT);
Ok(Some(ids))
}
async fn radio_handler(
auth_ctx: auth::AuthContext,
session: Session,
db: Database,
pool: &sqlx::PgPool,
path: Path<PathRadioSeed>,
) -> cot::Result<cot::response::Response> {
let Some(user) = auth::get_request_user(&auth_ctx, &session, &db).await else {
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
};
let seed = path.0;
let ids = match seed.kind.as_str() {
"track" => build_track_radio_ids(pool, user.id, seed.id).await?,
"release" => build_release_radio_ids(pool, user.id, seed.id).await?,
_ => return Ok(json_error(StatusCode::BAD_REQUEST, "unknown radio seed")),
};
let Some(ids) = ids else {
return Ok(json_error(StatusCode::NOT_FOUND, "radio seed not found"));
};
let tracks = load_track_items_by_ids(pool, &ids).await?;
Json(tracks).into_response()
}
// ---------------------------------------------------------------------------
// POST /api/player/tracks-by-ids
// ---------------------------------------------------------------------------
@@ -9772,6 +9370,7 @@ impl App for PlayerApp {
pg_pool,
&path.0.id,
json.0.selected_files,
json.0.target_playlist_id,
live_config.agent_inbox_dir,
user.id,
proxy_url.as_deref(),
@@ -9979,35 +9578,6 @@ impl App for PlayerApp {
},
"player_release_detail",
),
Route::with_handler_and_name(
"/radio/{kind}/{id}",
{
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
get(
move |auth_ctx: auth::AuthContext,
session: Session,
db: Database,
path: Path<PathRadioSeed>| {
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("player pool")
})
.await;
radio_handler(auth_ctx, session, db, pg_pool, path).await
}
},
)
},
"player_radio",
),
// -- Playlists (list + create) --
Route::with_handler_and_name(
"/playlists",
@@ -10058,14 +9628,14 @@ impl App for PlayerApp {
),
// -- Shared playlist snapshots --
Route::with_handler_and_name(
"/share-playlist",
"/shares",
post({
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
move |auth_ctx: auth::AuthContext,
session: Session,
db: Database,
json: Json<CreatePlaylistShareRequest>| {
json: Json<CreateShareRequest>| {
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
async move {
@@ -10078,15 +9648,15 @@ impl App for PlayerApp {
.expect("player pool")
})
.await;
create_playlist_share_handler(auth_ctx, session, db, pg_pool, json)
create_share_handler(auth_ctx, session, db, pg_pool, json)
.await
}
}
}),
"player_share_playlist",
"player_create_share",
),
Route::with_handler_and_name(
"/share-playlist/{id}",
"/shares/{id}",
get({
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
@@ -10106,12 +9676,12 @@ impl App for PlayerApp {
.expect("player pool")
})
.await;
playlist_share_detail_handler(auth_ctx, session, db, pg_pool, path)
sharing::detail_handler(auth_ctx, session, db, pg_pool, path)
.await
}
}
}),
"player_share_playlist_detail",
"player_share_detail",
),
// -- Playlist detail (get, update, delete) --
Route::with_handler_and_name(
@@ -10409,6 +9979,42 @@ impl App for PlayerApp {
}),
"player_follow_toggle",
),
Route::with_handler_and_name(
"/shares/{token}/{action}/{track_id}", get({
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
move |db: Database, path: Path<sharing::MediaPath>, request: cot::request::Request| {
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("player pool")
}).await;
let (live_config, _) = AppConfig::load_with_db(&db).await;
sharing::media_handler(pg_pool, &live_config, &request, path).await
}
}
}), "player_shared_media",
),
Route::with_handler_and_name(
"/download/{track_id}", get({
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
move |db: Database, auth_ctx: auth::AuthContext, session: Session, path: Path<PathTrackId>, request: cot::request::Request| {
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("player pool")
}).await;
let (live_config, _) = AppConfig::load_with_db(&db).await;
sharing::download_handler(auth_ctx, session, db, pg_pool, &live_config, &request, path).await
}
}
}), "player_download",
),
// -- Audio stream --
Route::with_handler_and_name(
"/stream/{track_id}",
+1 -7
View File
@@ -54,7 +54,7 @@ pub(super) struct ReorderPlaylistRequest {
}
#[derive(Debug, Deserialize)]
pub(super) struct CreatePlaylistShareRequest {
pub(super) struct CreateShareRequest {
pub(super) track_ids: Vec<i64>,
pub(super) title: Option<String>,
}
@@ -76,12 +76,6 @@ pub(super) struct PathStringId {
pub(super) id: String,
}
#[derive(Debug, Deserialize)]
pub(super) struct PathRadioSeed {
pub(super) kind: String,
pub(super) id: i64,
}
#[derive(Debug, Deserialize)]
pub(super) struct SearchQuery {
pub(super) q: String,
+1 -1
View File
@@ -54,8 +54,8 @@ pub(super) struct ReleaseArtistRefRow {
#[derive(sqlx::FromRow)]
pub(super) struct MediaFileRow {
pub(super) file_path: String,
pub(super) original_filename: String,
pub(super) mime_type: String,
pub(super) file_size_bytes: i64,
pub(super) sha256_hash: String,
pub(super) created_at: String,
}
+125
View File
@@ -0,0 +1,125 @@
//! Public capabilities grant access only to a stored snapshot's visible tracks.
use super::*;
#[derive(Deserialize)]
pub(super) struct MediaPath {
token: String,
action: String,
track_id: i64,
}
async fn load_share(pool: &sqlx::PgPool, token: &str) -> cot::Result<Option<ShareDetail>> {
if !crate::is_share_token(token) {
return Ok(None);
}
let row: Option<(String, String)> =
sqlx::query_as("SELECT title, track_ids_json FROM furumusic__share_link WHERE token = $1")
.bind(token)
.fetch_optional(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
let Some((title, json)) = row else {
return Ok(None);
};
let ids: Vec<i64> =
serde_json::from_str(&json).map_err(|e| cot::Error::internal(e.to_string()))?;
let tracks = load_track_items_by_ids(pool, &ids).await?;
Ok(Some(ShareDetail {
token: token.to_owned(),
title,
tracks,
}))
}
pub(super) async fn detail_handler(
auth_ctx: auth::AuthContext,
session: Session,
db: Database,
pool: &sqlx::PgPool,
path: Path<PathStringId>,
) -> cot::Result<cot::response::Response> {
let Some(mut share) = load_share(pool, &path.0.id).await? else {
return Ok(json_error(StatusCode::NOT_FOUND, "shared music not found"));
};
if auth::get_request_user(&auth_ctx, &session, &db)
.await
.is_none()
{
for track in &mut share.tracks {
track.stream_url = format!("/api/player/shares/{}/stream/{}", share.token, track.id);
if track.cover_url.is_some() {
track.cover_url = Some(format!(
"/api/player/shares/{}/cover/{}",
share.token, track.id
));
}
}
}
let mut response = Json(share).into_response()?;
response
.headers_mut()
.insert("Cache-Control", "private, no-store".parse().unwrap());
Ok(response)
}
pub(super) async fn media_handler(
pool: &sqlx::PgPool,
config: &AppConfig,
request: &cot::http::Request<Body>,
path: Path<MediaPath>,
) -> cot::Result<cot::response::Response> {
let p = path.0;
if !crate::is_share_token(&p.token) {
return Ok(json_error(StatusCode::NOT_FOUND, "shared music not found"));
}
// Media range requests need only a membership check, not the metadata and
// artist lists of every track in a potentially large shared queue.
let allowed: bool = sqlx::query_scalar(
"SELECT EXISTS (SELECT 1 FROM furumusic__share_link s
JOIN furumusic__track t ON t.id = $2
JOIN furumusic__release r ON r.id = t.release_id
WHERE s.token = $1 AND s.track_ids_json::jsonb @> jsonb_build_array($2::bigint)
AND t.is_hidden = false AND r.is_hidden = false)",
)
.bind(&p.token)
.bind(p.track_id)
.fetch_one(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
if !allowed {
return Ok(json_error(StatusCode::NOT_FOUND, "shared track not found"));
}
match p.action.as_str() {
"stream" | "download" => {
audio_response(pool, config, request, p.track_id, p.action == "download").await
}
"cover" => {
let cover: Option<i64> = sqlx::query_scalar(
"SELECT COALESCE(t.cover_file_id, r.cover_file_id) FROM furumusic__track t JOIN furumusic__release r ON r.id = t.release_id WHERE t.id = $1")
.bind(p.track_id).fetch_one(pool).await.map_err(|e| cot::Error::internal(e.to_string()))?;
match cover {
Some(id) => cover_file_response(pool, config, id, Some("card")).await,
None => Ok(json_error(StatusCode::NOT_FOUND, "cover not found")),
}
}
_ => Ok(json_error(StatusCode::NOT_FOUND, "not found")),
}
}
pub(super) async fn download_handler(
auth_ctx: auth::AuthContext,
session: Session,
db: Database,
pool: &sqlx::PgPool,
config: &AppConfig,
request: &cot::http::Request<Body>,
path: Path<PathTrackId>,
) -> cot::Result<cot::response::Response> {
if auth::get_request_user(&auth_ctx, &session, &db)
.await
.is_none()
{
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
}
audio_response(pool, config, request, path.0.track_id, true).await
}
+9 -82
View File
@@ -80,19 +80,8 @@ impl ScheduledJob {
cron_expression: &str,
) -> cot::db::Result<Self> {
if let Some(mut existing) = Self::get_by_name(db, name).await? {
// Update cron expression and description if they changed
// The registered schedule is a default for new jobs; retain admin overrides.
let mut changed = false;
if existing.cron_expression.as_str() != cron_expression {
tracing::info!(
job = name,
old = existing.cron_expression.as_str(),
new = cron_expression,
"Updating cron expression"
);
existing.cron_expression = LimitedString::new(cron_expression).unwrap();
existing.next_run_at = compute_next_run(cron_expression);
changed = true;
}
if existing.description != description {
existing.description = description.to_owned();
changed = true;
@@ -131,10 +120,6 @@ impl ScheduledJob {
&self.cron_expression
}
pub fn enabled(&self) -> bool {
self.enabled
}
pub fn last_run_at_str(&self) -> &str {
self.last_run_at.as_deref().unwrap_or("")
}
@@ -683,69 +668,6 @@ impl ProcessingStats {
.await?;
Ok(all.into_iter().next())
}
pub async fn list_by_review_ids(
pool: &sqlx::PgPool,
ids: &[i64],
) -> anyhow::Result<HashMap<i64, ProcessingStatsRow>> {
if ids.is_empty() {
return Ok(HashMap::new());
}
// Build comma-separated ID list
let id_list: String = ids
.iter()
.map(|id| id.to_string())
.collect::<Vec<_>>()
.join(",");
let query = format!(
"SELECT pending_review_id, model_name, llm_duration_ms, prompt_tokens, completion_tokens \
FROM furumusic__processing_stats WHERE pending_review_id IN ({id_list})"
);
let rows = sqlx::query_as::<_, ProcessingStatsRow>(&query)
.fetch_all(pool)
.await?;
let map = rows.into_iter().map(|r| (r.pending_review_id, r)).collect();
Ok(map)
}
pub fn model_name_str(&self) -> &str {
&self.model_name
}
pub fn duration_display(&self) -> String {
if self.llm_duration_ms >= 1000 {
format!("{:.1}s", self.llm_duration_ms as f64 / 1000.0)
} else {
format!("{}ms", self.llm_duration_ms)
}
}
pub fn tokens_display(&self) -> String {
format!("{}/{}", self.prompt_tokens, self.completion_tokens)
}
}
#[derive(Debug, Clone, sqlx::FromRow)]
pub struct ProcessingStatsRow {
pub pending_review_id: i64,
pub model_name: String,
pub llm_duration_ms: i64,
pub prompt_tokens: i64,
pub completion_tokens: i64,
}
impl ProcessingStatsRow {
pub fn duration_display(&self) -> String {
if self.llm_duration_ms >= 1000 {
format!("{:.1}s", self.llm_duration_ms as f64 / 1000.0)
} else {
format!("{}ms", self.llm_duration_ms)
}
}
pub fn tokens_display(&self) -> String {
format!("{}/{}", self.prompt_tokens, self.completion_tokens)
}
}
// ---------------------------------------------------------------------------
@@ -1288,8 +1210,13 @@ impl SchedulerHandle {
}
}
// Add new cron job
self.add_cron_job(job_name, new_cron).await?;
// Editing a disabled job must not start it.
let job = ScheduledJob::get_by_name(&self.shared_db, job_name)
.await?
.ok_or_else(|| anyhow::anyhow!("job not found: {job_name}"))?;
if job.enabled {
self.add_cron_job(job_name, new_cron).await?;
}
// Update DB
if let Ok(Some(mut sched_job)) = ScheduledJob::get_by_name(&self.shared_db, job_name).await
@@ -1297,7 +1224,7 @@ impl SchedulerHandle {
sched_job.cron_expression = LimitedString::new(new_cron).unwrap();
sched_job.next_run_at = compute_next_run(new_cron);
sched_job.updated_at = now_iso();
let _ = sched_job.save(&self.shared_db).await;
sched_job.save(&self.shared_db).await?;
}
Ok(())
+178 -4
View File
@@ -58,6 +58,7 @@ pub struct TorrentJobDto {
pub created_at: Option<String>,
pub updated_at: Option<String>,
pub completed_at: Option<String>,
pub target_playlist_id: Option<i64>,
}
#[derive(Debug, Clone, Serialize)]
@@ -93,6 +94,7 @@ pub struct TorrentPreviewRequest {
#[derive(Debug, Deserialize)]
pub struct TorrentStartRequest {
pub target_playlist_id: Option<i64>,
pub selected_files: Vec<usize>,
}
@@ -153,6 +155,7 @@ struct TorrentJob {
created_at: String,
updated_at: String,
completed_at: Option<String>,
target_playlist_id: Option<i64>,
}
#[derive(Debug, FromRow)]
@@ -176,6 +179,7 @@ struct TorrentSessionRow {
created_at: String,
updated_at: String,
completed_at: Option<String>,
target_playlist_id: Option<i64>,
}
impl TorrentSessionRow {
@@ -226,6 +230,7 @@ impl TorrentSessionRow {
let peer_stats = live.map(|l| &l.snapshot.peer_stats);
TorrentJobDto {
target_playlist_id: self.target_playlist_id,
id: self.id.clone(),
name: self.name.clone(),
info_hash: self.info_hash.clone(),
@@ -275,6 +280,7 @@ impl TorrentSessionRow {
status: TorrentJobStatus::from_str(&self.status),
output_dir: temp_root.join(&id).join("download"),
selected_files,
target_playlist_id: self.target_playlist_id,
handle: None,
downloaded_bytes: i64_to_u64(self.downloaded_bytes),
uploaded_bytes: i64_to_u64(self.uploaded_bytes),
@@ -341,6 +347,7 @@ impl TorrentJob {
let peer_stats = live.map(|l| &l.snapshot.peer_stats);
TorrentJobDto {
target_playlist_id: self.target_playlist_id,
id: self.id.clone(),
name: self.name.clone(),
info_hash: self.info_hash.clone(),
@@ -430,7 +437,7 @@ impl TorrentService {
r#"SELECT 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
created_at, updated_at, completed_at, target_playlist_id
FROM furumusic__torrent_session
WHERE user_id = $1
ORDER BY created_at DESC, id DESC
@@ -441,6 +448,7 @@ impl TorrentService {
.fetch_all(pool)
.await?;
crate::import_playlists::reconcile(pool, Some(user_id)).await?;
let handles = {
let jobs = self.jobs.lock().await;
jobs.iter()
@@ -604,6 +612,7 @@ impl TorrentService {
status: TorrentJobStatus::Preview,
output_dir,
selected_files,
target_playlist_id: None,
handle: None,
downloaded_bytes: 0,
uploaded_bytes: 0,
@@ -727,6 +736,7 @@ impl TorrentService {
status: TorrentJobStatus::Preview,
output_dir,
selected_files,
target_playlist_id: None,
handle: None,
downloaded_bytes: 0,
uploaded_bytes: 0,
@@ -794,6 +804,7 @@ impl TorrentService {
pool: &PgPool,
id: &str,
selected_files: Vec<usize>,
target_playlist_id: Option<i64>,
inbox_dir: String,
uploader_user_id: i64,
proxy_url: Option<&str>,
@@ -806,6 +817,8 @@ impl TorrentService {
}
let inbox_dir = validate_inbox_dir(&inbox_dir)?;
crate::import_playlists::validate_target(pool, uploader_user_id, target_playlist_id)
.await?;
self.ensure_memory_job(pool, uploader_user_id, id).await?;
let (torrent_bytes, output_dir, selected_size) = {
@@ -823,7 +836,13 @@ impl TorrentService {
bail!("torrent job is already running");
}
validate_selection(&job.files, &selected_files)?;
if job.status != TorrentJobStatus::Preview
&& job.target_playlist_id != target_playlist_id
{
bail!("playlist destination cannot change after a torrent has started");
}
job.status = TorrentJobStatus::Downloading;
job.target_playlist_id = target_playlist_id;
job.selected_files = selected_files.clone();
job.downloaded_bytes = 0;
job.uploaded_bytes = 0;
@@ -1032,9 +1051,14 @@ impl TorrentService {
inbox_dir: &Path,
uploader_user_id: i64,
) -> anyhow::Result<()> {
let (name, files, selected_files, output_dir) = {
// The playlist may have been deleted while this torrent was downloading.
let persisted_target = load_row(pool, uploader_user_id, id)
.await?
.target_playlist_id;
let (name, files, selected_files, output_dir, target_playlist_id) = {
let mut jobs = self.jobs.lock().await;
let job = jobs.get_mut(id).context("torrent job not found")?;
job.target_playlist_id = persisted_target;
job.refresh_progress();
job.status = TorrentJobStatus::Moving;
job.updated_at = now_string();
@@ -1043,6 +1067,7 @@ impl TorrentService {
job.files.clone(),
job.selected_files.clone(),
job.output_dir.clone(),
job.target_playlist_id,
)
};
@@ -1052,6 +1077,7 @@ impl TorrentService {
let destination_root = inbox_dir
.join("user_uploads")
.join(uploader_user_id.to_string())
.join(format!("torrent-{id}"))
.join(sanitize_path_component(&name));
tokio::fs::create_dir_all(&destination_root).await?;
@@ -1064,6 +1090,22 @@ impl TorrentService {
if let Some(parent) = destination.parent() {
tokio::fs::create_dir_all(parent).await?;
}
if let Some(playlist_id) = target_playlist_id
&& crate::jobs::inbox_discover::is_audio_file(&file.name)
{
let input_path =
crate::media_paths::path_for_root(&inbox_dir.to_string_lossy(), &destination)
.context("torrent destination escaped inbox")?;
let sha = crate::agent::mover::sha256_file(&source).await?;
crate::import_playlists::register(
pool,
uploader_user_id,
playlist_id,
&input_path,
&sha,
)
.await?;
}
move_file(&source, &destination).await?;
}
@@ -1103,7 +1145,7 @@ async fn load_row(pool: &PgPool, user_id: i64, id: &str) -> anyhow::Result<Torre
r#"SELECT 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
created_at, updated_at, completed_at, target_playlist_id
FROM furumusic__torrent_session
WHERE id = $1 AND user_id = $2"#,
)
@@ -1244,13 +1286,15 @@ async fn mark_job_started(
progress_percent = 0,
error = NULL,
updated_at = $4,
completed_at = NULL
completed_at = NULL,
target_playlist_id = $5
WHERE id = $1"#,
)
.bind(id)
.bind(serde_json::to_string(selected_files)?)
.bind(u64_to_i64(dto.selected_size))
.bind(now_string())
.bind(dto.target_playlist_id)
.execute(pool)
.await?;
Ok(())
@@ -1434,3 +1478,133 @@ async fn move_file(source: &Path, destination: &Path) -> anyhow::Result<()> {
Err(err) => Err(err.into()),
}
}
#[cfg(test)]
mod playlist_tests {
use super::*;
#[tokio::test]
#[ignore = "requires disposable PostgreSQL in FURU_IMPORT_TEST_DATABASE_URL"]
async fn torrent_playlist_survives_restore_and_registers_selected_audio() {
let pool = sqlx::postgres::PgPoolOptions::new()
.max_connections(1)
.connect(&std::env::var("FURU_IMPORT_TEST_DATABASE_URL").unwrap())
.await
.unwrap();
sqlx::raw_sql(r#"
CREATE TEMP TABLE furumusic__playlist(id bigint PRIMARY KEY,owner_id bigint);
INSERT INTO furumusic__playlist VALUES (10,1);
CREATE TEMP TABLE furumusic__import_playlist_target(user_id bigint,playlist_id bigint,input_path text,source_sha256 text,media_file_id bigint,fulfilled_at text,PRIMARY KEY(user_id,input_path));
CREATE TEMP TABLE furumusic__torrent_session(
id text PRIMARY KEY,user_id bigint,name text,info_hash text,source_kind text,source_label text,torrent_bytes bytea,
files_json text,selected_files_json text,status text,total_size bigint DEFAULT 0,selected_size bigint DEFAULT 0,
downloaded_bytes bigint DEFAULT 0,uploaded_bytes bigint DEFAULT 0,progress_percent float8 DEFAULT 0,
error text,created_at text,updated_at text,completed_at text,target_playlist_id bigint);
"#).execute(&pool).await.unwrap();
let root = std::env::temp_dir().join(format!("furumi-torrent-test-{}", Uuid::new_v4()));
let mut service = TorrentService::new(Arc::new(OnceCell::new()));
service.temp_root = root.join("torrents");
let output = service.temp_root.join("job/download");
tokio::fs::create_dir_all(&output).await.unwrap();
let files: Vec<_> = ["a.flac", "b.mp3", "cover.jpg"]
.iter()
.enumerate()
.map(|(index, name)| TorrentFileDto {
index,
name: name.to_string(),
components: vec![name.to_string()],
length: 3,
selected: index != 1,
})
.collect();
for file in &files {
tokio::fs::write(output.join(&file.name), b"abc")
.await
.unwrap();
}
let mut job = TorrentJob {
id: "job".into(),
user_id: 1,
name: "Soundtrack".into(),
info_hash: "hash".into(),
source_kind: "torrent_file".into(),
source_label: None,
torrent_bytes: vec![],
files,
selected_files: vec![0, 2],
target_playlist_id: None,
output_dir: output,
status: TorrentJobStatus::Preview,
handle: None,
downloaded_bytes: 0,
uploaded_bytes: 0,
progress_percent: 0.0,
error: None,
created_at: now_string(),
updated_at: now_string(),
completed_at: None,
};
sqlx::query("INSERT INTO furumusic__torrent_session (id,user_id,name,info_hash,source_kind,torrent_bytes,files_json,selected_files_json,status,created_at,updated_at) VALUES ('job',1,'Soundtrack','hash','torrent_file',$1,$2,'[0,2]','resolving',$3,$3)")
.bind(Vec::<u8>::new()).bind(serde_json::to_string(&job.files).unwrap()).bind(now_string()).execute(&pool).await.unwrap();
update_resolved_job(&pool, &job).await.unwrap();
job.target_playlist_id = Some(10);
mark_job_started(&pool, "job", &[0, 2], &job.dto())
.await
.unwrap();
let restored = load_row(&pool, 1, "job")
.await
.unwrap()
.into_job(&service.temp_root)
.unwrap();
assert_eq!(restored.target_playlist_id, Some(10));
assert_eq!(restored.dto().target_playlist_id, Some(10));
service.jobs.lock().await.insert("job".into(), restored);
let inbox = root.join("inbox");
service
.finalize_completed(&pool, "job", &inbox, 1)
.await
.unwrap();
let paths: Vec<String> =
sqlx::query_scalar("SELECT input_path FROM furumusic__import_playlist_target")
.fetch_all(&pool)
.await
.unwrap();
assert_eq!(paths, vec!["user_uploads/1/torrent-job/Soundtrack/a.flac"]);
assert!(inbox.join(&paths[0]).exists());
assert!(
!inbox
.join("user_uploads/1/torrent-job/Soundtrack/b.mp3")
.exists()
);
assert_eq!(load_row(&pool, 1, "job").await.unwrap().status, "complete");
// Deleting the destination while downloading clears its persisted FK;
// an older in-memory choice must not prevent the audio from being imported.
sqlx::query("UPDATE furumusic__torrent_session SET target_playlist_id=NULL WHERE id='job'")
.execute(&pool)
.await
.unwrap();
sqlx::query("DELETE FROM furumusic__playlist WHERE id=10")
.execute(&pool)
.await
.unwrap();
let source = service.temp_root.join("job/download");
tokio::fs::create_dir_all(&source).await.unwrap();
tokio::fs::write(source.join("a.flac"), b"abc")
.await
.unwrap();
service
.finalize_completed(&pool, "job", &inbox, 1)
.await
.unwrap();
assert_eq!(
service
.memory_job_dto("job")
.await
.unwrap()
.target_playlist_id,
None
);
tokio::fs::remove_dir_all(root).await.unwrap();
pool.close().await;
}
}
+80 -28
View File
@@ -19,6 +19,10 @@ pub struct User {
avatar_url: Option<String>,
role: LimitedString<32>,
is_active: bool,
local_role: Option<String>,
sso_role: Option<String>,
approved_by: Option<i64>,
approved_at: Option<String>,
}
// ---------------------------------------------------------------------------
@@ -26,11 +30,6 @@ pub struct User {
// ---------------------------------------------------------------------------
impl User {
/// List all users.
pub async fn list_all(db: &Database) -> cot::db::Result<Vec<Self>> {
Self::objects().all(db).await
}
/// Get a user by primary key.
pub async fn get_by_id(db: &Database, user_id: i64) -> cot::db::Result<Option<Self>> {
Self::get_by_primary_key(db, Auto::Fixed(user_id)).await
@@ -55,6 +54,10 @@ impl User {
avatar_url: None,
role: LimitedString::new(role).unwrap(),
is_active: true,
local_role: Some(role.to_owned()),
sso_role: None,
approved_by: None,
approved_at: None,
};
user.insert(db).await?;
Ok(user)
@@ -77,8 +80,13 @@ impl User {
if let Some(pw) = new_password {
self.password = Some(PasswordHash::from_password(&Password::new(pw)).into_string());
}
self.role = LimitedString::new(role).unwrap();
self.save(db).await
let local_role = (!role.is_empty()).then(|| role.to_owned());
db.raw_with("UPDATE furumusic__user SET username = $1, email = $2, display_name = $3, password = $4, local_role = $5, role = COALESCE(sso_role, $5, 'user'), is_active = (sso_role IS NOT NULL OR $5 IS NOT NULL) WHERE id = $6",
&[&username.to_owned(), &self.email, &self.display_name, &self.password, &local_role, &self.id_val()]).await?;
if let Some(updated) = Self::get_by_id(db, self.id_val()).await? {
*self = updated;
}
Ok(())
}
/// Look up a user by username.
@@ -121,32 +129,27 @@ impl User {
pub fn username_str(&self) -> &str {
&self.username
}
pub fn email_str(&self) -> String {
self.email
.as_ref()
.map(|e| e.to_string())
.unwrap_or_default()
}
pub fn display_name_str(&self) -> String {
self.display_name
.as_ref()
.map(|d| d.to_string())
.unwrap_or_default()
}
pub fn role_str(&self) -> &str {
&self.role
}
pub fn is_active(&self) -> bool {
self.is_active
}
pub fn has_sso_admin_role(&self) -> bool {
self.sso_role.as_deref() == Some("admin")
}
/// Create a user without a password (for OIDC-only accounts).
pub async fn create_oidc(
db: &Database,
username: &str,
email: Option<&str>,
display_name: Option<&str>,
role: &str,
sso_role: Option<&str>,
) -> cot::db::Result<Self> {
let mut user = Self {
id: Auto::auto(),
@@ -155,24 +158,44 @@ impl User {
email: email.map(str::to_owned),
display_name: display_name.map(str::to_owned),
avatar_url: None,
role: LimitedString::new(role).unwrap(),
is_active: true,
role: LimitedString::new(sso_role.unwrap_or("user")).unwrap(),
is_active: sso_role.is_some(),
local_role: None,
sso_role: sso_role.map(str::to_owned),
approved_by: None,
approved_at: None,
};
user.insert(db).await?;
Ok(user)
}
/// Update the user's role and persist the change.
pub async fn update_role(&mut self, db: &Database, role: &str) -> cot::db::Result<()> {
self.role = LimitedString::new(role).unwrap();
self.save(db).await
pub async fn sync_sso_role(
&mut self,
db: &Database,
role: Option<&str>,
) -> cot::db::Result<()> {
let role = role.map(str::to_owned);
// Change just this grant atomically: a concurrent administrator approval
// must not be overwritten by a stale User loaded before the OIDC callback.
db.raw_with("UPDATE furumusic__user SET sso_role = $1, role = COALESCE($1, local_role, 'user'), is_active = ($1 IS NOT NULL OR local_role IS NOT NULL) WHERE id = $2", &[&role, &self.id_val()]).await?;
if let Some(updated) = Self::get_by_id(db, self.id_val()).await? {
*self = updated;
}
Ok(())
}
/// Find a user by email address.
pub async fn get_by_email(db: &Database, email: &str) -> cot::db::Result<Option<Self>> {
cot::db::query!(User, $email == Some(email.to_owned()))
.get(db)
.await
pub async fn approve(
&mut self,
db: &Database,
role: &str,
admin_id: i64,
) -> cot::db::Result<()> {
db.raw_with("UPDATE furumusic__user SET local_role = $1, role = COALESCE(sso_role, $1), is_active = true, approved_by = $2, approved_at = $3 WHERE id = $4",
&[&role.to_owned(), &admin_id, &chrono::Utc::now().to_rfc3339(), &self.id_val()]).await?;
if let Some(updated) = Self::get_by_id(db, self.id_val()).await? {
*self = updated;
}
Ok(())
}
}
@@ -407,9 +430,38 @@ pub mod db_migrations {
&[Operation::custom(create_oidc_link_indexes).build()];
}
#[cot::db::migrations::migration_op]
async fn add_local_approval(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
ctx.db.raw("ALTER TABLE furumusic__user ADD COLUMN local_role text, ADD COLUMN sso_role text, ADD COLUMN approved_by bigint, ADD COLUMN approved_at text").await?;
// Existing password accounts retain local access. OIDC-only accounts retain
// their last SSO role until the next verified login refreshes group membership.
ctx.db.raw("UPDATE furumusic__user SET local_role = CASE WHEN password IS NOT NULL AND is_active THEN role ELSE NULL END, sso_role = CASE WHEN password IS NULL AND is_active THEN role ELSE NULL END").await?;
ctx.db
.raw("DROP TABLE furumusic__playlist_share_link")
.await?;
ctx.db.raw("CREATE TABLE furumusic__share_link (token text PRIMARY KEY, creator_user_id bigint NOT NULL, title text NOT NULL, track_ids_json text NOT NULL, created_at text NOT NULL)").await?;
Ok(())
}
#[derive(Debug, Copy, Clone)]
pub struct M0053LocalApprovalAndPublicShares;
impl migrations::Migration for M0053LocalApprovalAndPublicShares {
const APP_NAME: &'static str = "furumusic";
const MIGRATION_NAME: &'static str = "m_0053_local_approval_and_public_shares";
const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
migrations::MigrationDependency::migration("furumusic", "m_0005_oidc_link_indexes"),
migrations::MigrationDependency::migration(
"furumusic",
"m_0037_create_playlist_share_links",
),
];
const OPERATIONS: &'static [Operation] = &[Operation::custom(add_local_approval).build()];
}
pub const MIGRATIONS: &[&SyncDynMigration] = &[
&M0003CreateUser,
&M0004CreateOidcLink,
&M0005OidcLinkIndexes,
&M0053LocalApprovalAndPublicShares,
];
}
+6 -82
View File
@@ -2089,91 +2089,15 @@ async fn sync_target_playlist_tracks_for_user(pool: &PgPool, user_id: i64) -> an
.await?;
for (playlist_id, owner_id, track_id, _, _) in candidates {
append_track_to_target_playlist(pool, owner_id, playlist_id, track_id).await?;
}
Ok(())
}
async fn append_track_to_target_playlist(
pool: &PgPool,
user_id: i64,
playlist_id: i64,
track_id: i64,
) -> anyhow::Result<bool> {
let mut transaction = pool.begin().await?;
let playlist: Option<i64> = sqlx::query_scalar(
r#"SELECT id FROM furumusic__playlist
WHERE id = $1 AND owner_id = $2
FOR UPDATE"#,
)
.bind(playlist_id)
.bind(user_id)
.fetch_optional(&mut *transaction)
.await?;
if playlist.is_none() {
transaction.rollback().await?;
return Ok(false);
}
let already_present: bool = sqlx::query_scalar(
r#"SELECT EXISTS (
SELECT 1 FROM furumusic__playlist_track
WHERE playlist_id = $1 AND track_id = $2
)"#,
)
.bind(playlist_id)
.bind(track_id)
.fetch_one(&mut *transaction)
.await?;
if already_present {
transaction.commit().await?;
return Ok(false);
}
let position: i64 = sqlx::query_scalar(
r#"SELECT COALESCE(MAX(position), -1)::bigint + 1
FROM furumusic__playlist_track WHERE playlist_id = $1"#,
)
.bind(playlist_id)
.fetch_one(&mut *transaction)
.await?;
let position = i32::try_from(position).context("target playlist has too many tracks")?;
let now = now_string();
sqlx::query(
r#"INSERT INTO furumusic__playlist_track
(playlist_id, track_id, position, added_at, added_by_user_id)
VALUES ($1, $2, $3, $4, $5)"#,
)
.bind(playlist_id)
.bind(track_id)
.bind(position)
.bind(&now)
.bind(user_id)
.execute(&mut *transaction)
.await?;
sqlx::query("UPDATE furumusic__playlist SET updated_at = $1 WHERE id = $2")
.bind(&now)
.bind(playlist_id)
.execute(&mut *transaction)
.await?;
transaction.commit().await?;
if let Err(error) = crate::federation::devices::record_playlist_tracks_added(
pool,
user_id,
playlist_id,
&[track_id],
)
.await
{
tracing::warn!(
crate::import_playlists::append_track_to_target_playlist(
pool,
owner_id,
playlist_id,
track_id,
%error,
"federation operation for an automatic YouTube playlist addition was not recorded"
);
)
.await?;
}
Ok(true)
Ok(())
}
async fn refresh_parent(pool: &PgPool, job_id: &str) -> anyhow::Result<()> {
-133
View File
@@ -1,133 +0,0 @@
{% extends "admin/layout.html" %}
{% block admin_title %}{% if is_edit %}{{ t.artists_edit_heading }}{% else %}{{ t.artists_new_heading }}{% endif %}{% endblock admin_title %}
{% block content %}
<h1>{% if is_edit %}{{ t.artists_edit_heading }}{% else %}{{ t.artists_new_heading }}{% endif %}</h1>
<form method="post" action="{% if is_edit %}/admin/artists/{{ form_artist_id }}/edit{% else %}/admin/artists/new{% endif %}">
<table>
<tr>
<td><label for="name">{{ t.artists_name }}</label></td>
<td><input name="name" id="name" value="{{ form_name }}" required style="width:100%"></td>
</tr>
</table>
<button type="submit" style="margin-top: 1rem; padding: .5rem 1.5rem;">{{ t.settings_save }}</button>
</form>
{% if is_edit %}
<hr style="margin: 2rem 0;">
<h2>{{ t.artists_image }}</h2>
<div id="artist-image-section" style="margin-top: 1rem;">
<!-- Current image -->
<div style="margin-bottom: 1.5rem;">
{% match current_image_url %}
{% when Some with (url) %}
<img id="current-image" src="{{ url }}" alt="" style="max-width: 200px; max-height: 200px; border-radius: 6px; border: 1px solid #ddd;">
<br>
<button type="button" onclick="removeImage()" style="margin-top: .5rem; padding: .3rem 1rem; cursor: pointer;">{{ t.artists_remove_image }}</button>
{% when None %}
<p style="color: #888;">{{ t.artists_no_image }}</p>
{% endmatch %}
</div>
<!-- Upload custom image -->
<div style="margin-bottom: 1.5rem;">
<h3 style="font-size: .95rem; margin-bottom: .5rem;">{{ t.artists_upload_image }}</h3>
<input type="file" id="image-upload" accept="image/*" style="margin-bottom: .5rem;">
<br>
<button type="button" id="upload-btn" onclick="uploadImage()" style="padding: .3rem 1rem; cursor: pointer;" disabled>{{ t.artists_upload }}</button>
</div>
<!-- Pick from album covers -->
<div>
<h3 style="font-size: .95rem; margin-bottom: .5rem;">{{ t.artists_pick_cover }}</h3>
<div id="covers-grid" style="display: flex; flex-wrap: wrap; gap: .75rem;">
<p style="color: #888;" id="covers-loading">...</p>
</div>
</div>
</div>
<script>
const artistId = {{ form_artist_id }};
// Enable upload button when file selected
document.getElementById('image-upload').addEventListener('change', function() {
document.getElementById('upload-btn').disabled = !this.files.length;
});
// Upload custom image
function uploadImage() {
const fileInput = document.getElementById('image-upload');
const file = fileInput.files[0];
if (!file) return;
const reader = new FileReader();
reader.onload = function() {
const base64 = reader.result.split(',')[1];
fetch('/admin/artists/' + artistId + '/upload-image', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
data: base64,
filename: file.name,
mime_type: file.type || 'image/jpeg'
})
}).then(function(r) {
if (r.ok) location.reload();
else r.text().then(function(t) { alert('Error: ' + t); });
});
};
reader.readAsDataURL(file);
}
// Set image from album cover
function setImage(mediaFileId) {
fetch('/admin/artists/' + artistId + '/set-image', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ media_file_id: mediaFileId })
}).then(function(r) {
if (r.ok) location.reload();
else r.text().then(function(t) { alert('Error: ' + t); });
});
}
// Remove image
function removeImage() {
fetch('/admin/artists/' + artistId + '/set-image', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ media_file_id: null })
}).then(function(r) {
if (r.ok) location.reload();
else r.text().then(function(t) { alert('Error: ' + t); });
});
}
// Load available covers
fetch('/admin/artists/' + artistId + '/available-covers')
.then(function(r) { return r.json(); })
.then(function(covers) {
const grid = document.getElementById('covers-grid');
grid.innerHTML = '';
if (!covers.length) {
grid.innerHTML = '<p style="color: #888;">{{ t.artists_no_covers }}</p>';
return;
}
covers.forEach(function(c) {
const div = document.createElement('div');
div.style.cssText = 'cursor:pointer; text-align:center;';
div.title = c.release_title;
div.innerHTML = '<img src="' + c.cover_url + '" alt="" style="width:100px; height:100px; object-fit:cover; border-radius:4px; border:2px solid #ddd;">'
+ '<br><small style="font-size:.75rem; color:#666;">' + c.release_title.substring(0, 20) + '</small>';
div.onclick = function() { setImage(c.media_file_id); };
grid.appendChild(div);
});
})
.catch(function() {
document.getElementById('covers-grid').innerHTML = '<p style="color: #888;">{{ t.artists_no_covers }}</p>';
});
</script>
{% endif %}
{% endblock content %}
-45
View File
@@ -1,45 +0,0 @@
{% extends "admin/layout.html" %}
{% block admin_title %}{{ t.nav_artists }}{% endblock admin_title %}
{% block content %}
<h1>{{ t.artists_heading }}</h1>
<p style="margin-bottom: 1rem;">
<a href="/admin/artists/new" style="display:inline-block; padding:.5rem 1rem; background:#1a1a2e; color:#fff; text-decoration:none; border-radius:4px;">{{ t.artists_add }}</a>
</p>
{% if rows.is_empty() %}
<p>{{ t.artists_empty }}</p>
{% else %}
<table>
<tr>
<th>ID</th>
<th>{{ t.artists_name }}</th>
<th>{{ t.artists_releases }}</th>
<th>{{ t.artists_tracks }}</th>
<th>{{ t.artists_hidden }}</th>
<th>{{ t.artists_actions }}</th>
</tr>
{% for row in rows %}
<tr>
<td>{{ row.artist.id_val() }}</td>
<td>{{ row.artist.name_str() }}</td>
<td>
<a href="/admin/releases?artist_id={{ row.artist.id_val() }}">{{ row.release_count }}</a>
</td>
<td>{{ row.track_count }}</td>
<td>{{ row.artist.is_hidden() }}</td>
<td>
<a href="/admin/artists/{{ row.artist.id_val() }}/edit">{{ t.artists_edit }}</a>
&nbsp;|&nbsp;
<a href="/admin/releases?artist_id={{ row.artist.id_val() }}">{{ t.artists_view_releases }}</a>
&nbsp;|&nbsp;
<form method="post" action="/admin/artists/{{ row.artist.id_val() }}/delete" style="display:inline;" onsubmit="return confirm('{{ t.artists_delete_confirm }}')">
<button type="submit" style="background:none; border:none; color:#c00; cursor:pointer; padding:0; text-decoration:underline;">{{ t.artists_delete }}</button>
</form>
</td>
</tr>
{% endfor %}
</table>
{% endif %}
{% endblock content %}
-82
View File
@@ -1,82 +0,0 @@
{% extends "admin/layout.html" %}
{% block admin_title %}{{ t.nav_debug }}{% endblock admin_title %}
{% block content %}
<style>
.cfg-key { position: relative; display: inline-flex; align-items: center; gap: .35rem; }
.cfg-info-btn {
display: inline-flex; align-items: center; justify-content: center;
width: 16px; height: 16px; border-radius: 50%;
background: #ccc; color: #fff; font-size: 11px; font-weight: 700;
cursor: help; flex-shrink: 0; line-height: 1;
}
.cfg-info-btn:hover { background: #888; }
.cfg-popup {
position: absolute; left: 100%; top: 50%;
transform: translateY(-50%); z-index: 10;
background: #1a1a2e; color: #eee; padding: .55rem .75rem;
border-radius: 6px; box-shadow: 0 4px 16px rgba(0,0,0,.25);
font-size: .8rem; white-space: nowrap; min-width: 220px;
margin-left: 8px;
opacity: 0; visibility: hidden; pointer-events: none;
transition: opacity .15s, visibility 0s .3s;
user-select: text;
}
/* invisible bridge so cursor can travel from icon to popup */
.cfg-popup::before {
content: ''; position: absolute; right: 100%; top: 0; bottom: 0;
width: 12px;
}
.cfg-key:hover .cfg-popup {
opacity: 1; visibility: visible; pointer-events: auto;
transition: opacity .15s, visibility 0s;
}
.cfg-popup dt { color: #999; font-size: .7rem; text-transform: uppercase; letter-spacing: .04em; margin-top: .35rem; }
.cfg-popup dt:first-child { margin-top: 0; }
.cfg-popup dd { margin: .1rem 0 0; }
.cfg-popup code { background: rgba(255,255,255,.12); color: #fff; padding: .05rem .3rem; border-radius: 3px; font-size: .8rem; }
</style>
<h1>{{ t.debug_heading }}</h1>
<h2>{{ t.debug_build_info }}</h2>
<table>
<tr><th>{{ t.debug_field }}</th><th>{{ t.debug_value }}</th></tr>
<tr><td>Package</td><td><code>{{ build.pkg_name }}</code></td></tr>
<tr><td>Version</td><td><code>{{ build.pkg_version }}</code></td></tr>
<tr><td>Profile</td><td><code>{{ build.profile }}</code></td></tr>
<tr><td>Target</td><td><code>{{ build.target }}</code></td></tr>
<tr><td>Rustc</td><td><code>{{ build.rustc_version }}</code></td></tr>
<tr><td>{{ t.debug_db_status }}</td><td><code>{{ db_status }}</code></td></tr>
</table>
<h2>{{ t.debug_app_config }}</h2>
<table>
<tr>
<th>{{ t.debug_field }}</th>
<th>{{ t.debug_value }}</th>
<th>{{ t.debug_source }}</th>
</tr>
{% for entry in config_entries %}
<tr>
<td>
<span class="cfg-key">
<code>{{ entry.key }}</code>
<span class="cfg-info-btn">i</span>
<dl class="cfg-popup">
<dt>env var</dt>
<dd><code>{{ entry.env_var }}</code></dd>
<dt>default</dt>
<dd><code>{% if entry.default_value == "" %}(empty){% else %}{{ entry.default_value }}{% endif %}</code></dd>
<dt>source</dt>
<dd><code>{{ entry.source }}</code></dd>
</dl>
</span>
</td>
<td><code>{{ entry.value }}</code></td>
<td><span class="badge badge-{{ entry.source }}">{{ entry.source }}</span></td>
</tr>
{% endfor %}
</table>
{% endblock content %}
-8
View File
@@ -1,8 +0,0 @@
{% extends "admin/layout.html" %}
{% block admin_title %}{{ t.nav_dashboard }}{% endblock admin_title %}
{% block content %}
<h1>{{ t.admin_heading }}</h1>
<p><a href="/admin/debug">{{ t.admin_debug_link }}</a></p>
{% endblock content %}
-120
View File
@@ -1,120 +0,0 @@
{% extends "admin/layout.html" %}
{% block admin_title %}{{ job.name_str() }}{% endblock admin_title %}
{% block content %}
<h1>{{ job.name_str() }}</h1>
<table>
<tr><th>{{ t.jobs_description }}</th><td>{{ job.description_str() }}</td></tr>
<tr><th>{{ t.jobs_cron }}</th><td><code>{{ job.cron_expression_str() }}</code></td></tr>
<tr><th>{{ t.jobs_enabled }}</th><td>{% if job.enabled() %}&#9989;{% else %}&#10060;{% endif %}</td></tr>
<tr><th>{{ t.jobs_last_run }}</th><td>{{ job.last_run_at_str() }}</td></tr>
<tr><th>{{ t.jobs_next_run }}</th><td>{{ job.next_run_at_str() }}</td></tr>
</table>
<div style="margin: 1rem 0; display: flex; gap: .5rem; align-items: flex-end;">
{% if job.name_str() != "metadata_backfill" && job.name_str() != "lastfm_popularity" %}
<form method="post" action="/admin/jobs/{{ job.name_str() }}/run" style="margin:0;">
<button type="submit" style="padding:.4rem 1rem; background:#007bff; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.jobs_run_now }}</button>
</form>
{% endif %}
{% if job.name_str() != "metadata_backfill" %}
<form method="post" action="/admin/jobs/{{ job.name_str() }}/toggle" style="margin:0;">
{% if job.enabled() %}
<button type="submit" style="padding:.4rem 1rem; background:#dc3545; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.jobs_disable }}</button>
{% else %}
<button type="submit" style="padding:.4rem 1rem; background:#28a745; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.jobs_enable }}</button>
{% endif %}
</form>
{% endif %}
</div>
{% if job.name_str() == "lastfm_popularity" %}
<form method="post" action="/admin/jobs/lastfm_popularity/run-options" style="margin:1rem 0;">
<p>{{ t.jobs_lastfm_light_help }}</p>
<label style="display:block; margin-bottom:1rem;">
<input type="checkbox" name="refresh_existing"> {{ t.jobs_lastfm_full }}
</label>
<button type="submit">{{ t.jobs_run_now }}</button>
</form>
{% endif %}
{% if job.name_str() == "metadata_backfill" %}
<h2>{{ t.jobs_metadata_backfill_options }}</h2>
<form method="post" action="/admin/jobs/metadata_backfill/run-options" style="margin:0 0 1.5rem; padding:1rem; background:#fff; border:1px solid #e0e0e0; border-radius:6px;">
<fieldset style="border:0; margin:0 0 .75rem; padding:0;">
<legend style="font-weight:600; margin-bottom:.5rem;">{{ t.jobs_metadata_backfill_fields }}</legend>
<label style="display:inline-flex; gap:.35rem; align-items:center; margin-right:1rem; margin-bottom:.4rem;">
<input type="checkbox" name="audio_bitrate" checked> audio_bitrate
</label>
<label style="display:inline-flex; gap:.35rem; align-items:center; margin-right:1rem; margin-bottom:.4rem;">
<input type="checkbox" name="audio_sample_rate" checked> audio_sample_rate
</label>
<label style="display:inline-flex; gap:.35rem; align-items:center; margin-right:1rem; margin-bottom:.4rem;">
<input type="checkbox" name="audio_bit_depth" checked> audio_bit_depth
</label>
<label style="display:inline-flex; gap:.35rem; align-items:center; margin-right:1rem; margin-bottom:.4rem;">
<input type="checkbox" name="duration_seconds" checked> duration_seconds
</label>
<label style="display:inline-flex; gap:.35rem; align-items:center; margin-right:1rem; margin-bottom:.4rem;">
<input type="checkbox" name="local_genres" checked> local genres from files
</label>
<label style="display:inline-flex; gap:.35rem; align-items:center; margin-right:1rem; margin-bottom:.4rem;">
<input type="checkbox" name="lastfm_tags" checked> Last.fm tags
</label>
</fieldset>
<div style="display:flex; gap:1rem; align-items:center; margin-bottom:.9rem;">
<label style="display:inline-flex; gap:.35rem; align-items:center;">
<input type="radio" name="mode" value="fill_missing" checked> {{ t.jobs_metadata_backfill_fill_missing }}
</label>
<label style="display:inline-flex; gap:.35rem; align-items:center;">
<input type="radio" name="mode" value="overwrite"> {{ t.jobs_metadata_backfill_overwrite }}
</label>
</div>
<button type="submit" style="padding:.45rem 1rem; background:#007bff; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.jobs_metadata_backfill_run }}</button>
</form>
{% endif %}
{% if job.name_str() != "metadata_backfill" %}
<h2>{{ t.jobs_cron }}</h2>
<p style="font-size:.85rem;color:#666;margin-bottom:.5rem;">{{ t.jobs_cron_help }}</p>
<form method="post" action="/admin/jobs/{{ job.name_str() }}/cron" style="display:flex;gap:.5rem;align-items:center;margin-bottom:1.5rem;">
<input name="cron_expression" value="{{ job.cron_expression_str() }}" style="width:20em;font-family:monospace;">
<button type="submit" style="padding:.4rem 1rem; background:#6c757d; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.jobs_cron_update }}</button>
</form>
{% endif %}
<h2>{{ t.jobs_run_history }}</h2>
{% if runs.is_empty() %}
<p>No runs yet.</p>
{% else %}
<table>
<tr>
<th>ID</th>
<th>{{ t.jobs_run_status }}</th>
<th>{{ t.jobs_run_started }}</th>
<th>{{ t.jobs_run_duration }}</th>
<th>{{ t.jobs_run_trigger }}</th>
<th>{{ t.jobs_actions }}</th>
</tr>
{% for run in runs %}
<tr>
<td>{{ run.id_val() }}</td>
<td><span class="badge {{ run.status_badge_class() }}">{{ run.status_str() }}</span></td>
<td>{{ run.started_at_str() }}</td>
<td>{{ run.duration_display() }}</td>
<td>{{ run.trigger_str() }}</td>
<td><a href="/admin/jobs/{{ job.name_str() }}/runs/{{ run.id_val() }}">{{ t.reviews_view }}</a></td>
</tr>
{% endfor %}
</table>
{% endif %}
<p style="margin-top:1rem;"><a href="/admin/jobs">&larr; {{ t.jobs_back_to_list }}</a></p>
<style>
.badge-completed { background: #d4edda; color: #155724; }
.badge-failed { background: #f8d7da; color: #721c24; }
.badge-processing { background: #d1ecf1; color: #0c5460; }
</style>
{% endblock content %}
-31
View File
@@ -1,31 +0,0 @@
{% extends "admin/layout.html" %}
{% block admin_title %}{{ t.jobs_run_detail }} #{{ run.id_val() }}{% endblock admin_title %}
{% block content %}
<h1>{{ t.jobs_run_detail }} #{{ run.id_val() }}</h1>
<table>
<tr><th>{{ t.jobs_run_status }}</th><td><span class="badge {{ run.status_badge_class() }}">{{ run.status_str() }}</span></td></tr>
<tr><th>{{ t.jobs_run_trigger }}</th><td>{{ run.trigger_str() }}</td></tr>
<tr><th>{{ t.jobs_run_started }}</th><td>{{ run.started_at_str() }}</td></tr>
<tr><th>{{ t.jobs_run_duration }}</th><td>{{ run.duration_display() }}</td></tr>
</table>
{% if !run.error_message_str().is_empty() %}
<h2>{{ t.jobs_run_error }}</h2>
<pre style="background:#f8d7da; color:#721c24; padding:1rem; border-radius:6px; overflow-x:auto; font-size:.85rem;">{{ run.error_message_str() }}</pre>
{% endif %}
{% if !run.log_output_str().is_empty() %}
<h2>{{ t.jobs_run_log }}</h2>
<pre style="background:#f4f4f4; padding:1rem; border-radius:6px; overflow-x:auto; font-size:.85rem; max-height:40em; overflow-y:auto;">{{ run.log_output_str() }}</pre>
{% endif %}
<p style="margin-top:1rem;"><a href="/admin/jobs/{{ job_name }}">&larr; {{ t.jobs_back_to_job }}</a></p>
<style>
.badge-completed { background: #d4edda; color: #155724; }
.badge-failed { background: #f8d7da; color: #721c24; }
.badge-processing { background: #d1ecf1; color: #0c5460; }
</style>
{% endblock content %}
-46
View File
@@ -1,46 +0,0 @@
{% extends "admin/layout.html" %}
{% block admin_title %}{{ t.nav_jobs }}{% endblock admin_title %}
{% block content %}
<h1>{{ t.jobs_heading }}</h1>
<table>
<tr>
<th>{{ t.jobs_name }}</th>
<th>{{ t.jobs_description }}</th>
<th>{{ t.jobs_cron }}</th>
<th>{{ t.jobs_enabled }}</th>
<th>{{ t.jobs_last_run }}</th>
<th>{{ t.jobs_next_run }}</th>
<th>{{ t.jobs_actions }}</th>
</tr>
{% for job in jobs %}
<tr>
<td><a href="/admin/jobs/{{ job.name_str() }}">{{ job.name_str() }}</a></td>
<td>{{ job.description_str() }}</td>
<td><code>{{ job.cron_expression_str() }}</code></td>
<td>{% if job.enabled() %}&#9989;{% else %}&#10060;{% endif %}</td>
<td>{{ job.last_run_at_str() }}</td>
<td>{{ job.next_run_at_str() }}</td>
<td style="display:flex;gap:.3rem;">
{% if job.name_str() == "metadata_backfill" %}
<a href="/admin/jobs/{{ job.name_str() }}" style="padding:.3rem .6rem; border-radius:4px; border:1px solid #007bff; background:#007bff; color:#fff; cursor:pointer; text-decoration:none;">{{ t.jobs_metadata_backfill_options }}</a>
{% else %}
<form method="post" action="/admin/jobs/{{ job.name_str() }}/run" style="margin:0;">
<button type="submit" style="padding:.3rem .6rem; border-radius:4px; border:1px solid #007bff; background:#007bff; color:#fff; cursor:pointer;">{{ t.jobs_run_now }}</button>
</form>
{% endif %}
{% if job.name_str() != "metadata_backfill" %}
<form method="post" action="/admin/jobs/{{ job.name_str() }}/toggle" style="margin:0;">
{% if job.enabled() %}
<button type="submit" style="padding:.3rem .6rem; border-radius:4px; border:1px solid #dc3545; background:#fff; color:#dc3545; cursor:pointer;">{{ t.jobs_disable }}</button>
{% else %}
<button type="submit" style="padding:.3rem .6rem; border-radius:4px; border:1px solid #28a745; background:#fff; color:#28a745; cursor:pointer;">{{ t.jobs_enable }}</button>
{% endif %}
</form>
{% endif %}
</td>
</tr>
{% endfor %}
</table>
{% endblock content %}
-64
View File
@@ -1,64 +0,0 @@
{% extends "base.html" %}
{% block title %}{% block admin_title %}{{ t.nav_admin }}{% endblock admin_title %} | {{ t.site_name }}{% endblock title %}
{% block head_extra %}
<script src="https://unpkg.com/htmx.org@2.0.4" integrity="sha384-HGfztofotfshcF7+8n44JQL2oJmowVChPTg48S+jvZoztPfvwD79OC/LTtG6dMp+" crossorigin="anonymous"></script>
<style>
* { margin: 0; padding: 0; box-sizing: border-box; }
body { font-family: system-ui, -apple-system, sans-serif; display: flex; min-height: 100vh; background: #f5f5f5; color: #333; }
nav.sidebar { width: 220px; background: #1a1a2e; color: #eee; padding: 1rem; }
nav.sidebar h2 { font-size: 1.1rem; margin-bottom: 1.5rem; }
.admin-version { display: inline-block; margin-left: .35rem; color: #999; font-size: .72rem; font-weight: 500; vertical-align: baseline; }
nav.sidebar a { color: #ccc; text-decoration: none; display: block; padding: .4rem .6rem; border-radius: 4px; }
nav.sidebar a:hover { background: #16213e; color: #fff; }
.main-wrap { flex: 1; display: flex; flex-direction: column; }
.topbar { display: flex; justify-content: flex-end; align-items: center; gap: 1rem; padding: .5rem 1.5rem; background: #fff; border-bottom: 1px solid #e0e0e0; }
.user-info { font-size: .85rem; color: #555; }
.lang-switch { display: flex; gap: .25rem; }
.lang-switch a { text-decoration: none; padding: .25rem .5rem; border-radius: 4px; font-size: .9rem; color: #555; }
.lang-switch a:hover { background: #eee; color: #111; }
.lang-switch a.active { font-weight: 700; color: #111; }
.logout-link { text-decoration: none; font-size: .85rem; color: #555; padding: .25rem .5rem; border-radius: 4px; }
.logout-link:hover { background: #eee; color: #111; }
.main { flex: 1; padding: 2rem; overflow-x: auto; }
table { border-collapse: collapse; width: 100%; margin-bottom: 1.5rem; background: #fff; border-radius: 6px; overflow: hidden; box-shadow: 0 1px 3px rgba(0,0,0,.1); }
th, td { text-align: left; padding: .6rem .8rem; border-bottom: 1px solid #eee; }
th { background: #f0f0f0; font-weight: 600; }
h1 { margin-bottom: 1rem; }
h2 { margin: 1.5rem 0 .5rem; }
code { background: #f4f4f4; padding: .1rem .35rem; border-radius: 3px; font-size: .85em; }
.badge { display: inline-block; padding: .15rem .55rem; border-radius: 4px; font-size: .8rem; font-weight: 600; letter-spacing: .02em; }
.badge-default { background: #e9ecef; color: #555; }
.badge-database { background: #d1ecf1; color: #0c5460; }
.badge-env { background: #fff3cd; color: #856404; }
</style>
{% endblock head_extra %}
{% block body %}
<nav class="sidebar">
<h2>{{ t.site_name }} {{ t.nav_admin }} <span class="admin-version">v{{ t.app_version() }}</span></h2>
<a href="/admin/">{{ t.nav_dashboard }}</a>
<a href="/admin/artists">{{ t.nav_artists }}</a>
<a href="/admin/releases">{{ t.nav_releases }}</a>
<a href="/admin/media-files">{{ t.nav_media_files }}</a>
<a href="/admin/jobs">{{ t.nav_jobs }}</a>
<a href="/admin/reviews">{{ t.nav_reviews }}</a>
<a href="/admin/users">{{ t.nav_users }}</a>
<a href="/admin/settings">{{ t.nav_settings }}</a>
<a href="/admin/debug">{{ t.nav_debug }}</a>
</nav>
<div class="main-wrap">
<div class="topbar">
<span class="user-info">{{ user_name }} ({{ user_role }})</span>
<div class="lang-switch">
<a href="#"{% if t.lang.code() == "en" %} class="active"{% endif %} onclick="location.href='/set-lang?lang=en&next='+encodeURIComponent(location.pathname);return false">EN</a>
<a href="#"{% if t.lang.code() == "ru" %} class="active"{% endif %} onclick="location.href='/set-lang?lang=ru&next='+encodeURIComponent(location.pathname);return false">RU</a>
</div>
<a class="logout-link" href="/logout">{{ t.nav_logout }}</a>
</div>
<div class="main">
{% block content %}{% endblock content %}
</div>
</div>
{% endblock body %}
-51
View File
@@ -1,51 +0,0 @@
{% extends "admin/layout.html" %}
{% block admin_title %}{{ t.nav_media_files }}{% endblock admin_title %}
{% block content %}
<h1>{{ t.media_files_heading }}</h1>
{% if rows.is_empty() %}
<p>{{ t.media_files_empty }}</p>
{% else %}
<table>
<tr>
<th>ID</th>
<th>{{ t.media_files_filename }}</th>
<th>{{ t.media_files_type }}</th>
<th>{{ t.media_files_format }}</th>
<th>{{ t.media_files_size }}</th>
<th>{{ t.media_files_track }}</th>
<th>{{ t.media_files_path }}</th>
<th>{{ t.media_files_created }}</th>
<th>{{ t.media_files_actions }}</th>
</tr>
{% for row in rows %}
<tr>
<td>{{ row.media_file.id_val() }}</td>
<td>{{ row.media_file.original_filename_str() }}</td>
<td>{{ row.media_file.file_type_str() }}</td>
<td>{{ row.media_file.audio_format_str() }}</td>
<td>{{ row.media_file.file_size_display() }}</td>
<td>
{% if row.track_title.is_empty() %}
<span class="badge badge-orphan">{{ t.media_files_orphan }}</span>
{% else %}
{{ row.track_title }}
{% endif %}
</td>
<td style="max-width:250px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;" title="{{ row.media_file.file_path_str() }}">{{ row.media_file.file_path_str() }}</td>
<td>{{ row.media_file.created_at_str() }}</td>
<td>
<form method="post" action="/admin/media-files/{{ row.media_file.id_val() }}/delete" style="display:inline;" onsubmit="return confirm('{{ t.media_files_delete_confirm }}')">
<button type="submit" style="background:none; border:none; color:#c00; cursor:pointer; padding:0; text-decoration:underline;">{{ t.media_files_delete }}</button>
</form>
</td>
</tr>
{% endfor %}
</table>
{% endif %}
<style>
.badge-orphan { background: #fff3cd; color: #856404; }
</style>
{% endblock content %}
+25
View File
@@ -0,0 +1,25 @@
<aside class="sidebar" id="admin-navigation" :class="{'is-open': menuOpen}" :data-compact="isCompact" :inert="isCompact && !menuOpen" :role="isCompact ? 'dialog' : null" :aria-modal="isCompact && menuOpen ? 'true' : null" aria-label="Admin navigation" tabindex="-1" x-effect="adminOverlay.sync($el, isCompact && menuOpen)" @keydown="adminOverlay.keydown($event, $el)">
<div class="brand">
<div><div class="brand-title">FuruMusic <span class="version">v{{ version }}</span></div><div class="admin-user">{{ user_name }} · {{ user_role }}</div></div>
<button class="icon-btn nav-close" data-dialog-close aria-label="Close navigation" @click="closeMenu()"><i data-lucide="x"></i></button>
</div>
<nav aria-label="Administration" class="nav-sections" @click="if ($event.target.closest('.nav-btn')) closeMenu()">
<div class="nav-group">
<div class="nav-label">Operations</div>
<button class="nav-btn" :class="{active: activeView === 'reviews'}" :aria-current="activeView === 'reviews' ? 'page' : null" @click="openReviews()"><i data-lucide="inbox"></i><span>Review Queue</span><span class="nav-count" x-text="reviewTotalAll()"></span></button>
<button class="nav-btn" :class="{active: activeView === 'jobs'}" :aria-current="activeView === 'jobs' ? 'page' : null" @click="openJobs()"><i data-lucide="calendar-clock"></i><span>Tasks</span><span class="nav-count" x-text="jobs.length || 0"></span></button>
</div>
<div class="nav-group">
<div class="nav-label">Music</div>
<button class="nav-btn" :class="{active: activeView === 'library'}" :aria-current="activeView === 'library' ? 'page' : null" @click="openLibrary(libraryKind)"><i data-lucide="library"></i><span>Library Workbench</span><span class="nav-count" x-text="fmt(stats.tracks || 0)"></span></button>
<button class="nav-btn" :class="{active: activeView === 'tools'}" :aria-current="activeView === 'tools' ? 'page' : null" @click="openTools()"><i data-lucide="wrench"></i><span>Library Tools</span></button>
<button class="nav-btn" :class="{active: activeView === 'statistics'}" :aria-current="activeView === 'statistics' ? 'page' : null" @click="openStatistics()"><i data-lucide="chart-no-axes-combined"></i><span>Statistics</span></button>
</div>
<div class="nav-group">
<div class="nav-label">Instance</div>
<button class="nav-btn" :class="{active: activeView === 'users'}" :aria-current="activeView === 'users' ? 'page' : null" @click="openUsers()"><i data-lucide="users"></i><span>Users</span><span class="nav-count" x-text="users.online_count ? users.online_count + ' online' : ''"></span></button>
<button class="nav-btn" :class="{active: activeView === 'settings'}" :aria-current="activeView === 'settings' ? 'page' : null" @click="openSettings()"><i data-lucide="settings"></i><span>Settings</span></button>
</div>
</nav>
<a class="nav-player btn" href="/"><i data-lucide="music-2"></i>Back to player</a>
</aside>
-32
View File
@@ -1,32 +0,0 @@
{% if !agent_enabled %}
<p style="color:#999;">{{ t.settings_agent_status_disabled }}</p>
{% else if agent_llm_url.is_empty() %}
<p style="color:#999;">{{ t.settings_agent_status_no_url }}</p>
{% else if agent_probe.ok %}
<div style="border:1px solid #28a745; border-radius:6px; padding:1rem; margin-bottom:1rem; background:#f0fff0;">
<p style="margin:0 0 .5rem; font-weight:bold; color:#28a745;">{{ t.settings_agent_status_ok }}</p>
{% if !agent_probe.model_intro.is_empty() %}
<blockquote style="border-left:3px solid #28a745; padding-left:.75rem; margin:.5rem 0; color:#333; font-style:italic;">{{ agent_probe.model_intro }}</blockquote>
{% endif %}
<table style="font-size:.85rem; margin-top:.5rem;">
{% if !agent_probe.model_name.is_empty() %}
<tr><td style="padding-right:1rem; color:#666;">{{ t.settings_agent_model_name }}</td><td><code>{{ agent_probe.model_name }}</code></td></tr>
{% endif %}
<tr><td style="padding-right:1rem; color:#666;">{{ t.settings_agent_latency }}</td><td>{{ agent_probe.latency_ms }} ms</td></tr>
{% if let Some(pt) = agent_probe.prompt_tokens %}
<tr><td style="padding-right:1rem; color:#666;">{{ t.settings_agent_prompt_tokens }}</td><td>{{ pt }}</td></tr>
{% endif %}
{% if let Some(ct) = agent_probe.completion_tokens %}
<tr><td style="padding-right:1rem; color:#666;">{{ t.settings_agent_completion_tokens }}</td><td>{{ ct }}</td></tr>
{% endif %}
{% if let Some(tps) = agent_probe.tokens_per_sec %}
<tr><td style="padding-right:1rem; color:#666;">{{ t.settings_agent_tokens_per_sec }}</td><td>{{ format!("{:.1}", tps) }}</td></tr>
{% endif %}
</table>
</div>
{% else %}
<div style="border:1px solid #dc3545; border-radius:6px; padding:1rem; margin-bottom:1rem; background:#fff5f5;">
<p style="margin:0 0 .5rem; font-weight:bold; color:#dc3545;">{{ t.settings_agent_status_error }}</p>
<p style="margin:0; font-size:.85rem; color:#666;">{{ agent_probe.error }}</p>
</div>
{% endif %}
-130
View File
@@ -1,130 +0,0 @@
{% extends "admin/layout.html" %}
{% block admin_title %}{% if is_edit %}{{ t.releases_edit_heading }}{% else %}{{ t.releases_new_heading }}{% endif %}{% endblock admin_title %}
{% block content %}
<h1>{% if is_edit %}{{ t.releases_edit_heading }}{% else %}{{ t.releases_new_heading }}{% endif %}</h1>
<form method="post" action="{% if is_edit %}/admin/releases/{{ form_release_id }}/edit{% else %}/admin/releases/new{% endif %}" id="release-form">
<table>
<tr>
<td><label for="title">{{ t.releases_title }}</label></td>
<td><input name="title" id="title" value="{{ form_title }}" required 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 form_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="year">{{ t.releases_year }}</label></td>
<td><input name="year" id="year" type="number" min="1900" max="2100" value="{{ form_year }}" style="width:100%"></td>
</tr>
<tr>
<td><label>{{ t.releases_artists }}</label></td>
<td>
<div id="artist-tags" style="display:flex; flex-wrap:wrap; gap:.3rem; margin-bottom:.5rem;"></div>
<div style="display:flex; gap:.5rem;">
<input list="artist-list" id="artist-input" placeholder="{{ t.releases_select_artist }}" style="flex:1; padding:.4rem;">
<datalist id="artist-list">
{% for a in artists %}
<option value="{{ a.name_str() }}" data-id="{{ a.id_val() }}"></option>
{% endfor %}
</datalist>
<button type="button" onclick="addArtist()" style="padding:.4rem .8rem;">+</button>
</div>
<input type="hidden" name="artist_id" id="artist-ids-hidden" value="">
</td>
</tr>
</table>
<button type="submit" style="margin-top: 1rem; padding: .5rem 1.5rem;">{{ t.settings_save }}</button>
</form>
<script>
(function() {
// Artist data from server
var allArtists = [
{% for a in artists %}
{ id: {{ a.id_val() }}, name: "{{ a.name_str() }}" },
{% endfor %}
];
// Currently selected artist IDs
var selectedIds = [{% for aid in form_artist_ids %}{{ aid }},{% endfor %}];
var tagsContainer = document.getElementById('artist-tags');
var hiddenInput = document.getElementById('artist-ids-hidden');
var artistInput = document.getElementById('artist-input');
function findArtistByName(name) {
var lower = name.toLowerCase().trim();
for (var i = 0; i < allArtists.length; i++) {
if (allArtists[i].name.toLowerCase() === lower) return allArtists[i];
}
return null;
}
function findArtistById(id) {
for (var i = 0; i < allArtists.length; i++) {
if (allArtists[i].id === id) return allArtists[i];
}
return null;
}
function syncHidden() {
hiddenInput.value = selectedIds.join(',');
}
function renderTags() {
tagsContainer.innerHTML = '';
for (var i = 0; i < selectedIds.length; i++) {
var artist = findArtistById(selectedIds[i]);
if (!artist) continue;
var tag = document.createElement('span');
tag.style.cssText = 'display:inline-flex; align-items:center; gap:.3rem; padding:.2rem .5rem; background:#e9ecef; border-radius:4px; font-size:.85rem;';
tag.textContent = artist.name;
var btn = document.createElement('button');
btn.type = 'button';
btn.textContent = '\u00d7';
btn.style.cssText = 'background:none; border:none; cursor:pointer; font-size:1rem; color:#c00; padding:0; line-height:1;';
btn.setAttribute('data-id', artist.id);
btn.onclick = function() {
var rid = parseInt(this.getAttribute('data-id'));
selectedIds = selectedIds.filter(function(x) { return x !== rid; });
renderTags();
syncHidden();
};
tag.appendChild(btn);
tagsContainer.appendChild(tag);
}
}
window.addArtist = function() {
var artist = findArtistByName(artistInput.value);
if (!artist) return;
if (selectedIds.indexOf(artist.id) === -1) {
selectedIds.push(artist.id);
renderTags();
syncHidden();
}
artistInput.value = '';
};
// Allow pressing Enter in the artist input to add
artistInput.addEventListener('keydown', function(e) {
if (e.key === 'Enter') {
e.preventDefault();
window.addArtist();
}
});
// Initial render
renderTags();
syncHidden();
})();
</script>
{% endblock content %}
-51
View File
@@ -1,51 +0,0 @@
{% extends "admin/layout.html" %}
{% block admin_title %}{{ t.nav_releases }}{% endblock admin_title %}
{% block content %}
<h1>{{ t.releases_heading }}</h1>
<div style="display:flex; gap:1rem; align-items:center; margin-bottom:1rem; flex-wrap:wrap;">
<a href="/admin/releases/new" style="display:inline-block; padding:.5rem 1rem; background:#1a1a2e; color:#fff; text-decoration:none; border-radius:4px;">{{ t.releases_add }}</a>
<form method="get" action="/admin/releases" style="display:flex; gap:.5rem; align-items:center;">
<label for="artist_id" style="font-size:.85rem; color:#555;">{{ t.releases_filter_label }}:</label>
<select name="artist_id" id="artist_id" onchange="this.form.submit()" style="padding:.35rem .5rem; border:1px solid #ccc; border-radius:4px;">
<option value="">{{ t.releases_filter_all }}</option>
{% for a in artists %}
<option value="{{ a.id_val() }}"{% match filter_artist_id %}{% when Some with (fid) %}{% if *fid == a.id_val() %} selected{% endif %}{% when None %}{% endmatch %}>{{ a.name_str() }}</option>
{% endfor %}
</select>
</form>
</div>
{% if rows.is_empty() %}
<p>{{ t.releases_empty }}</p>
{% else %}
<table>
<tr>
<th>ID</th>
<th>{{ t.releases_title }}</th>
<th>{{ t.releases_artists }}</th>
<th>{{ t.releases_type }}</th>
<th>{{ t.releases_year }}</th>
<th>{{ t.releases_actions }}</th>
</tr>
{% for row in rows %}
<tr>
<td>{{ row.release.id_val() }}</td>
<td>{{ row.release.title_str() }}</td>
<td>{% if row.artist_names.is_empty() %}<span style="color:#999;">{{ t.releases_no_artist }}</span>{% else %}{{ row.artist_names }}{% endif %}</td>
<td><code>{{ row.release.release_type_str() }}</code></td>
<td>{{ row.release.year_display() }}</td>
<td>
<a href="/admin/releases/{{ row.release.id_val() }}/edit">{{ t.releases_edit }}</a>
&nbsp;|&nbsp;
<form method="post" action="/admin/releases/{{ row.release.id_val() }}/delete" style="display:inline;" onsubmit="return confirm('{{ t.releases_delete_confirm }}')">
<button type="submit" style="background:none; border:none; color:#c00; cursor:pointer; padding:0; text-decoration:underline;">{{ t.releases_delete }}</button>
</form>
</td>
</tr>
{% endfor %}
</table>
{% endif %}
{% endblock content %}
+193
View File
@@ -0,0 +1,193 @@
<style>
/* Shared admin UI contract. Keep breakpoints in sync with admin/ui.html. */
:root { --admin-gap:16px; --admin-touch:44px; --admin-header:64px; --admin-radius:10px; }
html { overscroll-behavior:none; }
:focus-visible { outline:2px solid var(--accent); outline-offset:3px; }
.admin-shell { min-width:0; }
.sidebar { overflow:auto; overscroll-behavior:contain; padding-bottom:env(safe-area-inset-bottom); }
.brand { display:flex; align-items:center; justify-content:space-between; gap:12px; }
.nav-player { margin:12px; margin-top:auto; min-height:44px; flex:none; }
.nav-btn { min-height:44px; height:auto; padding-block:10px; }
.nav-group { padding-block:8px; }
.nav-label { letter-spacing:.08em; }
.nav-btn.active { background:rgba(29,185,84,.12); box-shadow:inset 3px 0 var(--accent); }
.menu-toggle, .nav-close, .nav-backdrop, .workspace-tabs, .section-jump { display:none; }
.main { overscroll-behavior:contain; scrollbar-gutter:stable; }
.main.is-locked { overflow:hidden; }
.topbar { min-height:var(--admin-header); height:auto; }
.top-actions { flex:none; }
.content { min-width:0; padding:var(--admin-gap); }
.content > *, .panel-head > *, .toolbar > *, .modal-body > *, .settings-section > *, .image-editor > * { min-width:0; }
.panel-head, .toolbar, .action-strip { flex-wrap:wrap; }
.panel-head > .toolbar { margin-left:auto; }
.toolbar { max-width:100%; }
.search { max-width:100%; min-width:0; }
.btn { text-decoration:none; white-space:normal; line-height:1.3; }
.icon-btn { flex:none; }
.segmented { max-width:100%; min-width:0; overflow:auto; flex-wrap:nowrap; }
.seg-btn { flex:none; }
.panel-title strong, .panel-title span, .setting-help, .selection-summary, .repair-context { overflow-wrap:anywhere; }
.table-wrap { max-width:100%; overscroll-behavior:contain; }
.table-wrap:focus-visible { outline-offset:-3px; }
.jobs-page { grid-template-columns:minmax(0,1fr) minmax(280px,340px); height:calc(100dvh - 100px); }
.run-row { width:100%; color:inherit; text-align:left; background:transparent; font:inherit; }
.row-link { display:block; max-width:100%; padding:0; background:transparent; color:inherit; text-align:left; cursor:pointer; }
.row-link:hover { text-decoration:underline; }
.job-fact > .btn { grid-column:2; justify-self:start; }
.job-fact > form { grid-column:1 / -1; }
.task-form { position:static; max-height:100%; }
.settings-section { scroll-margin-top:calc(var(--admin-header) + 70px); }
.settings-federation-body { grid-template-columns:minmax(0,4fr) minmax(0,8fr); }
.download-method-controls { grid-template-columns:minmax(0,.75fr) minmax(0,1.25fr); }
.proxy-row { grid-template-columns:minmax(0,1.4fr) minmax(0,.8fr) minmax(0,.8fr) auto; }
.field { display:block; min-width:0; }
.modal-backdrop { padding:24px; overscroll-behavior:contain; }
.modal { display:flex; flex-direction:column; width:min(760px,100%); max-width:100%; max-height:calc(100dvh - 48px); }
.modal.user-modal { width:min(860px,100%); }
.modal.merge-modal { width:min(1180px,100%); }
.modal-head { flex:none; min-width:0; padding:12px 16px; }
.modal-head [data-dialog-close] { flex:none; min-width:44px; min-height:44px; }
.modal-body { min-height:0; max-height:none; overflow:auto; overscroll-behavior:contain; padding:16px; }
.dialog-actions { position:sticky; bottom:-16px; z-index:4; display:flex; align-items:center; justify-content:flex-end; flex-wrap:wrap; gap:8px; margin:16px -16px -16px; padding:12px 16px; border-top:1px solid var(--border-color); background:var(--bg-secondary); }
.merge-footer.dialog-actions { justify-content:space-between; }
.track-field { min-width:0; margin:0; }
.track-field > span { display:none; }
.toast { z-index:50; max-width:min(420px,calc(100vw - 24px)); bottom:max(18px,env(safe-area-inset-bottom)); overflow-wrap:anywhere; }
.repair-plan-body { max-width:100%; }
.repair-work, .repair-side { min-width:0; }
.repair-manual { max-width:100%; overflow:auto; }
.repair-diff { table-layout:auto; }
.settings-actions { padding-bottom:max(12px,env(safe-area-inset-bottom)); }
@media (max-width:1279px) {
.workspace-tabs { display:flex; gap:4px; padding:4px; margin-bottom:12px; border:1px solid var(--border-color); border-radius:8px; background:var(--bg-secondary); }
.workspace-tabs button { flex:1; min-width:0; min-height:44px; padding:8px; border-radius:5px; background:transparent; color:var(--text-secondary); cursor:pointer; }
.workspace-tabs [aria-selected="true"] { background:var(--bg-active); color:var(--text-primary); }
.jobs-page { display:block; height:auto; }
.jobs-page .jobs-list-panel, .jobs-page .task-form, .jobs-page .run-log-panel { display:none; max-height:none; }
.jobs-page[data-task-pane="list"] .jobs-list-panel,
.jobs-page[data-task-pane="details"] .task-form,
.jobs-page[data-task-pane="logs"] .run-log-panel { display:flex; }
.task-form-body { overflow:visible; }
.run-log-body { min-height:300px; overflow:visible; }
.run-log-output { min-height:50dvh; max-height:70dvh; }
.settings-layout { grid-template-columns:minmax(0,1fr); grid-template-areas:"access" "oidc" "agent" "agentstatus" "similarity" "similaritystatus" "downloads" "federation" "lastfm" "developer" "actions"; }
.settings-federation-body { grid-template-columns:minmax(0,1fr); }
.repair-shell { grid-template-columns:250px minmax(0,1fr); }
}
@media (max-width:1023px) {
:root { --admin-gap:16px; }
.admin-shell { grid-template-columns:minmax(0,1fr); }
.sidebar { position:fixed; inset:0 auto 0 0; z-index:25; width:min(320px,calc(100vw - 48px)); height:100dvh; transform:translateX(-100%); visibility:hidden; transition:transform .18s ease, visibility .18s; padding-top:env(safe-area-inset-top); box-shadow:16px 0 48px #0006; }
.sidebar.is-open { transform:translateX(0); visibility:visible; }
.nav-backdrop { display:block; position:fixed; inset:0; z-index:24; background:#0009; }
.menu-toggle, .nav-close { display:inline-flex; align-items:center; justify-content:center; min-width:44px; min-height:44px; }
.topbar { display:grid; grid-template-columns:44px minmax(0,1fr) auto; gap:10px; padding:10px 16px; padding-top:max(10px,env(safe-area-inset-top)); }
.page-title h1 { font-size:18px; }
.page-title p { line-height:1.4; }
.panel-head { gap:12px; }
.panel-head > .toolbar { margin-left:0; }
.library-row { grid-template-columns:32px minmax(0,1fr) 110px; }
.library-row .tags { grid-column:2 / -1; grid-row:2; }
.library-row > .badge { grid-column:3; grid-row:1; justify-self:end; }
.section-jump { display:flex; align-items:center; gap:12px; margin-bottom:16px; font-size:13px; color:var(--text-secondary); }
.section-jump select { flex:1; width:auto; }
.primary-line, .secondary-line { white-space:normal; overflow-wrap:anywhere; }
.users-table, .statistics-table { min-width:700px; }
}
@media (max-width:767px) {
:root { --admin-gap:12px; }
.topbar { gap:8px; padding-inline:12px; }
.top-actions { gap:6px; }
.top-actions .btn { width:44px; height:44px; padding:0; justify-content:center; }
.top-action-label, .page-title p { display:none; }
.page-title h1 { font-size:17px; overflow-wrap:anywhere; }
.btn, .icon-btn, .seg-btn { min-height:44px; height:auto; }
.icon-btn { width:44px; }
.btn { padding:10px 12px; }
.search, .setting-field input, .setting-field select, .field input, .field select, .field textarea, .setting-field textarea, .proxy-row input, .download-method-controls select, .youtube-cookie-picker select, .repair-composer textarea { font-size:16px; min-height:44px; }
.search { width:100%; }
.toolbar { gap:8px; }
.panel-head { padding:12px; align-items:stretch; }
.panel-head > .toolbar { width:100%; }
.toolbar > input.search { flex:1 1 180px; }
.segmented { width:100%; }
.seg-btn { min-width:max-content; }
.action-strip { padding:12px; gap:12px; align-items:stretch; }
.action-strip > .toolbar { width:100%; }
.action-strip > .selection-summary { flex-basis:100%; }
.stats-strip, .statistics-summary, .user-summary-grid, .user-profile-facts, .user-stats-grid { grid-template-columns:repeat(2,minmax(0,1fr)); }
.stat-cell { padding:12px; }
.stat-value { font-size:24px; }
.stats-strip { gap:8px; }
.table-wrap, .review-table-wrap, .users-table-wrap, .job-table-wrap { max-height:none; overflow:visible; }
.responsive-table { display:block; table-layout:auto; min-width:0; width:100%; }
.responsive-table thead { position:absolute; width:1px; height:1px; overflow:hidden; clip-path:inset(50%); }
.responsive-table tbody { display:block; }
.responsive-table tr { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); gap:12px; margin:0 12px 12px; padding:14px; border:1px solid var(--border-color); border-radius:8px; background:var(--bg-primary); }
.responsive-table tr.active { border-color:var(--accent); }
.responsive-table td { display:flex; flex-direction:column; align-items:flex-start; gap:5px; width:auto; height:auto; min-width:0; padding:0; border:0; overflow-wrap:anywhere; white-space:normal; }
.responsive-table td::before { content:attr(data-label); color:var(--text-subdued); font-size:10px; font-weight:750; text-transform:uppercase; letter-spacing:.04em; }
.responsive-table td[data-primary], .responsive-table td[data-label="Actions"], .responsive-table td[data-label="Account"], .responsive-table td[data-label="Tags"] { grid-column:1 / -1; }
.responsive-table td[data-primary] { font-size:15px; }
.responsive-table .primary-line { font-size:14px; }
.responsive-table .secondary-line { line-height:1.5; }
.responsive-table .tags { max-height:none; }
.responsive-table .inline-runs { flex-wrap:wrap; }
.responsive-table .run-chip { min-height:36px; max-width:none; }
.responsive-table .toolbar { justify-content:flex-start; flex-wrap:wrap; }
.row-link { min-height:44px; display:flex; align-items:center; }
.check { width:22px; height:22px; }
.library-row { grid-template-columns:26px minmax(0,1fr) auto; padding:12px; gap:10px; }
.library-row > .tags { max-height:none; }
.editor-grid, .settings-grid, .federation-status-grid, .download-method-controls, .proxy-row, .metadata-backfill-options .option-grid { grid-template-columns:minmax(0,1fr); }
.setting-field, .settings-wide, .setting-field.settings-short { max-width:none; }
.settings-grid, .settings-federation-body, .probe-body { padding:12px; }
.settings-federation-body .settings-grid, .settings-federation-body .probe-body { padding:0; }
.youtube-cookie-picker, .youtube-cookie-upload, .transport-log-head { align-items:stretch; flex-direction:column; }
.settings-actions { position:static; }
.settings-actions .toolbar { justify-content:flex-end; }
.modal-backdrop { padding:0; }
.modal, .modal.user-modal, .modal.merge-modal { width:100%; height:100dvh; max-height:100dvh; border:0; border-radius:0; }
.modal-head { padding-top:max(12px,env(safe-area-inset-top)); }
.modal-body { flex:1; padding-bottom:max(16px,env(safe-area-inset-bottom)); }
.dialog-actions { padding-bottom:max(12px,env(safe-area-inset-bottom)); }
.modal-body .toolbar { flex-wrap:wrap; }
.image-editor { grid-template-columns:96px minmax(0,1fr); }
.image-preview { width:96px; }
.image-actions { flex-wrap:wrap; }
.image-actions input[type="file"] { max-width:100%; }
.user-activity-row { grid-template-columns:44px minmax(0,1fr); }
.user-activity-cover { width:44px; height:44px; }
.user-activity-time { grid-column:2; min-width:0; text-align:left; }
.user-activity-title, .user-activity-meta, .user-activity-sub, .user-profile-facts strong { white-space:normal; overflow-wrap:anywhere; }
.release-track-head, .merge-track-head { display:none; }
.merge-track-list { min-width:0; }
.release-track-row, .merge-track-row { grid-template-columns:repeat(2,minmax(0,1fr)); padding:12px; gap:10px; }
.release-track-row > div, .merge-track-row > div { grid-column:1 / -1; }
.release-track-row .icon-btn { justify-self:end; grid-column:2; }
.track-field > span { display:block; color:var(--text-subdued); font-size:11px; margin-bottom:6px; }
.release-track-title, .release-track-meta { white-space:normal; overflow-wrap:anywhere; }
.merge-track-row > span { grid-column:1 / -1; }
.merge-order-actions { justify-content:flex-end; gap:8px; }
.merge-release-grid { grid-template-columns:minmax(0,1fr); }
.repair-shell { grid-template-columns:minmax(0,1fr); height:auto; min-height:0; }
.repair-side .panel:first-child .repair-scroll { max-height:260px; }
.repair-work .repair-chat { min-height:420px; height:65dvh; max-height:720px; }
.repair-plan-actions { align-items:stretch; flex-direction:column; }
.repair-message { max-width:100%; }
.repair-composer { flex-wrap:wrap; }
.repair-composer textarea { flex-basis:100%; }
.repair-composer .btn { margin-left:auto; }
.repair-diff { min-width:760px; }
.repair-manual { overscroll-behavior:contain; }
.statistics-ranking-head { align-items:stretch; flex-direction:column; }
.statistics-filters { padding:12px; }
.statistics-toolbar label { flex:1 1 140px; min-width:0; }
.statistics-toolbar .search { width:100%; }
.statistics-chart { padding:16px; }
.statistics-service-grid { grid-template-columns:minmax(0,1fr); padding:12px; }
.job-fact { grid-template-columns:70px minmax(0,1fr); }
.job-fact span:last-child { white-space:normal; overflow-wrap:anywhere; }
}
@media (prefers-reduced-motion:reduce) { .sidebar { transition:none; } }
</style>
-111
View File
@@ -1,111 +0,0 @@
{% extends "admin/layout.html" %}
{% block admin_title %}Review #{{ review.id_val() }}{% endblock admin_title %}
{% block content %}
<h1>Review #{{ review.id_val() }}</h1>
<table>
<tr><th>{{ t.reviews_status }}</th><td><span class="badge {{ review.status_badge_class() }}">{{ review.status_str() }}</span></td></tr>
<tr><th>{{ t.reviews_type }}</th><td>{{ review.review_type_str() }}</td></tr>
<tr><th>{{ t.reviews_input_path }}</th><td style="word-break:break-all;">{{ review.input_path_str() }}</td></tr>
<tr><th>{{ t.reviews_confidence }}</th><td>{% match review.confidence() %}{% when Some with (c) %}{{ c }}{% when None %}-{% endmatch %}</td></tr>
<tr><th>{{ t.reviews_created }}</th><td>{{ review.created_at_str() }}</td></tr>
{% match stats %}
{% when Some with (s) %}
<tr><th>{{ t.reviews_model }}</th><td>{{ s.model_name_str() }}</td></tr>
<tr><th>{{ t.reviews_llm_duration }}</th><td>{{ s.duration_display() }}</td></tr>
<tr><th>{{ t.reviews_tokens }}</th><td>{{ s.tokens_display() }}</td></tr>
{% when None %}
{% endmatch %}
</table>
{% if !error_message.is_empty() %}
<div style="margin: 1rem 0; padding: 1rem; background: #f8d7da; color: #721c24; border-radius: 6px;">
<strong>{{ t.reviews_error }}:</strong> {{ error_message }}
</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;">
<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>
</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() && 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 %}
<p style="margin-top:1rem;"><a href="/admin/reviews">&larr; {{ t.reviews_back_to_list }}</a></p>
<style>
.badge-completed { background: #d4edda; color: #155724; }
.badge-failed { background: #f8d7da; color: #721c24; }
.badge-pending { background: #fff3cd; color: #856404; }
.badge-queued { background: #d1ecf1; color: #0c5460; }
.badge-processing { background: #cce5ff; color: #004085; }
</style>
{% endblock content %}
-276
View File
@@ -1,276 +0,0 @@
{% extends "admin/layout.html" %}
{% block admin_title %}{{ t.nav_reviews }}{% endblock admin_title %}
{% block content %}
<h1>{{ t.reviews_heading }}</h1>
<div style="margin-bottom: 1rem; display: flex; gap: .5rem; align-items: center; flex-wrap: wrap;">
<a href="/admin/reviews" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "" %} #333; color: #fff{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_all }}</a>
<a href="/admin/reviews?status=pending" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "pending" %} #ffc107; color: #000{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_pending }}</a>
<a href="/admin/reviews?status=approved" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "approved" %} #28a745; color: #fff{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_approved }}</a>
<a href="/admin/reviews?status=rejected" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "rejected" %} #dc3545; color: #fff{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_rejected }}</a>
<a href="/admin/reviews?status=queued" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "queued" %} #17a2b8; color: #fff{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_queued }}</a>
<a href="/admin/reviews?status=processing" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "processing" %} #007bff; color: #fff{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_processing }}</a>
<a href="/admin/reviews?status=auto_approved" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "auto_approved" %} #28a745; color: #fff{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_auto_approved }}</a>
<a href="/admin/reviews?status=failed" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "failed" %} #dc3545; color: #fff{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_failed }}</a>
{% if !rows.is_empty() %}
<span style="flex:1;"></span>
<form method="post" action="/admin/reviews/clear{% if !status_filter.is_empty() %}?status={{ status_filter }}{% endif %}" style="margin:0;" onsubmit="return confirm('{{ t.reviews_clear_confirm }}');">
<button type="submit" style="padding:.3rem .8rem; border-radius:4px; border:1px solid #dc3545; background:#fff; color:#dc3545; cursor:pointer;">{% if status_filter.is_empty() %}{{ t.reviews_clear_all }}{% else %}{{ t.reviews_clear_filtered }}{% endif %}</button>
</form>
{% endif %}
</div>
{% if rows.is_empty() %}
<p>{{ t.reviews_empty }}</p>
{% else %}
<form id="reviews-bulk-form" method="post" action="/admin/reviews/bulk" style="margin:0;">
<input type="hidden" name="selected_ids" id="selected-review-ids" value="">
<input type="hidden" name="status_filter" value="{{ status_filter }}">
<div class="review-bulk-toolbar">
<button type="button" id="select-shown-reviews" class="review-toolbar-button">{{ t.reviews_select_all }}</button>
<button type="button" id="clear-review-selection" class="review-toolbar-button">{{ t.reviews_clear_selection }}</button>
<button type="submit" name="action" value="delete" class="review-danger-button" disabled>{{ t.reviews_delete_selected }}</button>
<button type="submit" name="action" value="requeue" class="review-primary-button" disabled>{{ t.reviews_requeue_selected }}</button>
<span id="review-selection-summary" class="review-selection-summary">{{ t.reviews_selected_none }}</span>
</div>
<table>
<tr>
<th class="review-select-cell"></th>
<th>ID</th>
<th>{{ t.reviews_status }}</th>
<th>{{ t.reviews_type }}</th>
<th>{{ t.reviews_input_path }}</th>
<th>{{ t.reviews_tags }}</th>
<th>{{ t.reviews_confidence }}</th>
<th>{{ t.reviews_model }}</th>
<th>{{ t.reviews_llm_duration }}</th>
<th>{{ t.reviews_tokens }}</th>
<th>{{ t.reviews_created }}</th>
<th>{{ t.jobs_actions }}</th>
</tr>
{% for row in rows %}
<tr>
<td class="review-select-cell">
<input type="checkbox" class="review-select" value="{{ row.review.id_val() }}" data-status="{{ row.review.status_str() }}" aria-label="Select review {{ row.review.id_val() }}">
</td>
<td><a href="/admin/reviews/{{ row.review.id_val() }}">{{ row.review.id_val() }}</a></td>
<td><span class="badge {{ row.review.status_badge_class() }}">{{ row.review.status_str() }}</span></td>
<td>{{ row.review.review_type_str() }}</td>
<td class="review-input-path" title="{{ row.review.input_path_str() }}">{{ row.display_input_path }}</td>
<td class="review-tag-cell">
{% for tag in row.media_tags %}
<span class="review-tag review-tag-{{ tag.kind }}">{{ tag.label }}</span>
{% endfor %}
</td>
<td>{% match row.review.confidence() %}{% when Some with (c) %}{{ c }}{% when None %}-{% endmatch %}</td>
{% match stats_map.get(&row.review.id_val()) %}
{% when Some with (s) %}
<td>{{ s.model_name }}</td>
<td>{{ s.duration_display() }}</td>
<td>{{ s.tokens_display() }}</td>
{% when None %}
<td>-</td>
<td>-</td>
<td>-</td>
{% endmatch %}
<td>{{ row.review.created_at_str() }}</td>
<td>
<a href="/admin/reviews/{{ row.review.id_val() }}">{{ t.reviews_view }}</a>
</td>
</tr>
{% endfor %}
</table>
</form>
{% endif %}
<style>
.review-bulk-toolbar {
margin-bottom: .75rem;
display: flex;
gap: .5rem;
align-items: center;
flex-wrap: wrap;
}
.review-toolbar-button,
.review-danger-button,
.review-primary-button {
padding: .35rem .7rem;
border-radius: 4px;
border: 1px solid #ced4da;
background: #fff;
color: #212529;
cursor: pointer;
}
.review-danger-button {
border-color: #dc3545;
color: #dc3545;
}
.review-primary-button {
border-color: #17a2b8;
color: #0c5460;
}
.review-danger-button:disabled,
.review-primary-button:disabled {
cursor: not-allowed;
opacity: .45;
}
.review-selection-summary {
min-height: 1.7rem;
padding: .35rem .6rem;
border: 1px solid #dee2e6;
border-radius: 4px;
background: #f8f9fa;
color: #495057;
font-size: .9rem;
white-space: nowrap;
}
.review-select-cell {
width: 2.25rem;
text-align: center;
}
.review-select {
width: 1rem;
height: 1rem;
}
.review-input-path {
max-width: 34rem;
white-space: normal;
overflow-wrap: anywhere;
}
.review-tag-cell {
max-width: 18rem;
}
.review-tag {
display: inline-block;
margin: .1rem .15rem .1rem 0;
padding: .12rem .35rem;
border: 1px solid #ced4da;
border-radius: 4px;
background: #f8f9fa;
color: #495057;
font-size: .8rem;
white-space: nowrap;
}
.review-tag-format { border-color: #9ec5fe; background: #e7f1ff; color: #084298; }
.review-tag-bitrate { border-color: #a3cfbb; background: #d1e7dd; color: #0f5132; }
.review-tag-sample { border-color: #ffda6a; background: #fff3cd; color: #664d03; }
.review-tag-depth { border-color: #d0bfff; background: #f0e7ff; color: #3d246c; }
.review-tag-size { border-color: #ced4da; background: #f8f9fa; color: #495057; }
.badge-completed { background: #d4edda; color: #155724; }
.badge-failed { background: #f8d7da; color: #721c24; }
.badge-pending { background: #fff3cd; color: #856404; }
.badge-queued { background: #d1ecf1; color: #0c5460; }
.badge-processing { background: #cce5ff; color: #004085; }
</style>
<script>
(() => {
const form = document.getElementById("reviews-bulk-form");
if (!form) {
return;
}
const checkboxes = Array.from(form.querySelectorAll(".review-select"));
const selectedIdsInput = document.getElementById("selected-review-ids");
const summary = document.getElementById("review-selection-summary");
const selectShownButton = document.getElementById("select-shown-reviews");
const clearSelectionButton = document.getElementById("clear-review-selection");
const submitButtons = Array.from(form.querySelectorAll("button[type='submit']"));
const selected = new Set();
const statusCounts = new Map();
const labels = {
pending: "{{ t.reviews_filter_pending }}",
approved: "{{ t.reviews_filter_approved }}",
rejected: "{{ t.reviews_filter_rejected }}",
queued: "{{ t.reviews_filter_queued }}",
processing: "{{ t.reviews_filter_processing }}",
auto_approved: "{{ t.reviews_filter_auto_approved }}",
failed: "{{ t.reviews_filter_failed }}"
};
function setStatusCount(status, delta) {
const next = (statusCounts.get(status) || 0) + delta;
if (next > 0) {
statusCounts.set(status, next);
} else {
statusCounts.delete(status);
}
}
function syncControls() {
selectedIdsInput.value = Array.from(selected).join(",");
const total = selected.size;
for (const button of submitButtons) {
button.disabled = total === 0;
}
if (total === 0) {
summary.textContent = "{{ t.reviews_selected_none }}";
return;
}
const parts = Array.from(statusCounts.entries())
.sort(([a], [b]) => a.localeCompare(b))
.map(([status, count]) => `${labels[status] || status}: ${count}`);
summary.textContent = `{{ t.reviews_selected_prefix }}: ${total} (${parts.join(", ")})`;
}
function setChecked(checkbox, checked) {
const id = checkbox.value;
const isSelected = selected.has(id);
checkbox.checked = checked;
if (isSelected === checked) {
return;
}
const status = checkbox.dataset.status || "unknown";
if (checked) {
selected.add(id);
setStatusCount(status, 1);
} else {
selected.delete(id);
setStatusCount(status, -1);
}
}
for (const checkbox of checkboxes) {
checkbox.addEventListener("change", () => {
setChecked(checkbox, checkbox.checked);
syncControls();
});
}
selectShownButton.addEventListener("click", () => {
for (const checkbox of checkboxes) {
setChecked(checkbox, true);
}
syncControls();
});
clearSelectionButton.addEventListener("click", () => {
for (const checkbox of checkboxes) {
setChecked(checkbox, false);
}
syncControls();
});
form.addEventListener("submit", (event) => {
syncControls();
if (selected.size === 0) {
event.preventDefault();
alert("{{ t.reviews_none_selected_confirm }}");
return;
}
const action = event.submitter ? event.submitter.value : "";
const message = action === "requeue"
? "{{ t.reviews_requeue_selected_confirm }}"
: "{{ t.reviews_delete_selected_confirm }}";
if (!confirm(message)) {
event.preventDefault();
}
});
syncControls();
})();
</script>
{% endblock content %}
-166
View File
@@ -1,166 +0,0 @@
{% extends "admin/layout.html" %}
{% block admin_title %}{{ t.nav_settings }}{% endblock admin_title %}
{% block content %}
<h1>{{ t.settings_heading }}</h1>
{% if saved %}
<p style="color: green; font-weight: bold; margin-bottom: 1rem;">{{ t.settings_saved }}</p>
{% endif %}
<form method="post" action="/admin/settings">
<h2>{{ t.settings_auth }}</h2>
<table>
<tr>
<th>{{ t.debug_field }}</th>
<th>{{ t.debug_value }}</th>
<th>{{ t.debug_source }}</th>
</tr>
<tr>
<td><label for="auth_password_enabled">{{ t.settings_password_login }}</label></td>
<td><input type="checkbox" name="auth_password_enabled" id="auth_password_enabled" value="on"{% if auth_password_enabled %} checked{% endif %}></td>
<td><span class="badge badge-{{ auth_password_enabled_source }}">{{ auth_password_enabled_source }}</span></td>
</tr>
<tr>
<td><label for="auth_sso_enabled">{{ t.settings_sso_login }}</label></td>
<td><input type="checkbox" name="auth_sso_enabled" id="auth_sso_enabled" value="on"{% if auth_sso_enabled %} checked{% endif %}></td>
<td><span class="badge badge-{{ auth_sso_enabled_source }}">{{ auth_sso_enabled_source }}</span></td>
</tr>
</table>
<h2>{{ t.settings_oidc }}</h2>
<p style="font-size:.85rem;color:#666;margin-bottom:.5rem;">{{ t.settings_oidc_help }}</p>
<p style="font-size:.85rem;color:#666;margin-bottom:1rem;">
<strong>{{ t.settings_oidc_callback }}:</strong>
<code id="oidc-callback-url"></code>
</p>
<script>document.getElementById('oidc-callback-url').textContent=location.origin+'/auth/oidc/callback';</script>
<table>
<tr>
<th>{{ t.debug_field }}</th>
<th>{{ t.debug_value }}</th>
<th>{{ t.debug_source }}</th>
</tr>
<tr>
<td><label for="oidc_button_text">{{ t.settings_oidc_button }}</label></td>
<td><input name="oidc_button_text" id="oidc_button_text" value="{{ oidc_button_text }}" style="width:100%"></td>
<td><span class="badge badge-{{ oidc_button_text_source }}">{{ oidc_button_text_source }}</span></td>
</tr>
<tr>
<td><label for="oidc_issuer">oidc_issuer</label><br><span style="font-size:.75rem;color:#999;">{{ t.settings_oidc_issuer_help }}</span></td>
<td><input name="oidc_issuer" id="oidc_issuer" value="{{ oidc_issuer }}" style="width:100%"></td>
<td><span class="badge badge-{{ oidc_issuer_source }}">{{ oidc_issuer_source }}</span></td>
</tr>
<tr>
<td><label for="oidc_client_id">oidc_client_id</label></td>
<td><input name="oidc_client_id" id="oidc_client_id" value="{{ oidc_client_id }}" style="width:100%"></td>
<td><span class="badge badge-{{ oidc_client_id_source }}">{{ oidc_client_id_source }}</span></td>
</tr>
<tr>
<td><label for="oidc_client_secret">oidc_client_secret</label></td>
<td><input name="oidc_client_secret" id="oidc_client_secret" type="password" value="{{ oidc_client_secret }}" style="width:100%"></td>
<td><span class="badge badge-{{ oidc_client_secret_source }}">{{ oidc_client_secret_source }}</span></td>
</tr>
<tr>
<td><label for="oidc_admin_groups">{{ t.settings_oidc_admin_groups }}</label><br><span style="font-size:.75rem;color:#999;">{{ t.settings_oidc_admin_groups_help }}</span></td>
<td><input name="oidc_admin_groups" id="oidc_admin_groups" value="{{ oidc_admin_groups }}" style="width:100%"></td>
<td><span class="badge badge-{{ oidc_admin_groups_source }}">{{ oidc_admin_groups_source }}</span></td>
</tr>
<tr>
<td><label for="oidc_user_groups">{{ t.settings_oidc_user_groups }}</label><br><span style="font-size:.75rem;color:#999;">{{ t.settings_oidc_user_groups_help }}</span></td>
<td><input name="oidc_user_groups" id="oidc_user_groups" value="{{ oidc_user_groups }}" style="width:100%"></td>
<td><span class="badge badge-{{ oidc_user_groups_source }}">{{ oidc_user_groups_source }}</span></td>
</tr>
</table>
<h2>{{ t.settings_api }}</h2>
<table>
<tr>
<th>{{ t.debug_field }}</th>
<th>{{ t.debug_value }}</th>
<th>{{ t.debug_source }}</th>
</tr>
<tr>
<td><label for="swagger_enabled">{{ t.settings_swagger }}</label><br><span style="font-size:.75rem;color:#999;">{{ t.settings_swagger_help }}</span></td>
<td><input type="checkbox" name="swagger_enabled" id="swagger_enabled" value="on"{% if swagger_enabled %} checked{% endif %}></td>
<td><span class="badge badge-{{ swagger_enabled_source }}">{{ swagger_enabled_source }}</span></td>
</tr>
<tr>
<td><label for="lastfm_api_key">{{ t.settings_lastfm_api_key }}</label><br><span style="font-size:.75rem;color:#999;">{{ t.settings_lastfm_api_key_help }}</span></td>
<td><input type="password" name="lastfm_api_key" id="lastfm_api_key" value="{{ lastfm_api_key }}"></td>
<td><span class="badge badge-{{ lastfm_api_key_source }}">{{ lastfm_api_key_source }}</span></td>
</tr>
<tr>
<td><label for="lastfm_shared_secret">{{ t.settings_lastfm_shared_secret }}</label><br><span style="font-size:.75rem;color:#999;">{{ t.settings_lastfm_shared_secret_help }}</span></td>
<td><input type="password" name="lastfm_shared_secret" id="lastfm_shared_secret" value="{{ lastfm_shared_secret }}"></td>
<td><span class="badge badge-{{ lastfm_shared_secret_source }}">{{ lastfm_shared_secret_source }}</span></td>
</tr>
</table>
<h2>{{ t.settings_agent }}</h2>
<p style="font-size:.85rem;color:#666;margin-bottom:.5rem;">{{ t.settings_agent_help }}</p>
<table>
<tr>
<th>{{ t.debug_field }}</th>
<th>{{ t.debug_value }}</th>
<th>{{ t.debug_source }}</th>
</tr>
<tr>
<td><label for="agent_enabled">{{ t.settings_agent_enabled }}</label></td>
<td><input type="checkbox" name="agent_enabled" id="agent_enabled" value="on"{% if agent_enabled %} checked{% endif %}></td>
<td><span class="badge badge-{{ agent_enabled_source }}">{{ agent_enabled_source }}</span></td>
</tr>
<tr>
<td><label for="agent_inbox_dir">{{ t.settings_agent_inbox }}</label></td>
<td><input name="agent_inbox_dir" id="agent_inbox_dir" value="{{ agent_inbox_dir }}" style="width:100%"></td>
<td><span class="badge badge-{{ agent_inbox_dir_source }}">{{ agent_inbox_dir_source }}</span></td>
</tr>
<tr>
<td><label for="agent_storage_dir">{{ t.settings_agent_storage }}</label></td>
<td><input name="agent_storage_dir" id="agent_storage_dir" value="{{ agent_storage_dir }}" style="width:100%"></td>
<td><span class="badge badge-{{ agent_storage_dir_source }}">{{ agent_storage_dir_source }}</span></td>
</tr>
<tr>
<td><label for="agent_llm_url">{{ t.settings_agent_llm_url }}</label></td>
<td><input name="agent_llm_url" id="agent_llm_url" value="{{ agent_llm_url }}" style="width:100%"></td>
<td><span class="badge badge-{{ agent_llm_url_source }}">{{ agent_llm_url_source }}</span></td>
</tr>
<tr>
<td><label for="agent_llm_model">{{ t.settings_agent_llm_model }}</label></td>
<td><input name="agent_llm_model" id="agent_llm_model" value="{{ agent_llm_model }}" style="width:100%"></td>
<td><span class="badge badge-{{ agent_llm_model_source }}">{{ agent_llm_model_source }}</span></td>
</tr>
<tr>
<td><label for="agent_llm_auth">{{ t.settings_agent_llm_auth }}</label></td>
<td><input name="agent_llm_auth" id="agent_llm_auth" type="password" value="{{ agent_llm_auth }}" style="width:100%"></td>
<td><span class="badge badge-{{ agent_llm_auth_source }}">{{ agent_llm_auth_source }}</span></td>
</tr>
<tr>
<td><label for="agent_confidence_threshold">{{ t.settings_agent_threshold }}</label></td>
<td><input name="agent_confidence_threshold" id="agent_confidence_threshold" value="{{ agent_confidence_threshold }}" style="width:6em"></td>
<td><span class="badge badge-{{ agent_confidence_threshold_source }}">{{ agent_confidence_threshold_source }}</span></td>
</tr>
<tr>
<td><label for="agent_context_limit">{{ t.settings_agent_context }}</label></td>
<td><input name="agent_context_limit" id="agent_context_limit" value="{{ agent_context_limit }}" style="width:6em"></td>
<td><span class="badge badge-{{ agent_context_limit_source }}">{{ agent_context_limit_source }}</span></td>
</tr>
<tr>
<td><label for="agent_concurrency">{{ t.settings_agent_concurrency }}</label></td>
<td><input name="agent_concurrency" id="agent_concurrency" value="{{ agent_concurrency }}" type="number" min="1" max="32" style="width:6em"></td>
<td><span class="badge badge-{{ agent_concurrency_source }}">{{ agent_concurrency_source }}</span></td>
</tr>
</table>
<h2>{{ t.settings_agent_status }}</h2>
<div hx-get="/admin/settings/probe" hx-trigger="load" hx-swap="innerHTML">
<p style="color:#999;">
<span class="htmx-indicator" style="display:inline;">
&#9696; {{ t.settings_agent_status_loading }}...
</span>
</p>
</div>
<button type="submit" style="margin-top: 1rem; padding: .5rem 1.5rem;">{{ t.settings_save }}</button>
</form>
{% endblock content %}
+7 -7
View File
@@ -5,13 +5,13 @@
{% block head_extra %}
<style>
* { margin: 0; padding: 0; box-sizing: border-box; }
body { font-family: system-ui, -apple-system, sans-serif; background: #f5f5f5; color: #333; display: flex; justify-content: center; align-items: center; min-height: 100vh; }
.setup-card { background: #fff; border-radius: 8px; box-shadow: 0 2px 8px rgba(0,0,0,.12); padding: 2rem 2.5rem; width: 100%; max-width: 400px; }
body { font-family: system-ui, -apple-system, sans-serif; background: #f5f5f5; color: #333; display: flex; justify-content: center; align-items: center; min-height: 100dvh; padding: max(16px, env(safe-area-inset-top)) 16px max(16px, env(safe-area-inset-bottom)); }
.setup-card { background: #fff; border-radius: 8px; box-shadow: 0 2px 8px rgba(0,0,0,.12); padding: clamp(20px, 5vw, 40px); width: 100%; max-width: 400px; }
.setup-card h1 { margin-bottom: 1.5rem; font-size: 1.5rem; text-align: center; }
.setup-card label { display: block; margin-bottom: .25rem; font-weight: 600; font-size: .9rem; }
.setup-card input[type="text"],
.setup-card input[type="password"] { width: 100%; padding: .5rem .7rem; margin-bottom: 1rem; border: 1px solid #ccc; border-radius: 4px; font-size: .95rem; }
.setup-card button { display: block; width: 100%; padding: .6rem; border: none; border-radius: 4px; font-size: 1rem; cursor: pointer; background: #1a1a2e; color: #fff; }
.setup-card input[type="password"] { width: 100%; padding: .5rem .7rem; margin-bottom: 1rem; border: 1px solid #ccc; border-radius: 4px; font-size: 16px; min-height: 44px; }
.setup-card button { display: block; width: 100%; padding: .6rem; min-height: 44px; border: none; border-radius: 4px; font-size: 1rem; cursor: pointer; background: #1a1a2e; color: #fff; }
.setup-card button:hover { background: #16213e; }
.setup-card .flash { color: #856404; background: #fff3cd; padding: .5rem .75rem; border-radius: 4px; margin-bottom: 1rem; text-align: center; font-size: .9rem; }
</style>
@@ -27,11 +27,11 @@
<form method="post" action="/admin/setup">
<label for="username">{{ t.setup_username }}</label>
<input type="text" name="username" id="username" required>
<input type="text" name="username" id="username" autocomplete="username" required>
<label for="password">{{ t.setup_password }}</label>
<input type="password" name="password" id="password" required>
<input type="password" name="password" id="password" autocomplete="new-password" required>
<label for="confirm_password">{{ t.setup_confirm }}</label>
<input type="password" name="confirm_password" id="confirm_password" required>
<input type="password" name="confirm_password" id="confirm_password" autocomplete="new-password" required>
<button type="submit">{{ t.setup_submit }}</button>
</form>
</div>
File diff suppressed because it is too large. Load diff
+120
View File
@@ -0,0 +1,120 @@
<script>
// Shared responsive shell state. Business data stays in adminV2().
function adminUI() {
return {
menuOpen: false,
isCompact: false,
isTaskStacked: false,
taskPane: 'list',
initUI() {
const compact = window.matchMedia('(max-width: 1023px)');
const stacked = window.matchMedia('(max-width: 1279px)');
const update = () => {
this.isCompact = compact.matches;
this.isTaskStacked = stacked.matches;
if (!this.isCompact) this.menuOpen = false;
};
update();
compact.addEventListener('change', update);
stacked.addEventListener('change', update);
this._uiCleanup = () => {
compact.removeEventListener('change', update);
stacked.removeEventListener('change', update);
};
this.$watch('activeView', () => {
this.closeMenu();
if (this.$refs?.main) this.$refs.main.scrollTop = 0;
});
},
destroy() {
this._uiCleanup?.();
if (this.poller) clearInterval(this.poller);
},
openMenu() { this.menuOpen = true; },
closeMenu() { this.menuOpen = false; },
showTaskPane(pane) {
this.taskPane = pane;
if (this.isTaskStacked) this.$nextTick(() => document.getElementById('task-tab-' + pane)?.focus());
},
taskTabKeydown(event) {
const panes = ['list', 'details', 'logs'];
const index = panes.indexOf(this.taskPane);
const keys = {ArrowRight:(index + 1) % 3, ArrowLeft:(index + 2) % 3, Home:0, End:2};
if (!(event.key in keys)) return;
event.preventDefault();
this.showTaskPane(panes[keys[event.key]]);
},
jumpToSettings(section) {
const target = document.getElementById('settings-' + section);
if (!target) return;
target.scrollIntoView({behavior:window.matchMedia('(prefers-reduced-motion: reduce)').matches ? 'instant' : 'smooth', block:'start'});
target.setAttribute('tabindex', '-1');
target.focus({preventScroll:true});
},
};
}
// All modal dialogs and the mobile navigation share one focus/scroll lifecycle.
// State is outside Alpine reactivity so opening a dialog does not retrigger x-effect.
const adminOverlay = (() => {
const states = new WeakMap();
const stack = [];
const frame = callback => window.requestAnimationFrame(callback);
const focusables = element => [...element.querySelectorAll('button:not(:disabled), a[href], input:not(:disabled), select:not(:disabled), textarea:not(:disabled), [tabindex="0"]')]
.filter(node => node.getClientRects().length && !node.closest('[inert]'));
function updateBackground() {
const top = stack.at(-1);
const main = document.getElementById('admin-main');
const nav = document.getElementById('admin-navigation');
if (main) { main.inert = !!top; main.classList.toggle('is-locked', !!top); }
if (nav) nav.inert = (top && top !== nav) || (nav.dataset.compact === 'true' && !nav.classList.contains('is-open'));
for (const entry of stack) entry.inert = entry !== top;
}
function sync(element, open) {
const previous = states.get(element);
if (previous?.open === open) return;
states.set(element, {open, returnFocus:open ? document.activeElement : previous?.returnFocus});
if (open) {
stack.push(element);
frame(() => {
if (stack.at(-1) !== element) return;
updateBackground();
const dialog = element.querySelector('[role="dialog"]') || element;
dialog.focus({preventScroll:true});
});
} else {
const index = stack.indexOf(element);
if (index !== -1) stack.splice(index, 1);
element.inert = element.id !== 'admin-navigation';
frame(() => {
updateBackground();
const top = stack.at(-1);
if (top) {
if (!top.contains(document.activeElement)) (top.querySelector('[role="dialog"]') || top).focus({preventScroll:true});
} else if (previous?.open) {
const target = previous.returnFocus;
if (target?.isConnected && target.getClientRects().length && !target.closest('[inert]')) target.focus({preventScroll:true});
else document.querySelector('.menu-toggle')?.focus({preventScroll:true});
}
});
}
}
function keydown(event, element) {
if (stack.at(-1) !== element) return;
if (event.key === 'Escape' && !event.defaultPrevented) {
const close = element.querySelector('[data-dialog-close]');
if (close && !close.disabled) { event.preventDefault(); event.stopPropagation(); close.click(); }
} else if (event.key === 'Tab') {
const nodes = focusables(element);
const first = nodes[0], last = nodes.at(-1);
if (!first) { event.preventDefault(); return; }
if (event.shiftKey && (document.activeElement === first || !nodes.includes(document.activeElement))) {
event.preventDefault(); last.focus();
} else if (!event.shiftKey && (document.activeElement === last || !nodes.includes(document.activeElement))) {
event.preventDefault(); first.focus();
}
}
}
return {sync, keydown};
})();
</script>
-40
View File
@@ -1,40 +0,0 @@
{% extends "admin/layout.html" %}
{% block admin_title %}{% if is_edit %}{{ t.users_edit_heading }}{% else %}{{ t.users_new_heading }}{% endif %}{% endblock admin_title %}
{% block content %}
<h1>{% if is_edit %}{{ t.users_edit_heading }}{% else %}{{ t.users_new_heading }}{% endif %}</h1>
<form method="post" action="{% if is_edit %}/admin/users/{{ form_user_id }}/edit{% else %}/admin/users/new{% endif %}">
<table>
<tr>
<td><label for="username">{{ t.users_username }}</label></td>
<td><input name="username" id="username" value="{{ form_username }}" required style="width:100%"></td>
</tr>
<tr>
<td><label for="email">{{ t.users_email }}</label></td>
<td><input name="email" id="email" type="email" value="{{ form_email }}" style="width:100%"></td>
</tr>
<tr>
<td><label for="display_name">{{ t.users_display_name }}</label></td>
<td><input name="display_name" id="display_name" value="{{ form_display_name }}" style="width:100%"></td>
</tr>
<tr>
<td><label for="password">{{ t.login_password }}</label></td>
<td>
<input name="password" id="password" type="password"{% if !is_edit %} required{% endif %} style="width:100%">
{% if is_edit %}<br><small style="color:#888;">{{ t.users_password_hint }}</small>{% endif %}
</td>
</tr>
<tr>
<td><label for="role">{{ t.users_role }}</label></td>
<td>
<select name="role" id="role" style="width:100%; padding:.4rem;">
<option value="user"{% if form_role == "user" %} selected{% endif %}>user</option>
<option value="admin"{% if form_role == "admin" %} selected{% endif %}>admin</option>
</select>
</td>
</tr>
</table>
<button type="submit" style="margin-top: 1rem; padding: .5rem 1.5rem;">{{ t.settings_save }}</button>
</form>
{% endblock content %}
-37
View File
@@ -1,37 +0,0 @@
{% extends "admin/layout.html" %}
{% block admin_title %}{{ t.nav_users }}{% endblock admin_title %}
{% block content %}
<h1>{{ t.users_heading }}</h1>
<p style="margin-bottom: 1rem;">
<a href="/admin/users/new" style="display:inline-block; padding:.5rem 1rem; background:#1a1a2e; color:#fff; text-decoration:none; border-radius:4px;">{{ t.users_add }}</a>
</p>
<table>
<tr>
<th>{{ t.users_username }}</th>
<th>{{ t.users_email }}</th>
<th>{{ t.users_display_name }}</th>
<th>{{ t.users_role }}</th>
<th>{{ t.users_active }}</th>
<th>{{ t.users_actions }}</th>
</tr>
{% for u in users %}
<tr>
<td>{{ u.username_str() }}</td>
<td>{{ u.email_str() }}</td>
<td>{{ u.display_name_str() }}</td>
<td>{{ u.role_str() }}</td>
<td>{{ u.is_active() }}</td>
<td>
<a href="/admin/users/{{ u.id_val() }}/edit">{{ t.users_edit }}</a>
&nbsp;|&nbsp;
<form method="post" action="/admin/users/{{ u.id_val() }}/delete" style="display:inline;" onsubmit="return confirm('{{ t.users_delete_confirm }}')">
<button type="submit" style="background:none; border:none; color:#c00; cursor:pointer; padding:0; text-decoration:underline;">{{ t.users_delete }}</button>
</form>
</td>
</tr>
{% endfor %}
</table>
{% endblock content %}
+544 -2230
View File
File diff suppressed because it is too large. Load diff
+23
View File
@@ -0,0 +1,23 @@
{% extends "base.html" %}
{% block title %}{{ t.approval_heading }} | {{ t.site_name }}{% endblock title %}
{% block head_extra %}
<style>
body { margin:0; min-height:100vh; display:grid; place-items:center; background:#121212; color:#eee; font-family:system-ui,sans-serif; }
.approval-card { max-width:440px; margin:24px; padding:36px; border:1px solid #333; border-radius:18px; background:#1b1b1b; }
h1 { font-size:24px; } p { line-height:1.6; color:#bbb; } a { color:#b7d79f; }
</style>
{% endblock head_extra %}
{% block body %}
<main class="approval-card"><h1>{{ t.approval_heading }}</h1><p>{{ t.approval_message }}</p><a href="/logout">{{ t.player_log_out }}</a></main>
<script>
setInterval(async () => {
try {
const response = await fetch('/auth/status', {cache:'no-store'});
if (!response.ok) return;
const {status} = await response.json();
if (status === 'active') location.replace('/');
else if (status === 'anonymous') location.replace('/login');
} catch {}
}, 5000);
</script>
{% endblock body %}
+26 -1
View File
@@ -495,6 +495,18 @@
</button>
</div>
</div>
<div class="youtube-preview-destination">
<label for="torrent-target-playlist">{{ t.player_import_destination }}</label>
<div class="youtube-preview-destination-fields" :class="{ creating: $store.torrents.torrentPlaylistChoice === '__new__' }">
<select id="torrent-target-playlist" x-model="$store.torrents.torrentPlaylistChoice" @change="$store.torrents.importPlaylistChoiceChanged('torrent')" :disabled="$store.torrents.torrentDestinationLocked()">
<option value="">{{ t.player_youtube_no_destination }}</option>
<template x-for="playlist in $store.torrents.youtubeOwnedPlaylists()" :key="playlist.id"><option :value="String(playlist.id)" x-text="playlist.title"></option></template>
<option value="__new__">{{ t.player_youtube_create_playlist }}</option>
</select>
<template x-if="$store.torrents.torrentPlaylistChoice === '__new__'"><input type="text" maxlength="255" autocomplete="off" x-model="$store.torrents.torrentNewPlaylistTitle" placeholder="{{ t.player_youtube_new_playlist_name }}" :disabled="$store.torrents.torrentDestinationLocked()"></template>
</div>
<p>{{ t.player_import_destination_hint }}</p>
</div>
<div class="torrent-tree-toolbar">
<div class="torrent-selected-summary"
x-text="$store.torrents.selected.size + ' {{ t.player_selected }} - ' + $store.torrents.bytes($store.torrents.selectedBytes())"></div>
@@ -594,6 +606,18 @@
<small>{{ t.player_audio_folder_hint }}</small>
</div>
<div class="youtube-preview-destination" x-show="$store.torrents.localFiles.length > 0">
<label for="local-target-playlist">{{ t.player_import_destination }}</label>
<div class="youtube-preview-destination-fields" :class="{ creating: $store.torrents.localPlaylistChoice === '__new__' }">
<select id="local-target-playlist" x-model="$store.torrents.localPlaylistChoice" @change="$store.torrents.importPlaylistChoiceChanged('local')" :disabled="$store.torrents.localFilesUploading || $store.torrents.localPlaylistLocked">
<option value="">{{ t.player_youtube_no_destination }}</option>
<template x-for="playlist in $store.torrents.youtubeOwnedPlaylists()" :key="playlist.id"><option :value="String(playlist.id)" x-text="playlist.title"></option></template>
<option value="__new__">{{ t.player_youtube_create_playlist }}</option>
</select>
<template x-if="$store.torrents.localPlaylistChoice === '__new__'"><input type="text" maxlength="255" autocomplete="off" x-model="$store.torrents.localNewPlaylistTitle" placeholder="{{ t.player_youtube_new_playlist_name }}" :disabled="$store.torrents.localFilesUploading || $store.torrents.localPlaylistLocked"></template>
</div>
<p>{{ t.player_import_destination_hint }}</p>
</div>
<div class="file-upload-selection" x-show="$store.torrents.localFiles.length > 0">
<span x-text="$store.torrents.localUploadSummary()"></span>
<div>
@@ -602,7 +626,7 @@
:disabled="$store.torrents.localFilesUploading">{{ t.player_cancel }}</button>
<button type="button" class="modal-btn modal-btn-primary"
@click="$store.torrents.uploadLocalFiles()"
:disabled="$store.torrents.localFilesUploading">{{ t.player_upload_selected_files }}</button>
:disabled="$store.torrents.localFilesUploading || !$store.torrents.importDestinationValid('local')">{{ t.player_upload_selected_files }}</button>
</div>
</div>
@@ -635,6 +659,7 @@
<div class="file-upload-history-title" x-text="item.filename"></div>
<div class="file-upload-history-meta"
x-text="$store.torrents.bytes(item.size_bytes) + ' · ' + $store.torrents.formatUploadDate(item.created_at)"></div>
<div class="file-upload-history-meta" x-show="item.target_playlist_id" x-text="T.youtubePlaylist + ': ' + ($store.torrents.youtubePlaylistTitle(item.target_playlist_id) || '#' + item.target_playlist_id)"></div>
<p class="youtube-item-error" x-show="item.error" x-text="item.error"></p>
</div>
<span class="torrent-status-badge"
+197 -175
View File
@@ -1,9 +1,11 @@
<script defer src="https://cdn.jsdelivr.net/npm/alpinejs@3/dist/cdn.min.js"></script>
<script>
const GUEST = {{ guest }};
const SHARE_TOKEN = "{{ share_token }}";
// Handle expired sessions centrally, including background player requests.
let loginRedirectStarted = false;
function redirectOnUnauthorized(status) {
if (status !== 401 || loginRedirectStarted) return;
if (GUEST || status !== 401 || loginRedirectStarted) return;
loginRedirectStarted = true;
window.location.replace('/login');
}
@@ -60,8 +62,8 @@ const T = {
lastfmDisconnectConfirm: "{{ t.player_lastfm_disconnect_confirm }}",
lastfmConnectFailed: "{{ t.player_lastfm_connect_failed }}",
lastfmDisconnectFailed: "{{ t.player_lastfm_disconnect_failed }}",
startRadio: "{{ t.player_start_radio }}",
radioFailed: "{{ t.player_radio_failed }}",
download: "{{ t.track_download }}",
shareUnavailable: "{{ t.share_unavailable }}",
searchSimilarTo: "{{ t.player_search_similar_to }}",
findSimilar: "{{ t.player_find_similar }}",
similarityFailed: "{{ t.player_similarity_failed }}",
@@ -342,6 +344,7 @@ document.addEventListener('alpine:init', () => {
}
},
navigate(link) {
if (GUEST) return;
if (!link || !link.id) return;
this.close();
const library = Alpine.store('library');
@@ -388,35 +391,39 @@ document.addEventListener('alpine:init', () => {
return copied;
},
copyTrack(track, trigger = null) {
async copyTrack(track, trigger = null) {
const id = Number(track?.id || track);
if (!id) return;
this.copyUrl(`/share/track/${id}`, trigger);
if (id) return this.copyTracks([{id}], track?.title || T.sharedPlaylist, trigger);
},
async copyQueue(trigger = null) {
const queue = Alpine.store('queue');
return this.copyTracks(queue?.tracks || [], T.sharedPlaylist, trigger);
return this.copyTracks(Alpine.store('queue')?.tracks || [], T.sharedPlaylist, trigger);
},
async copyRelease(release, trigger = null) {
const id = Number(release?.id || release || 0);
if (!id) return;
return this.copyUrl(`/share/release/${id}`, trigger);
try {
const id = Number(release?.id || release || 0);
if (!id) return;
const response = await fetch(`/api/player/releases/${id}`);
if (!response.ok) throw new Error('release load failed');
const data = await response.json();
return this.copyTracks(data.tracks || [], data.title || T.sharedPlaylist, trigger);
} catch { this.flashTrigger(trigger, false); }
},
async copyTracks(tracks, title = T.sharedPlaylist, trigger = null) {
if (GUEST) return this.copyUrl(`/share/${SHARE_TOKEN}`, trigger);
const trackIds = (tracks || []).map(track => Number(track.id)).filter(Boolean);
if (!trackIds.length) return;
try {
const res = await fetch('/api/player/share-playlist', {
const res = await fetch('/api/player/shares', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ track_ids: trackIds, title }),
});
if (!res.ok) throw new Error('share failed');
const data = await res.json();
await this.copyUrl(data.url || `/share/playlist/${data.token}`, trigger);
await this.copyUrl(data.url || `/share/${data.token}`, trigger);
} catch (err) {
this.flashTrigger(trigger, false);
console.warn(err);
@@ -468,84 +475,24 @@ document.addEventListener('alpine:init', () => {
},
async handleInitialShareLinks() {
if (this._handledInitialLink) return;
if (this._handledInitialLink || !SHARE_TOKEN) return;
this._handledInitialLink = true;
const params = new URLSearchParams(window.location.search);
const trackId = Number(params.get('track') || 0);
const releaseId = Number(params.get('release') || 0);
const playlistToken = (params.get('playlist_share') || '').trim();
if (trackId > 0) {
await this.openSharedTrack(trackId);
this._clearShareQuery();
} else if (releaseId > 0) {
await this.openSharedRelease(releaseId);
this._clearShareQuery();
} else if (playlistToken) {
await this.openSharedPlaylist(playlistToken);
this._clearShareQuery();
}
},
async openSharedTrack(trackId) {
try {
const res = await fetch('/api/player/tracks-by-ids', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ ids: [Number(trackId)] }),
});
if (!res.ok) throw new Error('track load failed');
const tracks = await res.json();
const track = Array.isArray(tracks) ? tracks[0] : null;
if (!track) return;
this.markSharedTrack(track.id);
if (track.release_id) {
await Alpine.store('library').openRelease(track.release_id, { focusSharedTrackId: track.id });
}
const queue = Alpine.store('queue');
queue.tracks = [track];
queue.currentIndex = 0;
Alpine.store('player')._playLocal(track, { paused: true });
this.focusSharedTrack(track.id);
} catch (err) {
console.warn(err);
}
},
async openSharedRelease(releaseId) {
const id = Number(releaseId || 0);
if (!id) return;
this.markSharedTrack(null);
await Alpine.store('library').openRelease(id);
},
async openSharedPlaylist(token) {
try {
const res = await fetch(`/api/player/share-playlist/${encodeURIComponent(token)}`);
if (!res.ok) throw new Error('playlist load failed');
const data = await res.json();
const tracks = Array.isArray(data.tracks) ? data.tracks : [];
if (!tracks.length) return;
const response = await fetch(`/api/player/shares/${SHARE_TOKEN}`);
if (!response.ok) throw new Error('share unavailable');
const data = await response.json();
const tracks = data.tracks || [];
Alpine.store('library').showSharedPlaylist(data);
if (!tracks.length) throw new Error('share empty');
const queue = Alpine.store('queue');
queue.tracks = tracks;
queue.currentIndex = 0;
Alpine.store('player')._playLocal(tracks[0], { paused: true });
Alpine.store('library').showSharedPlaylist(data);
} catch (err) {
console.warn(err);
Alpine.store('player')._playLocal(tracks[0], {paused:true});
} catch {
Alpine.store('library').showSharedPlaylist({title:T.shareUnavailable, tracks:[]});
}
},
_clearShareQuery() {
const url = new URL(window.location.href);
url.searchParams.delete('track');
url.searchParams.delete('release');
url.searchParams.delete('playlist_share');
const query = url.searchParams.toString();
const next = `${url.pathname}${query ? '?' + query : ''}${window.location.hash}`;
history.replaceState({}, '', next);
},
});
// -----------------------------------------------------------------------
@@ -553,17 +500,33 @@ document.addEventListener('alpine:init', () => {
// -----------------------------------------------------------------------
Alpine.store('user', {
profile: null,
accessStatus: "anonymous",
menuOpen: false,
settingsOpen: false,
lastfm: { configured: false, connected: false, username: null, reauth_required: false, last_error: null },
lastfmBusy: false,
init() {
if (GUEST) {
this.checkAccess();
setInterval(() => this.checkAccess(), 5000);
return;
}
this.cleanLastfmQuery();
this.load();
this.loadLastfm();
},
async checkAccess() {
try {
const response = await fetch('/auth/status', {cache:'no-store'});
if (!response.ok) return;
const data = await response.json();
this.accessStatus = data.status;
if (data.status === 'active') window.location.reload();
} catch {}
},
cleanLastfmQuery() {
const url = new URL(window.location.href);
if (!url.searchParams.has('lastfm')) return;
@@ -785,6 +748,7 @@ document.addEventListener('alpine:init', () => {
progress: 0,
_saveTimer: null,
_historyRecorded: false,
_historyTrack: null,
_nowPlayingSent: false,
_playbackStartedAt: null,
_listenId: null,
@@ -798,11 +762,7 @@ document.addEventListener('alpine:init', () => {
_prefetchedQueueKey: null,
_baseDocumentTitle: '',
_hasInitialShareLink() {
const params = new URLSearchParams(window.location.search);
return Number(params.get('track') || 0) > 0
|| (params.get('playlist_share') || '').trim().length > 0;
},
_hasInitialShareLink() { return !!SHARE_TOKEN; },
init() {
audio.volume = this.volume;
@@ -836,6 +796,7 @@ document.addEventListener('alpine:init', () => {
this._sendNowPlaying();
});
audio.addEventListener('pause', () => {
this._trackListenedDelta();
this.isPlaying = false;
this._lastAudioTime = audio.currentTime || 0;
});
@@ -858,8 +819,19 @@ document.addEventListener('alpine:init', () => {
}
// Save state on page unload
window.addEventListener('beforeunload', () => {
if (this._isLocalPlaybackDevice()) this._saveStateSync();
window.addEventListener('pagehide', () => {
if (this._isLocalPlaybackDevice()) {
this._saveStateSync();
this._recordHistory('stopped', true);
}
});
window.addEventListener('pageshow', (event) => {
if (event.persisted && this._historyRecorded) {
this._historyRecorded = false;
this._resetPlaybackTracking();
this._lastAudioTime = audio.currentTime || 0;
if (this.isPlaying) this._playbackStartedAt = Math.floor(Date.now() / 1000);
}
});
},
@@ -928,7 +900,9 @@ document.addEventListener('alpine:init', () => {
},
_playLocal(track, options = {}) {
this._recordHistory('replaced');
this.currentTrack = track;
this._historyTrack = track;
this._prefetchedQueueKey = null;
Alpine.store('queue')?.syncCurrentIndexToTrack(track);
this._localSourceTrackId = track.id;
@@ -1060,7 +1034,7 @@ document.addEventListener('alpine:init', () => {
const queue = Alpine.store('queue');
if (queue.tracks.length === 0) return;
this._recordHistoryIfListenThresholdReached();
this._recordHistory('skipped');
let nextIdx;
if (this.repeatMode === 'one') {
@@ -1432,6 +1406,7 @@ document.addEventListener('alpine:init', () => {
},
_saveState() {
if (GUEST) return;
const queue = Alpine.store('queue');
if (!this.currentTrack && queue.tracks.length === 0) return;
const state = this._buildStatePayload();
@@ -1443,6 +1418,7 @@ document.addEventListener('alpine:init', () => {
},
_saveStateSync() {
if (GUEST) return;
const queue = Alpine.store('queue');
if (!this.currentTrack && queue.tracks.length === 0) return;
const state = this._buildStatePayload();
@@ -1451,6 +1427,7 @@ document.addEventListener('alpine:init', () => {
},
async _restoreState() {
if (GUEST) return;
try {
const res = await fetch('/api/player/state');
if (!res.ok) return;
@@ -1481,6 +1458,7 @@ document.addEventListener('alpine:init', () => {
: tracks[idx];
if (currentTrack) {
this.currentTrack = currentTrack;
this._historyTrack = currentTrack;
queue.syncCurrentIndexToTrack(currentTrack);
this._localSourceTrackId = currentTrack.id;
this._historyRecorded = false;
@@ -1504,38 +1482,41 @@ document.addEventListener('alpine:init', () => {
} catch {}
},
_recordHistory(endedReason) {
if (this._historyRecorded || !this.currentTrack) return;
if (!Number.isInteger(Number(this.currentTrack.id)) || this.currentTrack.federated_cache) {
return;
}
this._historyRecorded = true;
_recordHistory(endedReason, unloading = false) {
if (GUEST) return;
const track = this._historyTrack;
if (this._historyRecorded || !track || !this._playbackStartedAt) return;
if (!Number.isInteger(Number(track.id)) || track.federated_cache) return;
this._trackListenedDelta();
const completed = endedReason === 'finished';
const listenedSeconds = this._historyListenedSeconds(completed);
fetch('/api/player/history', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
track_id: this.currentTrack.id,
listen_id: this._listenId,
started_at: this._playbackStartedAt,
duration_listened: listenedSeconds,
completed: completed,
ended_reason: endedReason,
}),
}).catch(() => {});
},
_recordHistoryIfListenThresholdReached() {
if (this._historyRecorded || !this.currentTrack) return false;
this._trackListenedDelta();
const duration = this._trackDuration();
if (duration <= 0) return false;
const listened = Math.floor(Number(this._listenedSeconds || 0));
const threshold = Math.ceil(duration / 2);
if (threshold <= 0 || listened < threshold) return false;
this._recordHistory('unknown');
return true;
if (!completed && listenedSeconds < 5) return;
const listenId = this._listenId;
const body = JSON.stringify({
track_id: track.id,
listen_id: listenId,
started_at: this._playbackStartedAt,
duration_listened: listenedSeconds,
completed,
ended_reason: endedReason,
});
this._historyRecorded = true;
if (unloading && navigator.sendBeacon('/api/player/history', new Blob([body], {type:'application/json'}))) return;
// Retry the captured event, never the next track. The server deduplicates by listen_id.
const send = async () => {
for (let attempt = 0; attempt < 3; attempt++) {
try {
const response = await fetch('/api/player/history', {
method: 'POST', headers: {'Content-Type':'application/json'}, body, keepalive: true,
});
if (response.ok) return;
if (response.status >= 400 && response.status < 500) break;
} catch (_) {}
if (attempt < 2) await new Promise(resolve => setTimeout(resolve, 500 * (attempt + 1)));
}
if (this._listenId === listenId) this._historyRecorded = false;
};
send();
},
_resetPlaybackTracking() {
@@ -1580,19 +1561,12 @@ document.addEventListener('alpine:init', () => {
},
_historyListenedSeconds(completed) {
const duration = this._trackDuration();
const listened = Number(this._listenedSeconds || 0);
const finalGrace = completed ? 1 : 0;
const precise = Math.floor(listened + finalGrace);
if (precise > 0) return precise;
const current = Number(audio.currentTime || this.currentTime || 0);
if (duration > 0 && Number.isFinite(current)) {
return Math.floor(Math.min(current, duration));
}
return Math.floor(current || 0);
// Seeking is not listening time. Allow rounding grace only at a natural finish.
return Math.max(0, Math.floor(Number(this._listenedSeconds || 0) + (completed ? 1 : 0)));
},
_sendNowPlaying() {
if (GUEST) return;
if (this._nowPlayingSent || !this.currentTrack) return;
if (!Number.isInteger(Number(this.currentTrack.id)) || this.currentTrack.federated_cache) {
return;
@@ -1642,6 +1616,7 @@ document.addEventListener('alpine:init', () => {
_lastPlaybackState: null,
init() {
if (GUEST) return;
this.id = this._ensureId();
this.currentJamId = sessionStorage.getItem('furu_player_jam_id') || null;
this.heartbeat();
@@ -1858,6 +1833,7 @@ document.addEventListener('alpine:init', () => {
},
isActive() {
if (GUEST) return true;
if (this.isControllingRemoteJam()) return false;
return !this.activeDeviceId || this.activeDeviceId === this.id;
},
@@ -2625,6 +2601,10 @@ document.addEventListener('alpine:init', () => {
_hashNav: false, // guard against circular hash updates
init() {
if (GUEST) {
this.$nextTick(() => Alpine.store('sharing').handleInitialShareLinks());
return;
}
this._setupScroll();
this.loadFederationLikes();
window.addEventListener('furumi:track-availability', event => {
@@ -2658,6 +2638,7 @@ document.addEventListener('alpine:init', () => {
},
_navigateFromHash(options = {}) {
if (GUEST) return;
if (this._hashNav) return;
const hash = location.hash || '#artists';
const match = hash.match(/^#(\w+)(?:\/([-]?\d+))?(?:\?(.*))?$/);
@@ -2768,6 +2749,7 @@ document.addEventListener('alpine:init', () => {
},
goArtists(options = {}) {
if (GUEST) return;
this._beginNavigation('#artists', options);
if (this.artistFilter !== 'all' || this.artistsPage === 0) {
this._resetArtistList('all');
@@ -2785,6 +2767,7 @@ document.addEventListener('alpine:init', () => {
},
goMyUploads(options = {}) {
if (GUEST) return;
this._beginNavigation('#uploads', options);
if (this.artistFilter !== 'uploads' || this.artistsPage === 0) {
this._resetArtistList('uploads');
@@ -2844,6 +2827,7 @@ document.addEventListener('alpine:init', () => {
},
async openArtist(id, options = {}) {
if (GUEST) return;
this.stopArtistFederation();
this._beginNavigation('#artist/' + id, options);
this.searchQuery = '';
@@ -3135,26 +3119,22 @@ document.addEventListener('alpine:init', () => {
return `${T.lastfmRating}: ${Math.round(value)}\n${this.trackInfo(track)}`;
},
async startRadio(kind, id) {
if (!kind || !id) return;
try {
const res = await fetch(`/api/player/radio/${encodeURIComponent(kind)}/${encodeURIComponent(id)}`);
if (!res.ok) throw new Error('radio failed');
const tracks = await res.json();
if (!Array.isArray(tracks) || tracks.length === 0) throw new Error('radio empty');
Alpine.store('queue').playRelease(tracks, 0);
Alpine.store('info').close();
} catch (err) {
console.warn(err);
window.alert(T.radioFailed);
}
downloadTrack(track) {
if (!track?.id) return;
const link = document.createElement('a');
link.href = GUEST ? `/api/player/shares/${SHARE_TOKEN}/download/${track.id}` : `/api/player/download/${track.id}`;
link.download = '';
document.body.appendChild(link);
link.click();
link.remove();
},
openTrackInfo(track) {
Alpine.store('info').openRows(T.trackInfoTitle, this.trackInfoRows(track), [
{ label: T.startRadio, run: () => this.startRadio('track', track?.id) },
{ label: T.findSimilar, run: () => this.searchSimilar(track) },
]);
const rows = this.trackInfoRows(track).map(row => GUEST && row.links
? {...row, value: row.links.map(link => link.label).join(', '), links: null} : row);
const actions = [{label:T.download, run:() => this.downloadTrack(track)}];
if (!GUEST) actions.push({label:T.findSimilar, run:() => this.searchSimilar(track)});
Alpine.store('info').openRows(T.trackInfoTitle, rows, actions);
},
uploadersInfo(uploaders) {
@@ -3178,9 +3158,7 @@ document.addEventListener('alpine:init', () => {
},
openReleaseInfo(release) {
Alpine.store('info').openRows(T.releaseInfoTitle, this.releaseInfoRows(release), [
{ label: T.startRadio, run: () => this.startRadio('release', release?.id) },
]);
Alpine.store('info').openRows(T.releaseInfoTitle, this.releaseInfoRows(release));
},
infoLinks(items, type) {
@@ -3279,6 +3257,7 @@ document.addEventListener('alpine:init', () => {
},
async openRelease(id, options = {}) {
if (GUEST) return;
this.stopReleaseFederation();
this._beginNavigation('#release/' + id, options);
this.searchQuery = '';
@@ -3395,6 +3374,7 @@ document.addEventListener('alpine:init', () => {
},
async openPlaylist(id, options = {}) {
if (GUEST) return;
this._beginNavigation('#playlist/' + id, options);
Alpine.store('playlists')?.stopEdit?.();
this.view = 'playlist_detail';
@@ -3481,6 +3461,7 @@ document.addEventListener('alpine:init', () => {
},
async search(query, options = {}) {
if (GUEST) return;
const q = (query || '').trim();
if (!q) {
this.clearSearch();
@@ -3508,6 +3489,7 @@ document.addEventListener('alpine:init', () => {
},
async searchSimilar(trackOrId, options = {}) {
if (GUEST) return;
const id = Number(typeof trackOrId === 'object' ? trackOrId?.id : trackOrId);
if (!Number.isInteger(id) || id <= 0) return;
const track = typeof trackOrId === 'object' ? trackOrId : null;
@@ -4484,6 +4466,7 @@ document.addEventListener('alpine:init', () => {
_set: new Set(),
init() {
if (GUEST) return;
this.reload();
},
@@ -4553,6 +4536,7 @@ document.addEventListener('alpine:init', () => {
artists: [],
init() {
if (GUEST) return;
this.reload();
},
@@ -4632,6 +4616,12 @@ document.addEventListener('alpine:init', () => {
youtubeUrl: '',
youtubePreview: null,
youtubePreviewSelected: new Set(),
torrentPlaylistChoice: '',
torrentNewPlaylistTitle: '',
localPlaylistChoice: '',
localNewPlaylistTitle: '',
localPlaylistLocked: false,
localTargetPlaylistId: null,
youtubePlaylistChoice: '',
youtubeNewPlaylistTitle: '',
youtubePlaylistSyncKey: '',
@@ -4704,6 +4694,7 @@ document.addEventListener('alpine:init', () => {
open() {
if (!this.downloadsEnabled) return;
this.modal = true;
Alpine.store('playlists')?.reload?.();
this.message = '';
this.error = false;
if (this.sourceTab === 'youtube') this.loadYoutubeJobs();
@@ -4874,34 +4865,41 @@ document.addEventListener('alpine:init', () => {
return this.youtubeOwnedPlaylists().find(playlist => Number(playlist.id) === wanted)?.title || '';
},
async resolveYoutubeTargetPlaylist() {
if (this.youtubePlaylistChoice !== '__new__') {
const playlistId = Number(this.youtubePlaylistChoice || 0);
importPlaylistChoiceChanged(kind) {
const choice = kind + 'PlaylistChoice';
const title = kind + 'NewPlaylistTitle';
if (this[choice] !== '__new__' || String(this[title] || '').trim()) return;
const file = this.localFiles[0];
const suggestion = kind === 'torrent' ? this.previewData?.name
: (file?.webkitRelativePath?.split('/').slice(0, -1).join('/') || (this.localFiles.length === 1 ? file?.name?.replace(/\.[^.]+$/, '') : ''));
this[title] = String(suggestion || '').slice(0,255);
},
importDestinationValid(kind) {
return this[kind + 'PlaylistChoice'] !== '__new__' || String(this[kind + 'NewPlaylistTitle'] || '').trim().length > 0;
},
torrentDestinationLocked() {
return this.loading || (this.currentJob && !['preview', 'resolving'].includes(this.currentJob.status));
},
async resolveYoutubeTargetPlaylist() { return this.resolveImportTargetPlaylist('youtube'); },
async resolveImportTargetPlaylist(kind) {
const choice = kind + 'PlaylistChoice';
const titleKey = kind + 'NewPlaylistTitle';
if (this[choice] !== '__new__') {
const playlistId = Number(this[choice] || 0);
return playlistId > 0 ? playlistId : null;
}
const title = String(this.youtubeNewPlaylistTitle || '').trim();
const title = String(this[titleKey] || '').trim();
if (!title) throw new Error(T.youtubePlaylistCreateFailed);
const res = await fetch('/api/player/playlists', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ title }),
method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify({title}),
});
const playlist = await res.json().catch(() => null);
if (!res.ok || Number(playlist?.id || 0) <= 0) {
throw new Error(playlist?.error || T.youtubePlaylistCreateFailed);
}
// Switch to the created playlist before starting the job. If the
// YouTube request fails, retrying will reuse it instead of creating
// another playlist with the same name.
this.youtubePlaylistChoice = String(playlist.id);
if (!res.ok || Number(playlist?.id || 0) <= 0) throw new Error(playlist?.error || T.youtubePlaylistCreateFailed);
// Retrying an upload reuses this playlist, including after a failed start request.
this[choice] = String(playlist.id);
const playlists = Alpine.store('playlists');
if (playlists) {
playlists.list = [
...(playlists.list || []).filter(item => Number(item.id) !== Number(playlist.id)),
playlist,
];
playlists.list = [...(playlists.list || []).filter(item => Number(item.id) !== Number(playlist.id)), playlist];
await playlists.reload();
}
return Number(playlist.id);
@@ -5325,6 +5323,7 @@ document.addEventListener('alpine:init', () => {
actionButtonDisabled() {
return this.loading
|| (!this.isCurrentDownloading() && !this.importDestinationValid('torrent'))
|| this.isCurrentCompletedLocked()
|| this.normalizedStatus(this.currentJob) === 'resolving'
|| !this.previewData
@@ -5341,7 +5340,8 @@ document.addEventListener('alpine:init', () => {
sessionMeta(job) {
if (!job) return '';
const size = this.bytes(job.selected_size || job.total_size);
return this.progressValue(job).toFixed(1) + '% - ' + size;
const title = this.youtubePlaylistTitle(job.target_playlist_id);
return this.progressValue(job).toFixed(1) + '% - ' + size + (title ? ' · ' + T.youtubePlaylist + ': ' + title : '');
},
async loadAgentStatus() {
@@ -5878,6 +5878,8 @@ document.addEventListener('alpine:init', () => {
this.uploadProgressText = '';
this.previewData = preview;
this.currentJob = job;
this.torrentPlaylistChoice = job?.target_playlist_id ? String(job.target_playlist_id) : '';
this.torrentNewPlaylistTitle = '';
const selected = Array.isArray(data.selected_files) && data.selected_files.length
? data.selected_files
: (preview.files || []).filter(f => f.selected).map(f => f.index);
@@ -5893,6 +5895,7 @@ 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 : [];
if (this.sessions.some(job => job.target_playlist_id)) Alpine.store('playlists')?.reload?.();
this._syncCurrentJobFromSessions();
await this._refreshResolvedSelection();
} catch (err) {
@@ -5982,6 +5985,10 @@ document.addEventListener('alpine:init', () => {
this.localFiles = selected;
this.localFilesBatchId = selected.length ? crypto.randomUUID() : null;
this.localFileUploadIds = new WeakMap();
this.localPlaylistLocked = false;
this.localTargetPlaylistId = null;
this.localPlaylistChoice = '';
this.localNewPlaylistTitle = '';
this.localFilesDragging = false;
this.uploadProgress = 0;
this.uploadProgressText = '';
@@ -5997,6 +6004,10 @@ document.addEventListener('alpine:init', () => {
this.localFiles = [];
this.localFilesBatchId = null;
this.localFileUploadIds = new WeakMap();
this.localPlaylistLocked = false;
this.localTargetPlaylistId = null;
this.localPlaylistChoice = '';
this.localNewPlaylistTitle = '';
this.uploadProgress = 0;
this.uploadProgressText = '';
},
@@ -6033,6 +6044,7 @@ document.addEventListener('alpine:init', () => {
}
xhr.setRequestHeader('X-Furumusic-Upload-Id', uploadId);
xhr.setRequestHeader('X-Furumusic-Upload-Batch-Id', this.localFilesBatchId);
if (this.localTargetPlaylistId) xhr.setRequestHeader('X-Furumusic-Target-Playlist-Id', String(this.localTargetPlaylistId));
if (file.webkitRelativePath) {
xhr.setRequestHeader('X-Furumusic-Relative-Path', encodeURIComponent(file.webkitRelativePath));
}
@@ -6055,7 +6067,7 @@ document.addEventListener('alpine:init', () => {
},
async uploadLocalFiles() {
if (this.localFilesUploading || this.localFiles.length === 0) return;
if (this.localFilesUploading || this.localFiles.length === 0 || !this.importDestinationValid('local')) return;
const batchId = this.localFilesBatchId;
this.localFilesUploading = true;
this.uploadProgress = 0;
@@ -6063,7 +6075,13 @@ document.addEventListener('alpine:init', () => {
this._setMessage(T.uploadingFiles);
const totalBytes = this.localUploadBytes();
let loadedBefore = 0;
let batchStarted = false;
try {
if (!this.localPlaylistLocked) {
this.localTargetPlaylistId = await this.resolveImportTargetPlaylist('local');
this.localPlaylistLocked = true;
}
batchStarted = true;
for (const file of [...this.localFiles]) {
const data = await this.uploadLocalFile(file, loadedBefore, totalBytes);
if (data?.upload) {
@@ -6085,7 +6103,7 @@ document.addEventListener('alpine:init', () => {
} catch (err) {
this._setMessage(err.message || String(err), true);
} finally {
try {
if (batchStarted) try {
const response = await fetch('/api/player/uploads/local', {
method: 'POST',
headers: {
@@ -6111,6 +6129,7 @@ document.addEventListener('alpine:init', () => {
const data = await res.json().catch(() => null);
if (!res.ok) throw new Error(data?.error || T.fileUploadLoadFailed);
this.localUploadHistory = Array.isArray(data) ? data : [];
if (this.localUploadHistory.some(item => item.target_playlist_id)) Alpine.store('playlists')?.reload?.();
} catch (err) {
if (!silent) this._setMessage(err.message || T.fileUploadLoadFailed, true);
} finally {
@@ -6361,6 +6380,7 @@ document.addEventListener('alpine:init', () => {
},
async start() {
if (!this.importDestinationValid('torrent')) return;
if (!this.previewData || this.loading) return;
const selected = this.selectedArray();
if (selected.length === 0) {
@@ -6371,10 +6391,11 @@ document.addEventListener('alpine:init', () => {
this.loading = true;
this._setMessage(T.startingDownload);
try {
const targetPlaylistId = await this.resolveImportTargetPlaylist('torrent');
const res = await fetch(`/api/player/torrents/${this.previewData.id}/start`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ selected_files: selected }),
body: JSON.stringify({ selected_files: selected, target_playlist_id: targetPlaylistId }),
});
const data = await res.json();
if (!res.ok) throw new Error(data.error || T.startFailed);
@@ -6456,6 +6477,7 @@ document.addEventListener('alpine:init', () => {
_pointerDragEnd: null,
init() {
if (GUEST) return;
this.reload();
},
+54 -45
View File
@@ -1,4 +1,4 @@
<div class="app-layout"
<div class="app-layout{% if guest %} guest-player{% endif %}"
x-data
@keydown.window.space="if (!['INPUT','TEXTAREA','SELECT'].includes(document.activeElement?.tagName)) { $event.preventDefault(); $store.player.toggle(); }"
@keydown.window.arrow-left="if (!['INPUT','TEXTAREA','SELECT'].includes(document.activeElement?.tagName)) { $event.preventDefault(); $store.player.seekRelative(-5); }"
@@ -7,6 +7,7 @@
>
<div class="main-content">
{% if !guest %}
<!-- Left Sidebar -->
<div class="sidebar-left">
<div class="user-widget" x-show="$store.user.profile" x-cloak>
@@ -119,17 +120,17 @@
</div>
<template x-if="pl.is_own && pl.kind === 'user'">
<div class="playlist-item-actions">
<button class="playlist-action-btn" @click.stop="$store.playlists.startRename(pl)" title="{{ t.player_rename }}">
<button data-member-only class="playlist-action-btn" @click.stop="$store.playlists.startRename(pl)" title="{{ t.player_rename }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M11 4H4a2 2 0 00-2 2v14a2 2 0 002 2h14a2 2 0 002-2v-7"/><path d="M18.5 2.5a2.12 2.12 0 013 3L12 15l-4 1 1-4 9.5-9.5z"/></svg>
</button>
<button class="playlist-action-btn" @click.stop="$store.playlists.deletePlaylist(pl.id)" title="{{ t.player_delete }}">
<button data-member-only class="playlist-action-btn" @click.stop="$store.playlists.deletePlaylist(pl.id)" title="{{ t.player_delete }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 01-2 2H7a2 2 0 01-2-2V6m3 0V4a2 2 0 012-2h4a2 2 0 012 2v2"/></svg>
</button>
</div>
</template>
</div>
</template>
<button class="sidebar-create-btn" @click="$store.playlists.showCreate()">
<button data-member-only class="sidebar-create-btn" @click="$store.playlists.showCreate()">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
{{ t.player_new_playlist }}
</button>
@@ -156,6 +157,7 @@
</div>
</div>
{% endif %}
<template x-if="$store.mobile.libraryOpen">
<div class="mobile-library-backdrop" @click.self="$store.mobile.closeLibrary()" x-cloak>
<aside class="mobile-library-drawer">
@@ -212,7 +214,7 @@
</div>
<div class="following-name" x-text="artist.name"></div>
</div>
<button class="mobile-list-action"
<button data-member-only class="mobile-list-action"
@click.stop="$store.follows.toggle(artist.id)"
title="{{ t.player_unfollow_artist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
@@ -244,17 +246,17 @@
</div>
<template x-if="pl.is_own && pl.kind === 'user'">
<div class="playlist-item-actions">
<button class="playlist-action-btn" @click.stop="$store.mobile.closeLibrary(); $store.playlists.startRename(pl)" title="{{ t.player_rename }}">
<button data-member-only class="playlist-action-btn" @click.stop="$store.mobile.closeLibrary(); $store.playlists.startRename(pl)" title="{{ t.player_rename }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M11 4H4a2 2 0 00-2 2v14a2 2 0 002 2h14a2 2 0 002-2v-7"/><path d="M18.5 2.5a2.12 2.12 0 013 3L12 15l-4 1 1-4 9.5-9.5z"/></svg>
</button>
<button class="playlist-action-btn" @click.stop="$store.playlists.deletePlaylist(pl.id)" title="{{ t.player_delete }}">
<button data-member-only class="playlist-action-btn" @click.stop="$store.playlists.deletePlaylist(pl.id)" title="{{ t.player_delete }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 01-2 2H7a2 2 0 01-2-2V6m3 0V4a2 2 0 012-2h4a2 2 0 012 2v2"/></svg>
</button>
</div>
</template>
</div>
</template>
<button class="sidebar-create-btn" @click="$store.mobile.closeLibrary(); $store.playlists.showCreate()">
<button data-member-only class="sidebar-create-btn" @click="$store.mobile.closeLibrary(); $store.playlists.showCreate()">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
{{ t.player_new_playlist }}
</button>
@@ -288,7 +290,7 @@
<div class="center-content" id="center-scroll">
<!-- Search / account bar -->
<div class="content-topbar" @click.outside="$store.user.menuOpen = false">
<button class="mobile-library-btn"
<button data-member-only class="mobile-library-btn"
@click="$store.user.menuOpen = false; $store.mobile.toggleLibrary()"
title="{{ t.player_library }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
@@ -310,6 +312,13 @@
</svg>
<span class="connection-alert-text">{{ t.player_connection_lost }}</span>
</div>
{% if guest %}
<div class="guest-account">
<strong>{{ t.guest_label }}</strong>
<div x-show="$store.user.accessStatus === 'pending'" x-cloak><span>{{ t.approval_heading }}</span> · <a href="/logout">{{ t.player_log_out }}</a></div>
<a x-show="$store.user.accessStatus === 'anonymous'" href="/login?next=/share/{{ share_token }}">{{ t.guest_login }}</a>
</div>
{% endif %}
<div class="search-bar">
<span class="search-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg></span>
<input id="search-input" type="text" placeholder="{{ t.player_search_placeholder }}"
@@ -518,7 +527,7 @@
<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="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
<button data-member-only class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
<svg viewBox="0 0 24 24" :fill="$store.likes.has(track.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>
<button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
@@ -527,10 +536,10 @@
<button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
</button>
<button class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<button data-member-only class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><path d="M8.6 10.6l6.8-3.9M8.6 13.4l6.8 3.9"/></svg>
</button>
<button class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
<button data-member-only class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
</button>
</div>
@@ -670,7 +679,7 @@
title="{{ t.player_add_to_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
</button>
<button class="track-action-btn playlist-add-btn"
<button data-member-only class="track-action-btn playlist-add-btn"
@click.stop="$store.playlists.showFederationPicker(track)"
title="{{ t.player_add_to_playlist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
@@ -714,7 +723,7 @@
<template x-if="!artist.image_url">
<span class="placeholder-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="12" cy="8" r="4"/><path d="M20 21a8 8 0 10-16 0"/></svg></span>
</template>
<button class="artist-follow-card-btn"
<button data-member-only class="artist-follow-card-btn"
:class="{ followed: $store.follows.has(artist.id) }"
@click.stop="$store.follows.toggle(artist.id)"
:title="$store.follows.has(artist.id) ? '{{ t.player_unfollow_artist }}' : '{{ t.player_follow_artist }}'">
@@ -794,7 +803,7 @@
</svg>
<span>{{ t.player_listen }}</span>
</button>
<button class="release-action-btn secondary artist-follow-action"
<button data-member-only class="release-action-btn secondary artist-follow-action"
x-show="$store.library.currentArtist.id"
:class="{ followed: $store.follows.has($store.library.currentArtist.id) }"
@click="$store.follows.toggle($store.library.currentArtist.id)"
@@ -881,7 +890,7 @@
<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="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
<button data-member-only class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
<svg viewBox="0 0 24 24" :fill="$store.likes.has(track.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>
<button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
@@ -890,10 +899,10 @@
<button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
</button>
<button class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<button data-member-only class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><path d="M8.6 10.6l6.8-3.9M8.6 13.4l6.8 3.9"/></svg>
</button>
<button class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
<button data-member-only class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
</button>
</div>
@@ -1037,7 +1046,7 @@
title="{{ t.player_add_to_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
</button>
<button class="track-action-btn playlist-add-btn"
<button data-member-only class="track-action-btn playlist-add-btn"
@click.stop="$store.playlists.showFederationPicker(track)"
title="{{ t.player_add_to_playlist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
@@ -1110,7 +1119,7 @@
<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="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
<button data-member-only class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
<svg viewBox="0 0 24 24" :fill="$store.likes.has(track.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>
<button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
@@ -1119,10 +1128,10 @@
<button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
</button>
<button class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<button data-member-only class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><path d="M8.6 10.6l6.8-3.9M8.6 13.4l6.8 3.9"/></svg>
</button>
<button class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
<button data-member-only class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
</button>
</div>
@@ -1193,7 +1202,7 @@
<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>
{{ t.player_info }}
</button>
<button class="release-action-btn secondary release-share-btn"
<button data-member-only class="release-action-btn secondary release-share-btn"
x-show="!$store.library.currentRelease.federated"
@click.stop="$store.sharing.copyRelease($store.library.currentRelease, $event.currentTarget)"
title="{{ t.player_share }}"
@@ -1290,7 +1299,7 @@
<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="like-btn"
<button data-member-only class="like-btn"
:class="{ liked: track.federation_pending ? $store.library.federationIsLiked(track._federationTrack) : $store.likes.has(track.id) }"
@click.stop="track.federation_pending ? $store.library.toggleFederationLike(track._federationTrack) : $store.likes.toggle(track.id)"
title="{{ t.player_like }}">
@@ -1304,12 +1313,12 @@
<button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
</button>
<button class="track-action-btn track-share-btn"
<button data-member-only class="track-action-btn track-share-btn"
x-show="!track.federation_pending"
@click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><path d="M8.6 10.6l6.8-3.9M8.6 13.4l6.8 3.9"/></svg>
</button>
<button class="track-action-btn playlist-add-btn"
<button data-member-only class="track-action-btn playlist-add-btn"
@click.stop="track.federation_pending ? $store.playlists.showFederationPicker(track._federationTrack) : $store.playlists.showPicker([track.id])"
title="{{ t.player_add_to_playlist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
@@ -1331,7 +1340,7 @@
</div>
<div class="playlist-detail-heading">
<h1 class="section-title" x-text="$store.playlists.displayTitle($store.library.currentPlaylist)"></h1>
<button class="release-action-btn secondary playlist-edit-toggle"
<button data-member-only class="release-action-btn secondary playlist-edit-toggle"
x-show="$store.playlists.canEditCurrent()"
x-cloak
@click="$store.playlists.toggleEditCurrent()"
@@ -1379,7 +1388,7 @@
@dragover.prevent="$store.playlists.dragOver($event, idx)"
@dragleave="$event.currentTarget.classList.remove('drag-over')"
@drop.prevent="$event.currentTarget.classList.remove('drag-over'); $store.playlists.dropOn(idx)">
<button class="playlist-track-remove"
<button data-member-only class="playlist-track-remove"
x-show="$store.playlists.isEditingCurrent()"
x-cloak
@click.stop="$store.playlists.removeCurrentTrack(track, idx)"
@@ -1422,7 +1431,7 @@
</template>
</span>
<div class="track-info playlist-track-info">
<button class="playlist-drag-handle"
<button data-member-only class="playlist-drag-handle"
x-show="$store.playlists.isEditingCurrent() && !!track.playlist_track_id"
x-cloak
@mousedown.stop
@@ -1457,7 +1466,7 @@
<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="like-btn"
<button data-member-only class="like-btn"
:class="{ liked: track.federation_pending ? $store.library.federationIsLiked(track._federationTrack) : $store.likes.has(track.id) }"
@click.stop="track.federation_pending ? $store.library.toggleFederationLike(track._federationTrack) : $store.likes.toggle(track.id)"
title="{{ t.player_like }}">
@@ -1471,10 +1480,10 @@
<button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
</button>
<button class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<button data-member-only class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><path d="M8.6 10.6l6.8-3.9M8.6 13.4l6.8 3.9"/></svg>
</button>
<button class="track-action-btn playlist-add-btn"
<button data-member-only class="track-action-btn playlist-add-btn"
@click.stop="track.federation_pending ? $store.playlists.showFederationPicker(track._federationTrack) : $store.playlists.showPicker([track.id])"
title="{{ t.player_add_to_playlist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
@@ -1496,7 +1505,7 @@
<div class="queue-header">
<h3>{{ t.player_queue }}</h3>
<div class="queue-header-actions">
<button class="queue-share-btn" @click="$store.sharing.copyQueue($event.currentTarget)" :disabled="$store.queue.tracks.length === 0" title="{{ t.player_share_queue }}" aria-label="{{ t.player_share_queue }}">
<button data-member-only class="queue-share-btn" @click="$store.sharing.copyQueue($event.currentTarget)" :disabled="$store.queue.tracks.length === 0" title="{{ t.player_share_queue }}" aria-label="{{ t.player_share_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><path d="M8.6 10.6l6.8-3.9M8.6 13.4l6.8 3.9"/></svg>
</button>
<button class="queue-clear-btn" @click="$store.queue.clear()">{{ t.player_clear }}</button>
@@ -1620,14 +1629,14 @@
<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"
<button data-member-only 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>
<button class="track-action-btn player-current-share"
<button data-member-only class="track-action-btn player-current-share"
@click.stop="$store.sharing.copyTrack($store.player.currentTrack, $event.currentTarget)"
title="{{ t.player_share_track }}"
aria-label="{{ t.player_share_track }}">
@@ -1727,7 +1736,7 @@
</button>
<div class="device-picker" @click.outside="$store.devices.open = false">
<template x-if="$store.devices.remoteHintVisible">
<button class="remote-playback-hint"
<button data-member-only class="remote-playback-hint"
type="button"
@click="$store.devices.dismissRemoteHint()"
x-transition
@@ -1736,7 +1745,7 @@
<span class="remote-playback-hint-progress"></span>
</button>
</template>
<button class="queue-toggle-btn device-toggle-btn"
<button data-member-only class="queue-toggle-btn device-toggle-btn"
:class="{ active: $store.devices.isActive() }"
@click="$store.devices.toggle()"
:title="$store.devices.activeLabel()"
@@ -1757,7 +1766,7 @@
<div class="device-popover" x-show="$store.devices.open" x-transition x-cloak>
<div class="device-section-label">Web players</div>
<template x-for="device in $store.devices.webDevices()" :key="device.id">
<button class="device-row"
<button data-member-only class="device-row"
:class="{ active: device.is_active, 'current-device': device.is_current }"
@click="$store.devices.select(device.id)">
<span class="device-row-icon">
@@ -1792,7 +1801,7 @@
</div>
</template>
<template x-for="device in $store.devices.playbackFedDevices()" :key="device.id">
<button class="device-row federation-device-row"
<button data-member-only class="device-row federation-device-row"
:class="{ active: device.is_active }"
@click="$store.devices.select(device.id)">
<span class="device-row-icon federation-device-icon">
@@ -1818,7 +1827,7 @@
<div class="device-section-label jam-section-label">Jams</div>
</template>
<template x-for="jam in $store.devices.jams" :key="jam.id">
<button class="device-row jam-row"
<button data-member-only class="device-row jam-row"
:class="{ active: jam.is_active, pending: jam.is_pending }"
@click="$store.devices.handleJamRowClick(jam)">
<span class="device-row-icon">
@@ -1841,7 +1850,7 @@
</span>
</button>
</template>
<button class="device-row start-jam-row" x-show="!$store.devices.hasJoinedJam()" @click="$store.devices.openJamPanel()">
<button data-member-only class="device-row start-jam-row" x-show="!$store.devices.hasJoinedJam()" @click="$store.devices.openJamPanel()">
<span class="device-row-icon">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
<path d="M12 5v14"/>
@@ -1865,7 +1874,7 @@
</label>
<div class="jam-selected-users" x-show="$store.devices.jamSelectedUsers.length > 0">
<template x-for="user in $store.devices.jamSelectedUsers" :key="user.id">
<button class="jam-user-chip" @click="$store.devices.removeJamInvitee(user.id)">
<button data-member-only class="jam-user-chip" @click="$store.devices.removeJamInvitee(user.id)">
<span x-text="user.display_name || user.username"></span>
<span aria-hidden="true">×</span>
</button>
@@ -1878,18 +1887,18 @@
@input="$store.devices.queueJamSearch()">
<div class="jam-search-results" x-show="$store.devices.jamUsers.length > 0">
<template x-for="user in $store.devices.jamUsers" :key="user.id">
<button class="jam-search-row" @click="$store.devices.addJamInvitee(user)">
<button data-member-only class="jam-search-row" @click="$store.devices.addJamInvitee(user)">
<span x-text="user.display_name || user.username"></span>
<small x-text="user.email || user.username"></small>
</button>
</template>
</div>
<div class="jam-panel-actions">
<button class="jam-create-btn"
<button data-member-only class="jam-create-btn"
:disabled="$store.devices.jamSelectedUsers.length === 0 && $store.devices.jamPanelMode === 'manage'"
@click="$store.devices.submitJamPanel()"
x-text="$store.devices.jamPanelMode === 'manage' ? 'Invite' : 'Create Jam'"></button>
<button class="jam-leave-btn"
<button data-member-only class="jam-leave-btn"
x-show="$store.devices.jamPanelMode === 'manage'"
@click="$store.devices.leaveJam($store.devices.jamPanelJamId)">Leave</button>
</div>
+19 -1
View File
@@ -6666,7 +6666,8 @@ button.user-stat:hover {
flex-wrap: wrap;
}
.youtube-preview-destination-fields {
.youtube-preview-destination-fields,
.youtube-preview-destination-fields.creating {
grid-column: auto;
grid-row: auto;
grid-template-columns: 1fr;
@@ -7001,3 +7002,20 @@ button.user-stat:hover {
.queue-tracks::-webkit-scrollbar-thumb,
.playlist-list::-webkit-scrollbar-thumb { background: var(--bg-active); border-radius: 3px; }
</style>
<style>
.guest-player [data-member-only], .guest-player .search-bar, .guest-player .breadcrumb,
.guest-player .device-picker, .guest-player .mobile-library-backdrop,
.guest-player .mobile-library-btn, .guest-player .mobile-library-toggle { display:none !important; }
.guest-player .artist-link, .guest-player .track-artist a, .guest-player .player-artist a { pointer-events:none; cursor:default; }
.guest-account { display:flex; align-items:center; justify-content:space-between; gap:16px; width:100%; font-size:14px; }
.guest-account a { color:var(--accent); text-decoration:none; }
.guest-account div { color:var(--text-secondary); }
@media(max-width:600px) { .guest-account { flex-wrap:wrap; gap:8px; font-size:12px; } }
@media(max-width:1100px) {
.guest-player .playlist-track-row > span:nth-child(4) { display:none; }
.guest-player .playlist-track-row .track-num { grid-column:1; grid-row:1; }
.guest-player .playlist-track-row .playlist-track-info { grid-column:2; grid-row:1; }
.guest-player .playlist-track-row .track-actions { grid-column:3; grid-row:1; }
}
</style>
+131
View File
@@ -0,0 +1,131 @@
const assert = require('node:assert/strict');
const { readFileSync } = require('node:fs');
const { test } = require('node:test');
const vm = require('node:vm');
const template = readFileSync(`${__dirname}/../templates/admin/v2.html`, 'utf8');
const ui = readFileSync(`${__dirname}/../templates/admin/ui.html`, 'utf8').match(/<script>([\s\S]*?)<\/script>/)[1];
const script = ui + '\n' + template.match(/<script>\s*(function adminV2\(\)[\s\S]*?)<\/script>/)[1];
function createApp() {
const context = vm.createContext({URLSearchParams});
vm.runInContext(script, context);
const app = context.adminV2();
app.showToast = message => { app.toastMessage = message; };
app.$nextTick = fn => fn();
app.$refs = {};
app.repairSelected = [{kind:'artists',id:1,title:'Artist'}];
app.repairExpanded = {snapshot:{artists:[{id:1,name:'Artist'}],releases:[{id:2,title:'#ИЗИРОК',year:2018}],tracks:[{id:3,title:'Actual song',release_id:2}]}};
return app;
}
const emptyPlan = () => ({artists:[],releases:[],tracks:[],questions:[],delete:{artists:[],releases:[],tracks:[]}});
test('deselect all retains related rows and allows selecting only the needed resources', async () => {
const app = createApp();
app.setAllRepairIncluded(false);
assert.equal(app.repairIncludedCount(),0);
assert.equal(app.repairRowsCount(),3);
app.setRepairIncluded('releases',2,true);
app.setRepairIncluded('tracks',3,true);
assert.equal(app.repairIncludedCount(),2);
app.repairDraft = 'Only these';
app.request = async (url,options) => {
assert.ok(url.endsWith('/plan'), 'must not re-expand exclusions');
const body = JSON.parse(options.body);
assert.deepEqual(body.selection,{artists:[],releases:[2],tracks:[3]});
return {plan:emptyPlan(),snapshot:app.repairExpanded.snapshot,message:'Done'};
};
await app.sendRepair();
assert.equal(app.repairChat.length,2);
app.setAllRepairIncluded(true);
assert.equal(app.repairIncludedCount(),3);
});
test('checking only releases includes their contents without selecting the artist', () => {
const app = createApp();
app.setAllRepairIncluded(false);
app.setRepairIncluded('releases',2,true);
assert.deepEqual(JSON.parse(JSON.stringify(app.repairSelection(true))),{artists:[],releases:[2],tracks:[3]});
assert.equal(app.repairIsIncluded('tracks',3),true);
assert.equal(app.repairIsIncluded('artists',1),false);
app.setRepairIncluded('tracks',3,false);
assert.equal(app.repairIsIncluded('tracks',3),false);
assert.deepEqual(JSON.parse(JSON.stringify(app.repairSelection(true))).tracks,[]);
assert.deepEqual(JSON.parse(JSON.stringify(app.repairExcludedTracks)),[3]);
app.setAllRepairIncluded(false);
app.setRepairIncluded('releases',2,true);
assert.equal(app.repairIsIncluded('tracks',3),true);
});
test('explicit track exclusions are sent to planning without re-expanding them', async () => {
const app=createApp();
app.setAllRepairIncluded(false);
app.setRepairIncluded('releases',2,true);
app.setRepairIncluded('tracks',3,false);
app.repairDraft='Edit release only';
app.request=async(url,options)=>{
assert.ok(url.endsWith('/plan'));
const body=JSON.parse(options.body);
assert.deepEqual(body.selection,{artists:[],releases:[2],tracks:[]});
assert.deepEqual(body.excluded_track_ids,[3]);
return {plan:emptyPlan(),snapshot:app.repairExpanded.snapshot,message:'Done'};
};
await app.sendRepair();
});
test('clarification replaces the single plan including removed changes and questions', async () => {
const app = createApp();
app.repairPlan = {...emptyPlan(),delete:{artists:[],releases:[],tracks:[3]},questions:['Which release?']};
app.repairChat = [{role:'user',content:'Delete song'},{role:'assistant',content:'Please review'}];
app.repairPlanOpen = true;
app.repairDraft = 'Keep song, cancel everything';
app.request = async (_url,options) => {
const body=JSON.parse(options.body);
assert.deepEqual(body.current_plan.delete.tracks,[3]);
assert.equal(body.conversation.length,2);
return {plan:emptyPlan(),snapshot:app.repairExpanded.snapshot,message:'Cancelled'};
};
await app.sendRepair();
assert.equal(app.repairChangeCount(),0);
assert.equal(app.repairPlan.questions.length,0);
assert.equal(app.repairPlanOpen,true);
assert.equal(app.repairChat.length,4);
});
test('failed revision preserves prior plan and retry avoids duplicate user messages', async () => {
const app = createApp();
const prior = {...emptyPlan(),delete:{artists:[],releases:[],tracks:[3]}};
app.repairPlan = prior;
app.repairDraft = 'Keep song';
app.request = async () => {throw Error('Offline');};
await app.sendRepair();
assert.equal(app.repairPlan,prior);
assert.equal(app.repairIncomplete,true);
assert.equal(app.repairChat.length,1);
app.request = async (_url,options) => {
assert.equal(JSON.parse(options.body).conversation.length,0);
return {plan:emptyPlan(),snapshot:app.repairExpanded.snapshot,message:'Kept'};
};
await app.sendRepair();
assert.equal(app.repairChat.length,2);
assert.equal(app.repairIncomplete,false);
});
test('incomplete plan cannot apply, deletion-only plan can apply and clears stale selection', async () => {
const app = createApp();
app.repairPlan = {...emptyPlan(),delete:{artists:[],releases:[],tracks:[3]}};
app.repairSnapshot = app.repairExpanded.snapshot;
app.repairIncomplete = true;
app.request = async () => assert.fail('must not apply incomplete plan');
await app.applyRepair();
app.repairIncomplete = false;
app.request = async (url,options) => {
assert.ok(url.endsWith('/apply'));
assert.deepEqual(JSON.parse(options.body).plan.delete.tracks,[3]);
return {history_id:7};
};
app.loadRepairHistory = async () => {};
app.loadLibrary = async () => {};
await app.applyRepair();
assert.equal(app.repairIncludedCount(),0);
assert.equal(app.repairPlan,null);
assert.equal(app.repairChat.at(-1).content.includes('#7'),true);
});
+42
View File
@@ -0,0 +1,42 @@
const assert = require('node:assert/strict');
const {readFileSync} = require('node:fs');
const {test} = require('node:test');
const vm = require('node:vm');
const template = readFileSync(`${__dirname}/../templates/admin/v2.html`, 'utf8');
const ui = readFileSync(`${__dirname}/../templates/admin/ui.html`, 'utf8').match(/<script>([\s\S]*?)<\/script>/)[1];
const script = ui + '\n' + template.match(/<script>\s*(function adminV2\(\)[\s\S]*?)<\/script>/)[1];
function app() {
const context = vm.createContext({URLSearchParams, Date}); vm.runInContext(script, context);
const a = context.adminV2(); a.icons = () => {}; a.setRoute = () => {}; return a;
}
test('artist → listeners → user retains artist and period filters', async () => {
const a = app(); const urls=[];
a.request = async url => { urls.push(new URL(url, 'http://localhost').searchParams); return {}; };
a.statisticsFilter.from = '2026-11-01'; a.statisticsHistoryPage = 5;
await a.statisticsSelectArtist('Artist & Friends');
assert.equal(urls[0].get('kind'), 'users'); assert.equal(urls[0].get('artist'), 'Artist & Friends');
assert.equal(urls[0].get('history_page'), '1');
await a.statisticsExplore({key:'23', label:'Alice'});
assert.equal(urls[1].get('user_id'), '23'); assert.equal(urls[1].get('artist'), 'Artist & Friends');
assert.equal(urls[1].get('from'), '2026-11-01');
await a.statisticsClearFilter('user_id'); assert.equal(urls[2].get('user_id'), null);
assert.equal(urls[2].get('artist'), 'Artist & Friends');
});
test('latest filters win when earlier requests arrive late', async () => {
const a = app(); const responses=[];
a.request = () => new Promise(resolve => responses.push(resolve));
const first = a.loadStatistics(); const second = a.statisticsSelectArtist('Second');
responses[1]({marker:2}); await second; responses[0]({marker:1}); await first;
assert.equal(a.statisticsData.marker, 2); assert.equal(a.statisticsLoading, false);
});
test('errors are shown separately from an empty result', async () => {
const a = app(); a.request = async () => {throw new Error('Database unavailable')};
await a.loadStatistics(); assert.equal(a.statisticsError, 'Database unavailable'); assert.equal(a.statisticsLoading, false);
});
test('opening a user starts full history without an earlier artist selection', () => {
const a = app(); a.statisticsFilter.artist = 'Previous'; a.statisticsSearch = 'old search'; a.statisticsHistoryKind = 'short'; a.statisticsFilter.source = 'synced'; a.statisticsSetPeriod = () => {};
a.openStatistics({id:4, username:'user4'});
assert.equal(a.statisticsFilter.user_id, 4); assert.equal(a.statisticsFilter.artist, '');
assert.equal(a.statisticsSearch, ''); assert.equal(a.statisticsHistoryKind, 'all'); assert.equal(a.statisticsFilter.source, 'all');
assert.equal(a.statisticsPeriod, 'all'); assert.equal(a.activeView, 'statistics'); assert.equal(a.userModalOpen, false);
});
+105
View File
@@ -0,0 +1,105 @@
const assert = require('node:assert/strict');
const { readFileSync } = require('node:fs');
const { test } = require('node:test');
const vm = require('node:vm');
const template = readFileSync(`${__dirname}/../templates/admin/v2.html`, 'utf8');
const ui = readFileSync(`${__dirname}/../templates/admin/ui.html`, 'utf8').match(/<script>([\s\S]*?)<\/script>/)[1];
const script = ui + '\n' + template.match(/<script>\s*(function adminV2\(\)[\s\S]*?)<\/script>/)[1];
function createApp() {
const context = vm.createContext({});
vm.runInContext(script, context);
const app = context.adminV2();
app.showToast = message => { app.toastMessage = message; };
app.loadReviews = async () => { app.reviewsReloaded = true; };
app.loadLibrary = async () => { app.libraryReloaded = true; };
return app;
}
test('approves individually selected reviews and reports partial failures', async () => {
const app = createApp();
app.toggleReview({ id: 12, status: 'pending' });
app.toggleReview({ id: 34, status: 'pending' });
app.toggleReview({ id: 56, status: 'failed' });
assert.equal(app.selectedPendingReviewCount(), 2);
app.request = async (url, options) => {
assert.equal(url, '/admin/v2/api/reviews/bulk');
assert.equal(options.method, 'POST');
assert.deepEqual(JSON.parse(options.body), {
action: 'approve', mode: 'ids', ids: [12, 34, 56],
filter: { status: null, search: null }
});
assert.equal(app.reviewBulkBusy, true);
return { ok: false, affected: 1, failed: 1, skipped: 1 };
};
await app.bulkReviews('approve');
assert.equal(app.toastMessage, '1 review(s) approved · 1 failed · 1 skipped');
assert.equal(app.selectedReviewCount(), 0);
assert.equal(app.reviewsReloaded, true);
assert.equal(app.libraryReloaded, true);
assert.equal(app.reviewBulkBusy, false);
});
test('select all approves the whole searched filter across pages', async () => {
const app = createApp();
app.reviewFilter = { status: 'pending', search: 'Album' };
app.reviews = { total: 320, items: [{ id: 1, status: 'pending' }] };
app.selectReviewFilter();
assert.equal(app.selectedPendingReviewCount(), 320);
app.request = async (_url, options) => {
assert.deepEqual(JSON.parse(options.body), {
action: 'approve', mode: 'filter', ids: [],
filter: { status: 'pending', search: 'Album' }
});
return { affected: 320, failed: 0, skipped: 0 };
};
await app.bulkReviews('approve');
assert.equal(app.toastMessage, '320 review(s) approved · 0 failed · 0 skipped');
});
test('mixed status filter enables approval only when pending reviews exist', () => {
const app = createApp();
app.reviews = { total: 10, status_counts: [{ status: 'pending', count: 3 }, { status: 'queued', count: 7 }] };
app.selectReviewFilter();
assert.equal(app.selectedPendingReviewCount(), 3);
app.reviewFilter.status = 'queued';
assert.equal(app.selectedPendingReviewCount(), 0);
});
test('empty and non-pending selections do not submit approval', async () => {
const app = createApp();
app.request = async () => { assert.fail('unexpected request'); };
await app.bulkReviews('approve');
app.toggleReview({ id: 1, status: 'queued' });
await app.bulkReviews('approve');
});
test('blocks duplicate bulk submissions while approval is running', async () => {
const app = createApp();
app.toggleReview({ id: 1, status: 'pending' });
let finish;
let calls = 0;
app.request = async () => {
calls += 1;
return new Promise(resolve => { finish = resolve; });
};
const approval = app.bulkReviews('approve');
await app.bulkReviews('approve');
await app.bulkReviews('requeue');
assert.equal(calls, 1);
finish({ affected: 1 });
await approval;
assert.equal(app.reviewBulkBusy, false);
});
test('request failure retains selection and restores bulk controls', async () => {
const app = createApp();
app.toggleReview({ id: 1, status: 'pending' });
app.request = async () => { throw new Error('Connection lost'); };
await app.bulkReviews('approve');
assert.equal(app.selectedReviewCount(), 1);
assert.equal(app.toastMessage, 'Connection lost');
assert.equal(app.reviewBulkBusy, false);
assert.equal(app.reviewBulkAction, null);
});
+141
View File
@@ -0,0 +1,141 @@
// Run against a disposable, freshly migrated instance only.
// Requires Docker PostgreSQL (FURU_ACCESS_TEST_PG), Playwright and Chrome.
const assert = require('node:assert/strict');
const {chromium} = require(process.env.PLAYWRIGHT_MODULE || 'playwright');
const {spawnSync} = require('node:child_process');
const {mkdirSync, writeFileSync} = require('node:fs');
const {createServer} = require('node:http');
const {generateKeyPairSync, sign, randomUUID, createHash} = require('node:crypto');
const base = process.env.FURU_TEST_URL || 'http://127.0.0.1:18048';
const issuer = 'http://127.0.0.1:18049';
const mediaRoot = process.env.FURU_ACCESS_TEST_MEDIA || '/tmp/furumi-access-media';
function sql(statement) {
const result = spawnSync('docker', ['exec', '-i', process.env.FURU_ACCESS_TEST_PG || 'furumi-access-test-pg', 'psql', '-U', 'postgres', '-d', 'furumi_access_test', '-At', '-v', 'ON_ERROR_STOP=1'], {input:statement, encoding:'utf8'});
assert.equal(result.status, 0, result.stderr); return result.stdout.trim();
}
const encode = value => Buffer.from(JSON.stringify(value)).toString('base64url');
const {privateKey, publicKey} = generateKeyPairSync('rsa', {modulusLength:2048});
const jwk = {...publicKey.export({format:'jwk'}), kid:'test', use:'sig', alg:'RS256'};
let claims = {sub:'pending-test', email:'pending@example.test', name:'Pending Listener', groups:[]};
const codes = new Map();
const oidc = createServer(async (request, response) => {
const url = new URL(request.url, issuer);
let data;
if (url.pathname === '/.well-known/openid-configuration') {
data = {issuer, authorization_endpoint:issuer+'/authorize', token_endpoint:issuer+'/token', jwks_uri:issuer+'/jwks', response_types_supported:['code'], subject_types_supported:['public'], id_token_signing_alg_values_supported:['RS256'], token_endpoint_auth_methods_supported:['client_secret_basic'], scopes_supported:['openid','email','profile'], claims_supported:['sub','email','email_verified','name','groups']};
} else if (url.pathname === '/jwks') data = {keys:[jwk]};
else if (url.pathname === '/authorize') {
const code = randomUUID(); codes.set(code, {...claims, nonce:url.searchParams.get('nonce'), challenge:url.searchParams.get('code_challenge')});
const target = new URL(url.searchParams.get('redirect_uri'));
target.searchParams.set('code', code); target.searchParams.set('state', url.searchParams.get('state'));
response.writeHead(302, {Location:target.toString()}); response.end(); return;
} else if (url.pathname === '/token') {
let body=''; for await (const chunk of request) body += chunk;
const form = new URLSearchParams(body); const saved = codes.get(form.get('code')); codes.delete(form.get('code'));
assert.ok(saved); assert.equal(createHash('sha256').update(form.get('code_verifier')).digest('base64url'), saved.challenge);
const {challenge, ...identity} = saved;
const payload = {iss:issuer, aud:'furumi-test', iat:Math.floor(Date.now()/1000), exp:Math.floor(Date.now()/1000)+300, email_verified:true, ...identity};
const token = encode({alg:'RS256',kid:'test'})+'.'+encode(payload);
data = {access_token:'test-access', token_type:'Bearer', expires_in:300, id_token:token+'.'+sign('RSA-SHA256',Buffer.from(token),privateKey).toString('base64url')};
} else { response.writeHead(404); response.end(); return; }
response.writeHead(200, {'Content-Type':'application/json'}); response.end(JSON.stringify(data));
});
(async () => {
await new Promise(resolve => oidc.listen(18049,'127.0.0.1',resolve));
const browser = await chromium.launch({headless:true, executablePath:process.env.CHROME_PATH || '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'});
const errors=[];
try {
const admin = await browser.newContext({viewport:{width:1440,height:1000}});
let response = await admin.request.post(base+'/admin/setup', {form:{username:'access-admin',password:'access-test-password',confirm_password:'access-test-password'}});
assert.ok(response.ok());
response = await admin.request.post(base+'/login',{form:{username:'access-admin',password:'access-test-password'}}); assert.ok(response.ok());
sql(`INSERT INTO furumusic__config_entry (key,value) VALUES ('auth_sso_enabled','true'),('oidc_issuer','${issuer}'),('oidc_client_id','furumi-test'),('oidc_client_secret','test-${randomUUID()}'),('oidc_admin_groups','admins'),('oidc_user_groups','listeners') ON CONFLICT (key) DO UPDATE SET value=EXCLUDED.value;`);
sql("UPDATE furumusic__user SET local_role=NULL, sso_role=NULL, is_active=false WHERE username IN ('pending','automatic','root-new');");
mkdirSync(mediaRoot,{recursive:true});
const wav=Buffer.alloc(44+8000*2*10); wav.write('RIFF'); wav.writeUInt32LE(wav.length-8,4); wav.write('WAVEfmt ',8); wav.writeUInt32LE(16,16); wav.writeUInt16LE(1,20); wav.writeUInt16LE(1,22); wav.writeUInt32LE(8000,24); wav.writeUInt32LE(16000,28); wav.writeUInt16LE(2,32); wav.writeUInt16LE(16,34); wav.write('data',36); wav.writeUInt32LE(wav.length-44,40);
writeFileSync(mediaRoot+'/shared-test.wav',wav);
const cover=Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aPioAAAAASUVORK5CYII=','base64'); writeFileSync(mediaRoot+'/cover.png',cover);
sql(`INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,uploader_name,created_at) VALUES (9001,'audio','shared-test.wav','Shared test.wav','audio/wav',${wav.length},'${createHash('sha256').update(wav).digest('hex')}','Test','2026-11-18T00:00:00Z'),(9002,'cover_art','cover.png','cover.png','image/png',${cover.length},'${createHash('sha256').update(cover).digest('hex')}','Test','2026-11-18T00:00:00Z') ON CONFLICT (id) DO NOTHING;
INSERT INTO furumusic__artist (id,name,name_sort,is_hidden,created_at,updated_at) VALUES (9001,'Test Artist','test artist',false,'2026-11-18T00:00:00Z','2026-11-18T00:00:00Z') ON CONFLICT (id) DO NOTHING;
INSERT INTO furumusic__release (id,title,title_sort,release_type,is_hidden,cover_file_id,created_at,updated_at) VALUES (9001,'Shared Album','shared album','album',false,9002,'2026-11-18T00:00:00Z','2026-11-18T00:00:00Z') ON CONFLICT (id) DO NOTHING;
INSERT INTO furumusic__track (id,title,title_sort,release_id,duration_seconds,audio_file_id,is_hidden,created_at,updated_at) VALUES (9001,'Shared Song','shared song',9001,10,9001,false,'2026-11-18T00:00:00Z','2026-11-18T00:00:00Z'),(9002,'Private Song','private song',9001,10,9001,false,'2026-11-18T00:00:00Z','2026-11-18T00:00:00Z') ON CONFLICT (id) DO NOTHING;
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) SELECT id,9001,'main',0 FROM furumusic__track WHERE id IN (9001,9002) AND NOT EXISTS (SELECT 1 FROM furumusic__track_artist WHERE track_id=furumusic__track.id);`);
response=await admin.request.post(base+'/api/player/shares',{data:{track_ids:[9001],title:'Shared Song'}}); assert.equal(response.status(),200); const share=await response.json();
const guest=await browser.newContext({viewport:{width:1440,height:1000}});
const page=await guest.newPage(); page.on('pageerror',e=>errors.push(e.message));
const api=[]; page.on('request',r=>{if(r.url().includes('/api/'))api.push(new URL(r.url()).pathname);});
await page.goto(base+share.url); await page.waitForSelector('.playlist-track-row');
assert.equal(await page.locator('.playlist-track-row').count(),1);
assert.equal(await page.getByRole('link',{name:'Sign in / register'}).count(),1);
assert.equal(await page.locator('#search-input').isVisible(),false);
assert.equal(await page.locator('.sidebar-left').count(),0);
await page.locator('.player-btn-play').click(); await page.waitForFunction(()=>Alpine.store('player').currentTime>0);
assert.equal(await page.locator('.device-picker').isVisible(),false);
await page.locator('.playlist-track-row [aria-label="Track info"]').click();
assert.equal(await page.getByRole('button',{name:'Start radio',exact:true}).count(),0);
assert.equal(await page.getByRole('button',{name:'Find similar',exact:true}).count(),0);
const downloading=page.waitForEvent('download'); await page.getByRole('button',{name:'Download',exact:true}).click(); const download=await downloading;
assert.equal(download.suggestedFilename(),'Shared test.wav'); await download.saveAs('/tmp/furumi-access-download.wav');
await page.locator('.modal-overlay [title="Close"]').click(); await page.screenshot({path:'/tmp/furumi-guest-desktop.png',fullPage:true});
assert.ok(api.every(path=>path.startsWith('/api/player/shares/')),JSON.stringify(api));
for (const action of ['stream','download','cover']) {
assert.equal((await guest.request.get(`${base}/api/player/shares/${share.token}/${action}/9002`)).status(),404);
assert.equal((await guest.request.get(`${base}/api/player/shares/${'0'.repeat(32)}/${action}/9001`)).status(),404);
}
assert.equal((await guest.request.get(`${base}/api/player/stream/9001`)).status(),401);
assert.equal((await guest.request.get(`${base}/api/player/artists`)).status(),401);
response=await guest.request.get(`${base}/api/player/shares/${share.token}/stream/9001`,{headers:{Range:'bytes=0-43'}}); assert.equal(response.status(),206); assert.equal((await response.body()).length,44);
assert.equal((await guest.request.get(`${base}/api/player/shares/${share.token}/stream/9001`,{headers:{Range:'bytes=999999999-'}})).status(),416);
assert.equal((await guest.request.get(`${base}/api/player/shares/${share.token}/cover/9001`)).status(),200);
assert.equal((await guest.request.post(`${base}/api/player/shares`,{data:{track_ids:[9001]}})).status(),401);
await page.getByRole('link',{name:'Sign in / register'}).click(); await page.locator('.sso-btn').click();
await page.waitForURL(base+share.url); await page.getByText('Awaiting approval',{exact:true}).waitFor(); await page.waitForSelector('.playlist-track-row');
assert.equal(await page.locator('.playlist-track-row').count(),1);
const pendingId=Number(sql("SELECT id FROM furumusic__user WHERE username='pending'")); assert.ok(pendingId);
await page.goto(base+'/'); await page.getByRole('heading',{name:'Awaiting approval'}).waitFor();
assert.equal(await page.locator('.app-layout').count(),0);
assert.equal((await guest.request.get(`${base}/api/player/artists`)).status(),401);
assert.equal((await guest.request.post(`${base}/admin/v2/api/users/manage`,{data:{action:'approve',id:pendingId,role:'admin'}})).status(),401);
const adminPage=await admin.newPage(); adminPage.on('pageerror',e=>errors.push(e.message));
await adminPage.goto(base+'/admin/#users');
const pendingRow=adminPage.locator('.users-table tr').filter({hasText:'Pending Listener'});
await pendingRow.getByRole('button',{name:'Approve as user',exact:true}).click();
await page.waitForSelector('.app-layout',{timeout:15000});
assert.equal((await guest.request.get(`${base}/api/player/artists`)).status(),200);
assert.equal(sql(`SELECT local_role || ':' || role FROM furumusic__user WHERE id=${pendingId}`),'user:user');
// Priority: a user SSO group overrides even a local admin grant; losing
// that group restores the separate local grant.
response=await admin.request.post(base+'/admin/v2/api/users/manage',{data:{action:'approve',id:pendingId,role:'admin'}}); assert.equal(response.status(),200);
claims.groups=['listeners']; await page.goto(base+'/logout'); await page.locator('.sso-btn').click(); await page.waitForURL(base+'/');
assert.equal(sql(`SELECT local_role || ':' || role FROM furumusic__user WHERE id=${pendingId}`),'admin:user');
claims.groups=[]; await page.goto(base+'/logout'); await page.locator('.sso-btn').click(); await page.waitForURL(base+'/');
assert.equal(sql(`SELECT local_role || ':' || role FROM furumusic__user WHERE id=${pendingId}`),'admin:admin');
claims={sub:'automatic-test',email:'automatic@example.test',name:'Automatic Listener',groups:['admins']};
await page.goto(base+'/logout'); await page.locator('.sso-btn').click(); await page.waitForURL(base+'/');
assert.equal(sql("SELECT COALESCE(local_role,'none') || ':' || role FROM furumusic__user WHERE username='automatic'"),'none:admin');
const automaticId=Number(sql("SELECT id FROM furumusic__user WHERE username='automatic'"));
response=await admin.request.post(base+'/admin/v2/api/users/manage',{data:{action:'update',id:automaticId,username:'automatic',display_name:'Renamed Automatic Listener',email:'automatic@example.test',role:''}});
assert.equal(response.status(),200);
assert.equal(sql("SELECT COALESCE(local_role,'none') || ':' || role FROM furumusic__user WHERE username='automatic'"),'none:admin');
claims.groups=[]; await page.goto(base+'/logout'); await page.locator('.sso-btn').click(); await page.getByRole('heading',{name:'Awaiting approval'}).waitFor();
assert.equal(sql("SELECT is_active FROM furumusic__user WHERE username='automatic'"),'f');
// A completely new identity arriving at the root never sees a demo player.
claims={sub:'new-root-test',email:'root-new@example.test',name:'New Root Listener',groups:[]};
await page.goto(base+'/logout'); await page.locator('.sso-btn').click(); await page.getByRole('heading',{name:'Awaiting approval'}).waitFor();
assert.equal(await page.locator('.app-layout').count(),0);
// Queue snapshots preserve order and repeated tracks.
response=await admin.request.post(base+'/api/player/shares',{data:{track_ids:[9002,9001,9002],title:'Shared queue'}}); const queue=await response.json();
response=await guest.request.get(base+'/api/player/shares/'+queue.token); assert.deepEqual((await response.json()).tracks.map(t=>t.id),[9002,9001,9002]);
const mobile=await browser.newContext({viewport:{width:390,height:844},isMobile:true,hasTouch:true}); const mobilePage=await mobile.newPage(); mobilePage.on('pageerror',e=>errors.push(e.message));
await mobilePage.goto(base+queue.url); await mobilePage.waitForSelector('.playlist-track-row');
assert.equal(await mobilePage.getByRole('link',{name:'Sign in / register'}).isVisible(),true);
const info=mobilePage.locator('.playlist-track-row [aria-label="Track info"]').first();
const bounds=await info.boundingBox(); assert.ok(bounds && bounds.x>=0 && bounds.x+bounds.width<=390,JSON.stringify(bounds));
await info.click(); await mobilePage.getByRole('button',{name:'Download',exact:true}).waitFor();
await mobilePage.locator('.modal-overlay [title="Close"]').click();
await mobilePage.screenshot({path:'/tmp/furumi-guest-mobile.png',fullPage:true});
for (const old of ['/share/track/9001','/share/release/9001','/share/playlist/abc','/api/player/radio/track/9001','/api/player/share-playlist']) assert.equal((await guest.request.get(base+old)).status(),404);
assert.deepEqual(errors,[]);
console.log('PASS: OIDC approval, live activation, SSO precedence and removal, anonymous playback/download/cover, scope enforcement, queue snapshots, desktop and mobile, removal of legacy routes.');
} finally { await browser.close(); await new Promise(resolve=>oidc.close(resolve)); }
})().catch(error=>{console.error(error);process.exitCode=1;});
+164
View File
@@ -0,0 +1,164 @@
// Run against a disposable local instance with at least one admin and one release.
// Existing data is read only; long-content fixtures are injected into browser state.
// FURU_TEST_URL, FURU_TEST_USERNAME, FURU_TEST_PASSWORD, PLAYWRIGHT_MODULE,
// CHROME_PATH and FURU_TEST_SCREENSHOTS configure the runner.
const assert = require('node:assert/strict');
const {chromium} = require(process.env.PLAYWRIGHT_MODULE || 'playwright');
const {mkdirSync} = require('node:fs');
const base = process.env.FURU_TEST_URL || 'http://127.0.0.1:18048';
(async () => {
const browser = await chromium.launch({headless:true, executablePath:process.env.CHROME_PATH});
try {
const context = await browser.newContext({viewport:{width:390,height:844}, reducedMotion:'reduce'});
const response = await context.request.post(base+'/login', {form:{username:process.env.FURU_TEST_USERNAME || 'access-admin', password:process.env.FURU_TEST_PASSWORD || 'access-test-password'}});
assert.ok(response.ok());
const page = await context.newPage();
const errors = []; page.on('pageerror', error => errors.push(error.message));
await page.goto(base+'/admin/v2');
await page.waitForFunction(() => window.Alpine && document.querySelector('.admin-shell')._x_dataStack);
const state = (fn, arg) => page.evaluate(({code,arg}) => Function('app','arg',`return (${code})(app,arg)`)(Alpine.$data(document.querySelector('.admin-shell')), arg), {code:fn.toString(),arg});
await state(async app => { clearInterval(app.poller); await app.refreshAll(); });
const screenshot = async name => {
if (!process.env.FURU_TEST_SCREENSHOTS) return;
mkdirSync(process.env.FURU_TEST_SCREENSHOTS, {recursive:true});
await page.screenshot({path:process.env.FURU_TEST_SCREENSHOTS+'/'+name+'.png'});
};
async function fits(label) {
const overflow = await page.evaluate(() => [...document.querySelectorAll('html, body, main, .content, .panel, .modal, .modal-body')]
.filter(el => el.getClientRects().length && el.scrollWidth > el.clientWidth + 2)
.map(el => `${el.tagName}.${el.className}: ${el.scrollWidth} > ${el.clientWidth}`));
assert.deepEqual(overflow, [], label);
}
async function settle() { await page.waitForTimeout(200); }
async function navigate(view) {
if (await page.locator('.menu-toggle').isVisible()) await page.locator('.menu-toggle').click();
await page.locator('.nav-btn').filter({hasText:{reviews:'Review Queue',jobs:'Tasks',library:'Library Workbench',tools:'Library Tools',statistics:'Statistics',users:'Users',settings:'Settings'}[view]}).click();
await page.waitForFunction(v => Alpine.$data(document.querySelector('.admin-shell')).activeView === v, view);
await settle();
assert.equal(await page.locator('main').evaluate(el => el.inert), false);
}
// Navigate through the actual menu, testing both permanent and drawer modes.
for (const width of [320,390,768,1024,1440]) {
await page.setViewportSize({width,height:844}); await settle();
for (const view of ['reviews','jobs','library','tools','statistics','users','settings']) {
await navigate(view); await fits(`${width}: ${view}`);
if (width === 390 || width === 1440) await screenshot(`${width}-${view}`);
}
}
await page.setViewportSize({width:390,height:844}); await settle();
await page.locator('.menu-toggle').click(); await settle();
assert.equal(await page.locator('main').evaluate(el => el.inert), true);
await screenshot('390-navigation');
await page.keyboard.press('Shift+Tab');
assert.equal(await page.evaluate(() => document.activeElement.classList.contains('nav-player')), true);
await page.keyboard.press('Tab');
assert.equal(await page.evaluate(() => document.activeElement.hasAttribute('data-dialog-close')), true);
await page.keyboard.press('Escape'); await settle();
assert.equal(await page.evaluate(() => document.activeElement.classList.contains('menu-toggle')), true);
await page.locator('.menu-toggle').click(); await page.setViewportSize({width:1440,height:844}); await settle();
assert.equal(await page.locator('main').evaluate(el => el.inert), false);
assert.equal(await page.locator('.sidebar').evaluate(el => el.inert), false);
await page.setViewportSize({width:390,height:844}); await settle();
await navigate('jobs');
await page.locator('#task-pane-list tbody tr').first().click(); await settle();
assert.equal(await page.locator('#task-pane-list').isVisible(), false);
assert.equal(await page.locator('#task-pane-details').isVisible(), true);
await page.getByRole('button', {name:'Edit schedule',exact:true}).click();
await page.getByRole('textbox', {name:'Cron schedule'}).fill('0 15 * * * *');
await page.locator('#task-tab-logs').click();
await page.keyboard.press('ArrowLeft');
assert.equal(await page.getByRole('textbox', {name:'Cron schedule'}).inputValue(), '0 15 * * * *');
await fits('task editor');
await navigate('settings');
await page.locator('.section-jump select').selectOption('federation'); await settle();
assert.equal(await page.evaluate(() => document.activeElement.id), 'settings-federation');
await page.getByRole('button',{name:'Save settings',exact:true}).scrollIntoViewIfNeeded();
await fits('settings footer');
// Shared dialog lifecycle: trap focus, lock background, retain close affordance,
// scroll long content and restore focus to its trigger.
async function checkDialog(name) {
const dialog = page.locator('.modal:visible'); await dialog.waitFor(); await settle();
assert.equal(await page.locator('main').evaluate(el => el.inert), true);
await fits(name);
assert.ok((await dialog.locator('.modal-body').innerText()).trim().length > 0, name+' body populated');
const box = await dialog.boundingBox();
if (page.viewportSize().width < 768) assert.ok(Math.abs(box.height-page.viewportSize().height)<2, name+' full height');
await dialog.focus(); await page.keyboard.press('Shift+Tab');
assert.equal(await dialog.evaluate(el => el.contains(document.activeElement)), true);
await page.keyboard.press('Tab');
assert.equal(await page.evaluate(() => document.activeElement.hasAttribute('data-dialog-close')), true);
await screenshot(name);
await dialog.locator('.modal-body').evaluate(el => { el.scrollTop=el.scrollHeight; });
await fits(name+' bottom');
const close = await dialog.locator('[data-dialog-close]').boundingBox();
assert.ok(close.y >= 0 && close.y+close.height <= page.viewportSize().height, name+' close reachable');
const footer = dialog.locator('.dialog-actions:visible');
if (await footer.count()) {
const bottom = await footer.boundingBox();
assert.ok(bottom.y >= -1 && bottom.y+bottom.height <= page.viewportSize().height+1, name+' actions reachable');
}
await page.keyboard.press('Escape'); await settle();
assert.equal(await page.locator('.modal:visible').count(),0);
assert.equal(await page.locator('main').evaluate(el => el.inert),false);
}
await navigate('users');
await page.getByRole('button',{name:'Add user',exact:true}).click();
await checkDialog('390-add-user');
assert.equal(await page.evaluate(() => document.activeElement.textContent.trim()), 'Add user');
await page.locator('.users-table tbody tr').first().click();
await checkDialog('390-user-profile');
const review = {id:987654,status:'pending',review_type:'metadata',filename:'Very long track title '.repeat(8),display_path:'/inbox/'+'album/'.repeat(20),tags:[],normalized:{title:'Long song title',artist:'Test artist',notes:'Notes\n'.repeat(40)}};
await navigate('reviews');
await state((app,row) => {app.reviews.items=[row]; app.reviews.total=1; app.openReview(row);}, review);
await checkDialog('390-review');
await fits('populated reviews');
await navigate('library');
await state(async app => {app.libraryKind='releases'; await app.loadLibrary(); app.openEditor(app.library.items[0]);});
await page.waitForFunction(() => !Alpine.$data(document.querySelector('.admin-shell')).editorLoading);
await state(app => {app.editorDraft.release_tracks = Array.from({length:12}, (_,i)=>({...app.editorDraft.release_tracks[0],id:700000+i,title:'Very long track title '.repeat(8),disc_number:1,track_number:i+1}));});
await page.locator('.modal:visible input[x-model="editorDraft.title"]').waitFor({state:'visible'});
assert.equal(await page.locator('.modal:visible .release-track-row:visible').count(),12);
await checkDialog('390-release-editor');
await state(app => {
const detail = app.editorDetail;
app.mergeDetails=[detail,{...detail,item:{...detail.item,id:700001},title:'Second release'}];
app.mergeDraft={release_ids:[detail.item.id,700001],target_release_id:detail.item.id,title:detail.title,release_type:'album',hidden:'false',year:'2026',artist_ids:[],cover_file_id:null,tracks:app.editorDraft.release_tracks};
app.mergeOpen=true;
});
await checkDialog('390-merge');
// Short landscape viewport and desktop dialog geometry use the same contract.
for (const viewport of [{width:320,height:568},{width:844,height:390},{width:1440,height:900}]) {
await page.setViewportSize(viewport); await settle();
await state((app,row)=>app.openReview(row),review);
await checkDialog(`${viewport.width}-review`);
}
await page.setViewportSize({width:320,height:700}); await settle();
await navigate('statistics');
await state(async app => {
await app.loadStatistics();
app.statisticsData.ranking.items=[{key:'fixture',label:'Very long artist name '.repeat(12),detail:'long_identifier_'.repeat(20),plays:42,listeners:10,listened_seconds:10000,last_play_ms:Date.now()}];
app.statisticsData.history.items=[{user_id:1,listen_id:'fixture',user_name:'Listener '.repeat(12),title:'Long song name '.repeat(12),content_id:'fixture',artist_names:['Artist '.repeat(20)],release_title:'Album '.repeat(20),started_at_ms:Date.now(),listened_ms:60000,track_duration_ms:90000,qualified:true,ended_reason:'ended',device_name:'LongDeviceName'.repeat(20),source:'instance'}];
});
await settle(); await fits('320 populated statistics');
await navigate('tools');
await state(app => {
app.repairExpanded={snapshot:{artists:[{id:1,name:'Artist'}],releases:[{id:2,title:'Album',year:2026,release_type:'album',artist_ids:[1]}],tracks:[]}};
app.repairPlan={artists:[],releases:[{id:2,title:'Album '.repeat(30),year:2026,release_type:'album',artist_ids:[1]}],tracks:[],questions:[],delete:{artists:[],releases:[],tracks:[]}};
app.repairPlanOpen=true;
});
await page.locator('.repair-manual summary').click(); await settle();
await fits('320 manual metadata comparison');
const comparison=page.locator('.repair-manual');
assert.ok(await comparison.evaluate(el=>el.scrollWidth>el.clientWidth), 'wide comparison scrolls within its own region');
await screenshot('320-manual-comparison');
await navigate('users');
await page.locator('.users-table tbody tr').first().click();
await page.getByRole('button',{name:'Edit user',exact:true}).click();
await checkDialog('320-edit-user');
await page.locator('.menu-toggle').click();
await page.goBack(); await settle();
assert.equal(await page.locator('main').evaluate(el=>el.inert),false, 'browser Back closes navigation');
assert.deepEqual(errors, []);
console.log('PASS: 7 sections × 5 widths; drawer, task tabs, settings jump and all 5 dialogs, keyboard and long content.');
} finally { await browser.close(); }
})().catch(error => {console.error(error); process.exitCode=1;});
+63
View File
@@ -0,0 +1,63 @@
// Run only against a fresh disposable instance, with the import agent disabled.
const {chromium}=require(process.env.PLAYWRIGHT_MODULE || 'playwright');
const assert=require('node:assert/strict');
const {spawnSync}=require('node:child_process');
const base=process.env.FURU_TEST_URL || 'http://127.0.0.1:3019';
const container=process.env.FURU_TEST_PG_CONTAINER || 'furumi-import-playlist-test-pg';
function sql(statement) {
const result=spawnSync('docker',['exec','-i',container,'psql','-U','postgres','-d','furumi_import_test','-At','-v','ON_ERROR_STOP=1'],{input:statement,encoding:'utf8'});
assert.equal(result.status,0,result.stderr);return result.stdout.trim();
}
(async()=>{
const browser=await chromium.launch({headless:true,executablePath:process.env.CHROME_PATH || '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'});
try {
const context=await browser.newContext({viewport:{width:1440,height:1000}});
const page=await context.newPage();const errors=[];page.on('pageerror',e=>errors.push(e.message));
await page.goto(base+'/admin/setup');
await page.locator('[name=username]').fill('importer');
await page.locator('[name=password]').fill('import-test-password');
await page.locator('[name=confirm_password]').fill('import-test-password');
await page.locator('form button[type=submit]').click();await page.waitForURL('**/admin/v2');
await page.goto(base+'/');
await page.evaluate(()=>{Alpine.store('torrents').open();Alpine.store('torrents').showSourceTab('files');});
await page.locator('#direct-audio-file-input').setInputFiles([
{name:'theme.wav',mimeType:'audio/wav',buffer:Buffer.from('test-audio-one')},
{name:'credits.wav',mimeType:'audio/wav',buffer:Buffer.from('test-audio-two')},
]);
await page.locator('#local-target-playlist').selectOption('__new__');
await page.getByPlaceholder('New playlist name',{exact:true}).fill('Game Soundtrack');
await page.screenshot({path:'/tmp/furumi-import-desktop.png'});
await page.setViewportSize({width:390,height:844});
await page.screenshot({path:'/tmp/furumi-import-mobile.png'});
await page.getByRole('button',{name:'Upload selected files',exact:true}).click();
await page.waitForFunction(()=>!Alpine.store('torrents').localFilesUploading && Alpine.store('torrents').localFiles.length===0);
const history=await (await context.request.get(base+'/api/player/uploads/local/history')).json();
assert.equal(history.length,2,JSON.stringify(history));
const target=history[0].target_playlist_id;assert.ok(target>0);assert.equal(history[1].target_playlist_id,target);
assert.equal(sql('SELECT count(*) FROM furumusic__import_playlist_target;'),'2');
// Simulate the importer resolving both uploaded files to library tracks.
sql(`INSERT INTO furumusic__media_file (file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at)
SELECT 'audio',input_path,input_path,'audio/wav',14,source_sha256,'2026-11-12T00:00:00Z' FROM furumusic__import_playlist_target;
INSERT INTO furumusic__track (title,title_sort,release_id,duration_seconds,audio_file_id,is_hidden,created_at,updated_at)
SELECT original_filename,original_filename,0,120,id,false,'2026-11-12T00:00:00Z','2026-11-12T00:00:00Z' FROM furumusic__media_file;`);
assert.equal((await context.request.get(base+'/api/player/uploads/local/history')).status(),200);
assert.equal(sql(`SELECT count(*) FROM furumusic__playlist_track WHERE playlist_id=${target};`),'2');
await context.request.get(base+'/api/player/uploads/local/history');
assert.equal(sql(`SELECT count(*) FROM furumusic__playlist_track WHERE playlist_id=${target};`),'2');
const invalid=await context.request.post(base+'/api/player/uploads/local',{headers:{'X-Furumusic-Target-Playlist-Id':'99999','X-Furumusic-Filename':'bad.wav'},data:Buffer.from('bad')});
assert.equal(invalid.status(),400);
// Render the torrent picker with a local preview fixture; no external torrent network.
await page.setViewportSize({width:1440,height:1000});
await page.evaluate(()=>{
const s=Alpine.store('torrents');s.showSourceTab('torrents');s._stopRefresh();s._stopPoll();
s._applySession({job:{id:'preview-test',name:'Movie OST',status:'preview'},preview:{id:'preview-test',name:'Movie OST',total_size:20,files:[{index:0,name:'theme.flac',components:['theme.flac'],length:20,selected:true}]},selected_files:[0]});
});
await page.locator('#torrent-target-playlist').selectOption(String(target));
assert.equal(await page.evaluate(()=>Alpine.store('torrents').torrentPlaylistChoice),String(target));
await page.screenshot({path:'/tmp/furumi-torrent-playlist.png'});
await page.evaluate(()=>{Alpine.store('torrents').currentJob.status='paused';});
assert.equal(await page.locator('#torrent-target-playlist').isDisabled(),true);
assert.deepEqual(errors,[]);
console.log('PASS: file batch → new playlist, persistent destinations, imported tracks, idempotency, invalid destination, torrent picker, desktop/mobile');
} finally {await browser.close();}
})().catch(e=>{console.error(e);process.exitCode=1});
+181
View File
@@ -0,0 +1,181 @@
// Run against a fresh disposable instance with tests/metadata_repair_fixture.sql.
// FURU_REPAIR_TEST_PG must name its disposable PostgreSQL container.
const {chromium}=require(process.env.PLAYWRIGHT_MODULE || 'playwright');
const assert=require('node:assert/strict');
const {readFileSync}=require('node:fs');
const {spawnSync}=require('node:child_process');
const base=process.env.FURU_TEST_URL || 'http://127.0.0.1:3029';
const container=process.env.FURU_REPAIR_TEST_PG || 'furumi-repair-test-pg';
function sql(statement) {
const result=spawnSync('docker',['exec','-i',container,'psql','-U','postgres','-d','furumi_repair_test','-At','-v','ON_ERROR_STOP=1'],{input:statement,encoding:'utf8'});
assert.equal(result.status,0,result.stderr);
return result.stdout.trim();
}
const emptyPlan=()=>({artists:[],releases:[],tracks:[],questions:[],delete:{artists:[],releases:[],tracks:[]}});
(async()=>{
const browser=await chromium.launch({headless:true,executablePath:process.env.CHROME_PATH || '/run/current-system/sw/bin/chromium',args:['--no-sandbox']});
try {
const context=await browser.newContext({viewport:{width:1440,height:1000}});
if (process.env.FURU_TEST_ASSETS) {
for (const [url,file] of [['alpinejs@3/dist/cdn.min.js','alpine.js'],['lucide@latest/dist/umd/lucide.min.js','lucide.js']]) {
await context.route('https://cdn.jsdelivr.net/npm/'+url,route=>route.fulfill({path:process.env.FURU_TEST_ASSETS+'/'+file}));
}
}
const api=context.request;
assert.equal((await api.post(base+'/admin/v2/api/metadata-fix/apply',{data:{snapshot:{},plan:{},instruction:'test'}})).status()>=400,true);
const page=await context.newPage(); const errors=[]; page.on('pageerror',error=>errors.push(error.message));
await page.goto(base+'/admin/setup');
if (page.url().includes('/admin/setup')) {
await page.locator('[name=username]').fill('repair_admin');
await page.locator('[name=password]').fill('repair-test-password');
await page.locator('[name=confirm_password]').fill('repair-test-password');
await page.locator('button[type=submit]').click();
await page.waitForURL('**/admin/v2');
} else {
await page.goto(base+'/login');
await page.locator('[name=username]').fill('repair_admin');
await page.locator('[name=password]').fill('repair-test-password');
await page.locator('button[type=submit]').click();
await page.waitForURL(base+'/');
await page.goto(base+'/admin/v2');
}
if (!process.env.FURU_REPAIR_SKIP_SEED) sql(readFileSync(__dirname+'/metadata_repair_fixture.sql','utf8'));
const post=async(path,data,status=200)=>{
const response=await api.post(base+'/admin/v2/api/metadata-fix/'+path,{data,timeout:240000});
assert.equal(response.status(),status,await response.text());
return response.json();
};
const expanded=await post('expand',{selection:{artists:[2719],releases:[],tracks:[]}});
const before=expanded.snapshot;
assert.equal(before.releases.length,4); assert.equal(before.tracks.length,10);
// Reproduce the reported request using ONLY the four release checkboxes.
if (process.env.FURU_REPAIR_TEST_MODEL) {
const selection={artists:[],releases:before.releases.map(r=>r.id),tracks:[]};
const instruction=`релизы #ИЗИРОК на самом деле один релиз типа компиляция 2021 года. тебе нужно сделать план по объединению в один релиз. вот полный треклист по порядку 01. Старик и братья
02. Потрошитель
03. Последняя песня
04. Песня для твоей подруги
05. Просто я сегодня... (feat. Перегаз)
06. Отзвуки тьмы
07. Битва за Москву
08. Настроение лето
09. Пробил час
10. Цусима`;
const proposed=await post('plan',{selection,instruction});
assert.equal(proposed.snapshot.artists.length,0);
assert.equal(proposed.snapshot.tracks.length,10);
assert.deepEqual(proposed.plan.artists,[]);
assert.deepEqual(proposed.plan.delete.artists,[]);
assert.deepEqual(proposed.plan.delete.tracks,[]);
const destination=proposed.plan.releases.find(r=>r.release_type==='compilation' && r.year===2021);
assert.ok(destination,JSON.stringify(proposed.plan));
const target=destination.id ? 'existing:'+destination.id : 'new:'+destination.key;
for (const [index,track] of before.tracks.entries()) {
const edit=proposed.plan.tracks.find(t=>t.id===track.id);
assert.equal(edit?.target_release || 'existing:'+track.release_id,target);
assert.equal(edit?.track_number ?? track.track_number,index+1);
assert.deepEqual(edit?.artist_ids || [2719],[2719]);
}
const result=await post('apply',{snapshot:proposed.snapshot,plan:proposed.plan,instruction});
assert.equal(sql('SELECT count(*) FROM furumusic__track'),'10');
assert.equal(sql('SELECT count(*) FROM furumusic__release'),'1');
assert.equal(sql('SELECT name FROM furumusic__artist'),'Radio Tapok');
await post('undo',{history_id:result.history_id});
assert.deepEqual((await post('expand',{selection:expanded.selection})).snapshot,before);
const excluded=await post('plan',{selection,excluded_track_ids:[33683],instruction:'Ничего не меняй. Верни пустой план.'});
assert.equal(excluded.snapshot.tracks.length,9);
assert.equal(excluded.snapshot.tracks.some(t=>t.id===33683),false);
assert.deepEqual(excluded.plan.tracks,[]);
const recovered=await post('plan',{selection,instruction:'__TEST_INVALID_ARTIST__ Объедини четыре релиза в компиляцию 2021 года.'});
assert.deepEqual(recovered.plan.artists,[]);
assert.equal(recovered.plan.releases[0].year,2021);
console.log('Release-only scope, exact ordered tracklist, model correction and exclusions passed.');
}
const artistIds=track=>before.track_artists.filter(link=>link.owner_id===track.id).map(link=>link.artist_id);
const merge={...emptyPlan(),releases:[{id:null,key:'collection',title:'#ИЗИРОК Сборник',release_type:'compilation',year:2021,artist_ids:[2719]}],tracks:before.tracks.map(track=>({id:track.id,title:track.title,target_release:'new:collection',track_number:track.track_number,disc_number:track.disc_number,year:track.year,artist_ids:artistIds(track)})),delete:{artists:[],releases:before.releases.map(release=>release.id),tracks:[]}};
await page.getByRole('button',{name:'Library Tools',exact:true}).click();
const tools=page.locator('.content').filter({has:page.getByText('Metadata assistant',{exact:true})});
await tools.locator('select').first().selectOption('artists');
await tools.getByPlaceholder('Search library…').fill('Radio Tapok');
await tools.locator('.repair-search-results button').first().click();
await tools.getByRole('button',{name:'Show related',exact:true}).click();
await page.waitForFunction(()=>Alpine.$data(document.querySelector('.admin-shell')).repairRowsCount()===15);
await tools.getByRole('button',{name:'Deselect all',exact:true}).click();
assert.equal(await tools.locator('.repair-entity input:checked').count(),0);
assert.equal(await tools.locator('.repair-entity input[type=checkbox]').count(),15);
for (const release of before.releases) {
await tools.getByRole('checkbox',{name:new RegExp('^#ИЗИРОК #' + release.id + ' ')}).check();
}
assert.equal(await tools.locator('.repair-entity input:checked').count(),14);
assert.equal(await tools.getByRole('checkbox',{name:'Radio Tapok #2719',exact:true}).isChecked(),false);
let calls=0;
await page.route('**/metadata-fix/plan',async route=>{
const body=route.request().postDataJSON(); calls++;
assert.deepEqual(body.selection,{...expanded.selection,artists:[]});
if (calls===1) await route.fulfill({json:{snapshot:before,plan:merge,message:'Объединю все 10 треков в сборник 2021 года.'}});
else {
assert.equal(body.current_plan.releases[0].year,2021);
assert.equal(body.conversation.length,2);
await route.fulfill({json:{snapshot:before,plan:{...merge,releases:[{...merge.releases[0],year:2022}]},message:'Год сборника изменён на 2022.'}});
}
});
const composer=tools.getByRole('textbox',{name:'Message to metadata assistant'});
await composer.fill('Объедини #ИЗИРОК в #ИЗИРОК Сборник, год 2021');
await tools.getByRole('button',{name:'Send',exact:true}).click();
await tools.getByText('Объединю все 10 треков в сборник 2021 года.',{exact:true}).waitFor();
const plan=tools.locator('details.repair-plan');
assert.equal(await plan.getAttribute('open'),null);
await plan.locator(':scope > summary').click();
await plan.getByText('Edit fields manually',{exact:true}).click();
assert.equal(await plan.locator('.repair-diff').nth(1).locator('input[type=number]').inputValue(),'2021');
await composer.fill('Сделай год 2022');
await tools.getByRole('button',{name:'Send',exact:true}).click();
await tools.getByText('Год сборника изменён на 2022.',{exact:true}).waitFor();
assert.equal(await tools.locator('details.repair-plan').count(),1);
assert.equal(await plan.locator('.repair-diff').nth(1).locator('input[type=number]').inputValue(),'2022');
await plan.getByText('Edit fields manually',{exact:true}).click();
await plan.locator(':scope > summary').scrollIntoViewIfNeeded();
await page.screenshot({path:'/tmp/furumi-repair-desktop.png'});
await page.setViewportSize({width:390,height:844});
assert.equal(await page.evaluate(()=>document.documentElement.scrollWidth<=innerWidth),true);
await page.screenshot({path:'/tmp/furumi-repair-mobile.png'});
await page.setViewportSize({width:1440,height:1000});
// Apply the 2021 plan against the original snapshot, then undo it.
const applied=await post('apply',{snapshot:before,plan:merge,instruction:'Merge #ИЗИРОК'});
assert.equal(sql("SELECT title || '|' || year || '|' || total_tracks FROM furumusic__release"),'#ИЗИРОК Сборник|2021|10');
assert.equal(sql('SELECT count(*) FROM furumusic__track'),'10');
assert.equal(sql('SELECT count(*) FROM furumusic__media_file'),'10');
assert.equal(sql('SELECT count(*) FROM furumusic__playlist_track'),'2');
await post('undo',{history_id:applied.history_id});
assert.deepEqual((await post('expand',{selection:expanded.selection})).snapshot,before);
const deletion={...emptyPlan(),delete:{artists:[],releases:[],tracks:[33683,33684]}};
const removed=await post('apply',{snapshot:before,plan:deletion,instruction:'Delete two tracks'});
assert.equal(sql('SELECT count(*) FROM furumusic__track'),'8');
assert.equal(sql('SELECT count(*) FROM furumusic__playlist_track'),'0');
assert.equal(sql('SELECT count(*) FROM furumusic__track_ref WHERE local_track_id IS NULL'),'2');
assert.equal(sql('SELECT queue_json FROM furumusic__playback_state'),'[33685]');
await post('undo',{history_id:removed.history_id});
assert.equal(sql('SELECT count(*) FROM furumusic__playlist_track'),'2');
assert.equal(sql('SELECT local_track_id FROM furumusic__track_ref ORDER BY content_id'),'33683\n33684');
assert.equal(sql('SELECT current_track_id || \'|\' || position_ms || \'|\' || queue_json FROM furumusic__playback_state'),'33683|1234|[33683,33684,33685]');
assert.deepEqual((await post('expand',{selection:expanded.selection})).snapshot,before);
const artistRemoval=await post('apply',{snapshot:before,plan:{...emptyPlan(),delete:{artists:[2719],releases:[],tracks:[]}},instruction:'Delete artist'});
assert.equal(sql('SELECT count(*) FROM furumusic__artist'),'0');
assert.equal(sql('SELECT count(*) FROM furumusic__track'),'10');
assert.equal(sql('SELECT count(*) FROM furumusic__track_artist'),'0');
await post('undo',{history_id:artistRemoval.history_id});
assert.deepEqual((await post('expand',{selection:expanded.selection})).snapshot,before);
const invalid={...emptyPlan(),delete:{artists:[],releases:[4256],tracks:[]}};
await post('apply',{snapshot:before,plan:invalid,instruction:'Invalid deletion'},400);
// A changed detached reference must block undo atomically.
const conflict=await post('apply',{snapshot:before,plan:deletion,instruction:'Delete before playback changes'});
sql("UPDATE furumusic__playback_state SET position_ms=9876");
await post('undo',{history_id:conflict.history_id},409);
assert.equal(sql('SELECT count(*) FROM furumusic__track'),'8');
sql('UPDATE furumusic__playback_state SET position_ms=0');
await post('undo',{history_id:conflict.history_id});
assert.equal(sql('SELECT count(*) FROM furumusic__track'),'10');
assert.deepEqual(errors,[]);
console.log('Metadata Repair browser, merge, deletion, undo and conflict checks passed.');
} finally { await browser.close(); }
})().catch(error=>{console.error(error);process.exit(1);});
+89
View File
@@ -0,0 +1,89 @@
// Run against a fresh disposable instance and the named disposable PostgreSQL container.
// PLAYWRIGHT_MODULE may point to an existing Playwright installation.
const {chromium} = require(process.env.PLAYWRIGHT_MODULE || 'playwright');
const assert = require('node:assert/strict');
const {spawnSync} = require('node:child_process');
const base = process.env.FURU_TEST_URL || 'http://127.0.0.1:3018';
(async () => {
const browser = await chromium.launch({headless:true, executablePath:process.env.CHROME_PATH || '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'});
try {
const context = await browser.newContext({viewport:{width:1440,height:1100}, ignoreHTTPSErrors:true});
const page = await context.newPage(); const errors=[];
page.on('pageerror', error => errors.push(error.message));
const anonymous = await context.request.get(`${base}/admin/v2/api/statistics`);
assert.equal(anonymous.status(),401);
await page.goto(`${base}/admin/setup`);
await page.getByLabel('Username', {exact:true}).fill('alice');
await page.getByLabel('Password', {exact:true}).fill('statistics-test-password');
await page.locator('[name=confirm_password]').fill('statistics-test-password');
await page.locator('form button[type=submit]').click();
await page.waitForURL('**/admin/v2');
await page.getByRole('button', {name:'Users',exact:true}).click();
await page.getByRole('button', {name:'Add user',exact:true}).click();
const editor = page.locator('.modal-backdrop').filter({has:page.getByRole('button',{name:'Save user',exact:true})});
await editor.getByLabel('username', {exact:true}).fill('bob');
await editor.getByLabel('password', {exact:true}).fill('statistics-test-password');
await editor.getByRole('button',{name:'Save user',exact:true}).click();
await editor.waitFor({state:'hidden'});
const sql = `INSERT INTO furumusic__listen_event
(user_id,listen_id,content_id,local_track_id,origin_device_id,started_at_ms,listened_ms,track_duration_ms,ended_reason,qualified,metadata_json,created_at)
SELECT 1,'ui-'||n,'content-one',NULL,'web-a',1793491200000+n*1000,180000,180000,'"finished"',true,
'{"title":"First song","artist_names":["Artist A"],"release_title":"Album"}'::jsonb,'2026-11-01T00:00:00Z' FROM generate_series(1,30) n;
INSERT INTO furumusic__listen_event
(user_id,listen_id,content_id,local_track_id,origin_device_id,started_at_ms,listened_ms,track_duration_ms,ended_reason,qualified,metadata_json,created_at)
VALUES (2,'ui-bob','content-one',NULL,'web-b',1793664000000,90000,180000,'"skipped"',true,
'{"title":"First song","artist_names":["Artist A"],"release_title":"Album"}','2026-11-03T00:00:00Z');`;
const seeded = spawnSync('docker',['exec','-i','furumi-statistics-test-pg','psql','-U','postgres','-d','furumi_statistics_test','-v','ON_ERROR_STOP=1'],{input:sql, encoding:'utf8'});
assert.equal(seeded.status,0,seeded.stderr);
await page.getByRole('button',{name:'Statistics',exact:true}).click();
const area = page.locator('.content').filter({has:page.getByText('Listening statistics',{exact:true})});
await area.getByRole('button',{name:'Artist A',exact:true}).first().waitFor();
const artistResponse = page.waitForResponse(r => r.url().includes('/api/statistics?') && r.url().includes('artist=Artist+A'));
await area.getByRole('button',{name:'Artist A',exact:true}).first().click();
assert.equal((await artistResponse).status(),200);
await area.getByRole('button',{name:'bob',exact:true}).first().waitFor();
const bobResponse = page.waitForResponse(r => r.url().includes('/api/statistics?') && r.url().includes('user_id=2'));
await area.getByRole('button',{name:'bob',exact:true}).first().click();
const bob = await (await bobResponse).json();
assert.equal(bob.summary.plays,1); assert.equal(bob.history.items[0].user_name,'bob');
assert.equal(bob.history.items[0].title,'First song');
const cleared = page.waitForResponse(r => r.url().includes('/api/statistics?') && !r.url().includes('user_id=') && !r.url().includes('artist='));
await area.getByRole('button',{name:'All listeners and music'}).click();
await cleared;
await area.getByText('Loading statistics…',{exact:true}).waitFor({state:'hidden'});
await page.screenshot({path:'/tmp/furumi-statistics-desktop.png',fullPage:false});
await page.setViewportSize({width:390,height:844});
await page.screenshot({path:'/tmp/furumi-statistics-mobile.png',fullPage:false});
await page.setViewportSize({width:1440,height:1100});
const usersResponse = await context.request.get(`${base}/admin/v2/api/users`); const users = await usersResponse.json();
assert.equal(users.items.find(u=>u.username==='bob').plays,1);
const detailResponse = await context.request.get(`${base}/admin/v2/api/users/2`); const detail = await detailResponse.json();
assert.equal(detail.stats.plays,1); assert.equal(detail.recent_plays[0].title,'First song');
const next = await context.request.get(`${base}/admin/v2/api/statistics?from=all&history_page=2`);
assert.equal((await next.json()).history.items.length,6);
for (const path of ['/admin/debug','/admin/users','/admin/settings','/admin/artists','/admin/reviews','/admin/jobs']) {
assert.equal((await context.request.get(base+path)).status(),404,path);
}
assert.equal((await context.request.get(`${base}/admin/v2/api/statistics?from=invalid`)).status(),400);
const jobs = await (await context.request.get(`${base}/admin/v2/api/jobs`)).json();
const job = jobs.find(j => j.name === 'metadata_backfill');
if (job.enabled) assert.equal((await context.request.post(`${base}/admin/v2/api/jobs/${job.name}/toggle`)).status(),200);
assert.equal((await context.request.post(`${base}/admin/v2/api/jobs/${job.name}/schedule`,{data:{cron:'0 17 3 * * *'}})).status(),200);
await context.request.get(`${base}/admin/v2/api/dashboard`);
const changedJob = (await (await context.request.get(`${base}/admin/v2/api/jobs`)).json()).find(j=>j.name===job.name);
assert.equal(changedJob.enabled,false); assert.equal(changedJob.cron_expression,'0 17 3 * * *');
const ownDelete = await context.request.post(`${base}/admin/v2/api/users/manage`, {data:{action:'delete',id:1}});
assert.equal(ownDelete.status(),400);
const listenerContext = await browser.newContext({ignoreHTTPSErrors:true});
const login = await listenerContext.newPage();
await login.goto(`${base}/login`);
await login.locator('[name=username]').fill('bob');
await login.locator('[name=password]').fill('statistics-test-password');
await login.locator('form button[type=submit]').click();
await login.waitForURL(base + '/');
assert.equal((await listenerContext.request.get(`${base}/admin/v2/api/statistics`)).status(),403);
await listenerContext.close();
assert.deepEqual(errors,[]);
console.log('PASS: setup, user creation, artist → listeners → user history, counts, pagination, invalid filters, v1 removal, desktop/mobile rendering');
} finally { await browser.close(); }
})().catch(error => {console.error(error); process.exitCode=1});
+75
View File
@@ -0,0 +1,75 @@
const assert = require('node:assert/strict');
const {readFileSync} = require('node:fs');
const {test} = require('node:test');
const vm = require('node:vm');
const {randomUUID} = require('node:crypto');
const template = readFileSync(`${__dirname}/../templates/player/scripts.html`, 'utf8');
function downloads(fetchImpl) {
let code = template.slice(template.indexOf(" Alpine.store('torrents', {"), template.indexOf(" Alpine.store('playlists', {"));
code = code.replace(/\{\{[^}]+\}\}/g,'true').replace(/sourceTab: .*?,\n/,"sourceTab: 'files',\n");
const stores={playlists:{list:[{id:10,title:'Mine',kind:'user',is_own:true},{id:20,title:'Other',kind:'user',is_own:false}],reload:async()=>{}}};
const requests=[];
class XHR {
headers={}; upload={}; status=200; responseText='{}';
open(method,url) {this.url=url;}
setRequestHeader(key,value) {this.headers[key]=value;}
send(file) {requests.push({file,headers:this.headers});this.onload();}
}
const context=vm.createContext({Alpine:{store:(name,value)=>value?(stores[name]=value):stores[name]},fetch:fetchImpl,
T:new Proxy({}, {get:(_,key)=>key}),crypto:{randomUUID},XMLHttpRequest:XHR,redirectOnUnauthorized:()=>{},console,setInterval:()=>0,clearInterval:()=>{}});
vm.runInContext(code,context);
const store=stores.torrents;
store._poll=()=>{};store.loadSessions=async()=>{};store.loadAgentStatus=async()=>{};store.loadLocalUploadHistory=async()=>{};
return {store,requests};
}
test('destinations are independent, owned playlists only, new titles required',()=>{
const {store:s}=downloads();
assert.deepEqual(Array.from(s.youtubeOwnedPlaylists(),p=>p.id),[10]);
s.localPlaylistChoice='__new__';assert.equal(s.importDestinationValid('local'),false);
assert.equal(s.importDestinationValid('torrent'),true);
s.localFiles=[{name:'song.flac',webkitRelativePath:'Soundtrack/song.flac'}];s.importPlaylistChoiceChanged('local');
assert.equal(s.localNewPlaylistTitle,'Soundtrack');assert.equal(s.importDestinationValid('local'),true);
});
test('failed torrent starts reuse the newly created playlist and send only selected files',async()=>{
const calls=[];
const {store:s}=downloads(async(url,opts)=>{
calls.push({url,data:JSON.parse(opts.body)});
return url==='/api/player/playlists'?{ok:true,json:async()=>({id:33,title:'Soundtrack',kind:'user',is_own:true})}:{ok:false,json:async()=>({error:'retry'})};
});
s.previewData={id:'torrent-1'};s.selected=new Set([1,3]);s.torrentPlaylistChoice='__new__';s.torrentNewPlaylistTitle='Soundtrack';
await s.start();await s.start();
assert.equal(calls.filter(c=>c.url==='/api/player/playlists').length,1);
assert.deepEqual(calls[1].data,{selected_files:[1,3],target_playlist_id:33});
assert.deepEqual(calls[2].data,calls[1].data);assert.equal(s.loading,false);
});
test('local files carry the same playlist destination and retries retain upload IDs',async()=>{
const {store:s,requests}=downloads();const f={name:'a.flac',size:10};
s.setLocalFiles([f]);s.localTargetPlaylistId=10;
await s.uploadLocalFile(f,0,10);await s.uploadLocalFile(f,0,10);
assert.equal(requests[0].headers['X-Furumusic-Target-Playlist-Id'],'10');
assert.equal(requests[0].headers['X-Furumusic-Upload-Id'],requests[1].headers['X-Furumusic-Upload-Id']);
s.clearLocalFiles();s.setLocalFiles([f]);await s.uploadLocalFile(f,0,10);
assert.equal(requests[2].headers['X-Furumusic-Target-Playlist-Id'],undefined);
});
test('partially failed batches keep their destination, create one playlist and retry remaining files',async()=>{
let creates=0;let attempts=0;
const {store:s}=downloads(async(url)=>{
if(url==='/api/player/playlists') {creates++;return {ok:true,json:async()=>({id:44})};}
return {ok:true};
});
s.setLocalFiles([{name:'a.mp3',size:1},{name:'b.mp3',size:1}]);s.localPlaylistChoice='__new__';s.localNewPlaylistTitle='OST';
s.uploadLocalFile=async()=>{attempts++;if(attempts===2)throw Error('offline');return {};};
await s.uploadLocalFiles();assert.equal(s.localFiles.length,1);assert.equal(s.localPlaylistLocked,true);
assert.equal(s.localTargetPlaylistId,44);await s.uploadLocalFiles();
assert.equal(creates,1);assert.equal(s.localFiles.length,0);assert.equal(s.localFilesUploading,false);
});
test('playlist creation failure leaves the batch editable and does not signal upload completion',async()=>{
const calls=[];const {store:s}=downloads(async(url)=>{calls.push(url);return {ok:false,json:async()=>({error:'failed'})};});
s.setLocalFiles([{name:'a.mp3',size:1}]);s.localPlaylistChoice='__new__';s.localNewPlaylistTitle='OST';
await s.uploadLocalFiles();assert.equal(s.localPlaylistLocked,false);assert.equal(s.localFilesUploading,false);
assert.deepEqual(calls,['/api/player/playlists']);assert.equal(s.localFiles.length,1);
});
test('torrent destination locks after start',()=>{
const {store:s}=downloads();s.currentJob={status:'preview'};assert.equal(s.torrentDestinationLocked(),false);
s.currentJob.status='paused';assert.equal(s.torrentDestinationLocked(),true);
});
+45
View File
@@ -0,0 +1,45 @@
INSERT INTO furumusic__artist (id,name,is_hidden,name_sort,model_name,updated_at,created_at) VALUES (2719,'Radio Tapok',false,'radio tapok','unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K','2026-11-15T23:13:56Z','2026-01-01T00:00:00Z');
INSERT INTO furumusic__release (id,year,title,is_hidden,model_name,title_sort,updated_at,total_discs,release_type,total_tracks,cover_file_id,created_at) VALUES (4256,2018,'#ИЗИРОК',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K','#изирок','2026-11-15T23:25:33Z',NULL,'album',NULL,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__release (id,year,title,is_hidden,model_name,title_sort,updated_at,total_discs,release_type,total_tracks,cover_file_id,created_at) VALUES (4257,2019,'#ИЗИРОК',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K','#изирок','2026-11-15T23:25:34Z',NULL,'album',NULL,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__release (id,year,title,is_hidden,model_name,title_sort,updated_at,total_discs,release_type,total_tracks,cover_file_id,created_at) VALUES (4258,2020,'#ИЗИРОК',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K','#изирок','2026-11-15T23:25:46Z',NULL,'ep',NULL,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__release (id,year,title,is_hidden,model_name,title_sort,updated_at,total_discs,release_type,total_tracks,cover_file_id,created_at) VALUES (4259,2021,'#ИЗИРОК',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K','#изирок','2026-11-15T23:25:47Z',NULL,'ep',NULL,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33683,'audio','/tmp/test-33683.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033683','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33683,2018,'Старик и братья',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4256,'старик и братья','2026-11-15T23:25:32Z',NULL,1,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33683,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33684,'audio','/tmp/test-33684.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033684','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33684,2018,'Потрошитель',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4256,'потрошитель','2026-11-15T23:25:33Z',NULL,2,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33684,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33685,'audio','/tmp/test-33685.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033685','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33685,2018,'Последняя песня',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4256,'последняя песня','2026-11-15T23:25:33Z',NULL,3,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33685,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33686,'audio','/tmp/test-33686.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033686','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33686,2018,'Песня для твоей подруги',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4256,'песня для твоей подруги','2026-11-15T23:25:33Z',NULL,4,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33686,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33687,'audio','/tmp/test-33687.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033687','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33687,2018,'Просто я сегодня...',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4256,'просто я сегодня...','2026-11-15T23:25:33Z',NULL,5,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33687,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33688,'audio','/tmp/test-33688.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033688','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33688,2019,'Отзвуки тьмы',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4257,'отзвуки тьмы','2026-11-15T23:25:34Z',NULL,6,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33688,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33689,'audio','/tmp/test-33689.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033689','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33689,2019,'Битва за Москву',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4257,'битва за москву','2026-11-15T23:25:34Z',NULL,7,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33689,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33690,'audio','/tmp/test-33690.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033690','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33690,2020,'Настроение лето',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4258,'настроение лето','2026-11-15T23:25:46Z',NULL,8,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33690,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33691,'audio','/tmp/test-33691.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033691','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33691,2020,'Пробил час',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4258,'пробил час','2026-11-15T23:25:47Z',NULL,9,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33691,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33692,'audio','/tmp/test-33692.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033692','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33692,2021,'Цусима',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4259,'цусима','2026-11-15T23:25:47Z',NULL,10,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33692,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__release_artist (release_id,artist_id,position) VALUES (4256,2719,0);
INSERT INTO furumusic__release_artist (release_id,artist_id,position) VALUES (4257,2719,0);
INSERT INTO furumusic__release_artist (release_id,artist_id,position) VALUES (4258,2719,0);
INSERT INTO furumusic__release_artist (release_id,artist_id,position) VALUES (4259,2719,0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33683,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33684,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33685,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33686,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33687,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33688,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33689,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33690,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33691,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33692,2719,'main',0);
INSERT INTO furumusic__playlist (id,owner_id,title,is_public,created_at,updated_at) VALUES (1,1,'Repair test',false,'2026-01-01T00:00:00Z','2026-01-01T00:00:00Z');
INSERT INTO furumusic__playlist_track (playlist_id,track_id,position,added_at,added_by_user_id) VALUES (1,33683,0,'2026-01-01T00:00:00Z',1);
INSERT INTO furumusic__track_ref (content_id,local_track_id,title,created_at,updated_at) VALUES ('content-33683',33683,'Старик и братья','2026-01-01T00:00:00Z','2026-01-01T00:00:00Z');
INSERT INTO furumusic__playlist_track (playlist_id,track_id,position,added_at,added_by_user_id) VALUES (1,33684,1,'2026-01-01T00:00:00Z',1);
INSERT INTO furumusic__track_ref (content_id,local_track_id,title,created_at,updated_at) VALUES ('content-33684',33684,'Потрошитель','2026-01-01T00:00:00Z','2026-01-01T00:00:00Z');
INSERT INTO furumusic__playback_state (user_id,current_track_id,position_ms,queue_json,queue_position,shuffle,repeat_mode,volume,updated_at) VALUES (1,33683,1234,'[33683,33684,33685]',0,false,'off',1.0,'2026-01-01T00:00:00Z');
+59
View File
@@ -0,0 +1,59 @@
const assert = require('node:assert/strict');
const {readFileSync} = require('node:fs');
const {test} = require('node:test');
const vm = require('node:vm');
const template = readFileSync(`${__dirname}/../templates/player/scripts.html`, 'utf8');
function player(fetchImpl = async () => ({ok:true}), beacon = () => true, guest = false) {
// Exercise the production methods with audio and network stubs.
const methods = template.slice(template.indexOf(' _recordHistory(endedReason'), template.indexOf(' _sendNowPlaying()'));
const audio = {currentTime:60};
const context = vm.createContext({GUEST:guest, audio, fetch:fetchImpl, navigator:{sendBeacon:beacon}, Blob,
globalThis:{crypto:{randomUUID:()=> 'uuid'}}, setTimeout: fn => { fn(); }, console});
vm.runInContext('this.methods = {' + methods + '};', context);
return Object.assign(context.methods, {
currentTrack:{id:8,duration_seconds:180}, _historyTrack:{id:8,duration_seconds:180},
_localSourceTrackId:8, _listenId:'event1', _playbackStartedAt:123456,
_historyRecorded:false, _listenedSeconds:60, _lastAudioTime:60, isPlaying:true,
});
}
const flush = () => new Promise(resolve => setImmediate(resolve));
test('switching tracks records short sessions, and completion is not counted twice', async () => {
const calls=[]; const p=player(async (_url, options)=> {calls.push(JSON.parse(options.body)); return {ok:true};});
p._listenedSeconds=8; p._recordHistory('replaced'); await flush();
assert.equal(calls[0].duration_listened,8); assert.equal(calls[0].ended_reason,'replaced');
p._recordHistory('skipped'); await flush(); assert.equal(calls.length,1);
});
test('natural finish records final duration; seeking does not create listened time', async () => {
const calls=[]; const p=player(async (_url, options)=> {calls.push(JSON.parse(options.body)); return {ok:true};});
p._listenedSeconds=179.4; p._recordHistory('finished'); await flush();
assert.equal(calls[0].duration_listened,180); assert.equal(calls[0].completed,true);
p._listenedSeconds=0; assert.equal(p._historyListenedSeconds(false),0);
});
test('failed submission retries the original event even after track changes', async () => {
const calls=[]; const p=player(async (_url,options)=> {calls.push(JSON.parse(options.body)); return {ok:calls.length>1,status:503};});
p._recordHistory('skipped'); p.currentTrack={id:9}; p._listenId='event2';
await flush(); assert.equal(calls.length,2); assert.deepEqual(calls[0], calls[1]);
assert.equal(calls[0].track_id,8);
});
test('page exit uses beacon and does not duplicate a recorded event', () => {
const calls=[]; const p=player(()=>assert.fail('unexpected fetch'), (url,blob)=>{calls.push({url,blob});return true;});
p._recordHistory('stopped',true); p._recordHistory('stopped',true);
assert.equal(calls.length,1); assert.equal(calls[0].url,'/api/player/history');
});
test('remote UI updates cannot attribute local audio to the wrong track', async () => {
let body; const p=player(async (_url,options)=> {body=JSON.parse(options.body);return {ok:true}});
p.currentTrack={id:999}; p._recordHistory('replaced'); await flush(); assert.equal(body.track_id,8);
});
test('unstarted tracks and sub-five-second interrupted sessions are not recorded', async () => {
const p=player(()=>assert.fail('unexpected fetch'));
p._playbackStartedAt=null; p._recordHistory('finished');
p._playbackStartedAt=123; p._listenedSeconds=4; p._recordHistory('skipped'); await flush();
assert.equal(p._historyRecorded,false);
});
test('guest listening never writes personal history or sends a beacon', async () => {
const calls = [];
const p = player(async () => {calls.push('fetch'); return {ok:true};}, () => {calls.push('beacon'); return true;}, true);
p._recordHistory('finished'); p._recordHistory('stopped', true);
await flush(); assert.deepEqual(calls, []);
});
+31
View File
@@ -0,0 +1,31 @@
CREATE TEMP TABLE furumusic__user (id bigint PRIMARY KEY, username text, display_name text);
CREATE TEMP TABLE furumusic__fed_device_identity (user_id bigint PRIMARY KEY, device_id text);
CREATE TEMP TABLE furumusic__fed_device (user_id bigint, device_id text, name text, PRIMARY KEY(user_id, device_id));
CREATE TEMP TABLE furumusic__listen_event (
user_id bigint, listen_id text, content_id text, local_track_id bigint, origin_device_id text,
started_at_ms bigint, listened_ms bigint, track_duration_ms bigint, ended_reason text,
qualified boolean, metadata_json jsonb, PRIMARY KEY(user_id, listen_id)
);
CREATE TEMP TABLE furumusic__track (id bigint);
CREATE TEMP TABLE furumusic__release (id bigint);
CREATE TEMP TABLE furumusic__artist (id bigint);
CREATE TEMP TABLE furumusic__playlist (id bigint);
CREATE TEMP TABLE furumusic__media_file (file_size_bytes bigint, audio_format text, file_type text);
CREATE TEMP TABLE furumusic__pending_review (status text);
CREATE TEMP TABLE furumusic__job_run (status text);
CREATE TEMP TABLE furumusic__lastfm_scrobble_outbox (status text);
INSERT INTO furumusic__user VALUES (1, 'alice', 'Alice'), (2, 'bob', 'Bob'), (3, 'silent', NULL);
INSERT INTO furumusic__fed_device_identity VALUES (1, 'web-a'), (2, 'web-b');
INSERT INTO furumusic__fed_device VALUES (1, 'phone', 'Alice phone');
INSERT INTO furumusic__listen_event
SELECT 1, 'listen-' || n, 'content-one', NULL, 'web-a',
1793491200000 + n * 1000, 180000, 180000, '"finished"', true,
'{"title":"First song", "artist_names":["Artist A"], "featured_artist_names":["Artist A", "Guest"], "release_title":"Album"}'::jsonb
FROM generate_series(1, 30) n;
INSERT INTO furumusic__listen_event VALUES
(2, 'listen-1', 'content-one', NULL, 'web-b', 1793664000000, 90000, 180000, '"skipped"', true,
'{"title":"First song", "artist_names":["Artist A"], "release_title":"Album"}'),
(1, 'phone-1', 'content-two', NULL, 'phone', 1793664001000, 120000, 240000, '"replaced"', true,
'{"title":"Remote song", "artist_names":["Artist B"], "release_title":"Remote album"}'),
(2, 'short-1', 'content-one', NULL, 'web-b', 1793664002000, 8000, 180000, '"skipped"', false,
'{"title":"First song", "artist_names":["Artist A"]}');