Compare commits

..
Author SHA1 Message Date
sanapachandClaude Opus 5.5 4f17feef71 Point frid deps at the fork branch
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-20 15:12:29 +02:00
sanapachandClaude Opus 5.5 c1cd689ea0 Test episode resume positions and rollback cleanup on PostgreSQL
The ignored device-sync PostgreSQL test now also covers a handoff and a
remote Next onto an episode with an unknown position (the relayed
progress register supplies 1200 s and its generation), and checks that
0.12's operation types fail on a relayed podcast operation and read the
log again after the documented cleanup statement, which the m_0055
backwards operation now shares.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 19:26:40 +02:00
sanapachandClaude Opus 5.5 a04a7460e6 Note the review fixes in the changelog and docs
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 19:22:26 +02:00
sanapachandClaude Opus 5.5 3af0e8ccc9 Keep a rollback to 0.12 safe for sync and the typed queue
Release 0.12 fails a whole sync batch on a podcast operation kind, so
rolling back is only safe after the relayed podcast operations are
removed: document the step in docs/administration.md and run it in the
m_0055 backwards operation.

The typed queue now records the current track id and queue position
written with it, next to the legacy ids. A 0.12 release that only moved
to another track in the same queue no longer leaves a stale typed
position that the next upgrade would restore. Jam placeholders are never
stored in a user's own typed queue.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 19:22:19 +02:00
sanapachandClaude Opus 5.5 6f3ed4b7ee Check Jam participant commands against the host queue
The server checked a participant's queue_remove/queue_clear against the
host state of the last report, but the host browser runs its pending
commands in one batch: after a move, a checked index can name a private
item. Participant commands are now stamped `jam_participant`, and the
host browser refuses to remove, clear, add or bring back its private
items for them, judged on the queue it is about to change.

A guest that stops controlling a Jam drops the host's private
placeholders from its own queue, so they are not saved or relayed as
the guest's queue.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 19:21:51 +02:00
sanapachandClaude Opus 5.5 d1be583d1e Resume unknown episode positions from progress, not 0
The web player only knows a podcast episode's position from a handoff or
a seek. When Next, auto-advance, a click or a play command makes an
episode current, it now reports `position_unknown` instead of 0, and the
server takes the resume position (and the register generation) from the
relayed progress register before it hands the state to another device.
Remote Next/Prev/play commands to a device do the same.

Next with repeat all or shuffle wraps past a trailing unplayable item
instead of stopping on it. Prev leaves an unplayable item instead of
"restarting" it, and seeking such an item moves its kept position.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 19:21:25 +02:00
sanapachandClaude Opus 5.5 ab7202fc73 Note the podcast queue fixes in the changelog
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 18:35:49 +02:00
sanapachandClaude Opus 5.5 19139ea830 Undo metadata deletions archived before the typed queue column
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 18:35:49 +02:00
sanapachandClaude Opus 5.5 a9736e5914 Keep Jam guests from removing or timing the host's private items
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 18:35:49 +02:00
sanapachandClaude Opus 5.5 4d0b352258 Keep the episode position and skip unplayable items safely in the player
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 18:35:49 +02:00
sanapachandClaude Opus 5.5 c14ab8dfea Document podcast queue support and release 0.13.0
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 16:58:32 +02:00
sanapachandClaude Opus 5.5 b558cf381e Relay device-sync v4 and keep podcast queue items
Use the shared music_dht::device_sync types instead of private copies
(byte-identical for v3 content, checked against the 0.12.x types and a
golden fixture) and announce protocol 4, because every v4 element is
kept:

- podcast operations stay in the operation log and are relayed only to
  peers that reported v4; their registers and the podcast snapshot
  sections are merged with the shared rules into an opaque relay table
  and returned in this server's snapshots (m_0055);
- the browser bridge carries PlaybackTrack.source: items that are not
  library tracks keep the verbatim wire item, so podcast episodes and
  Jam placeholders survive the round trip; the player labels and skips
  them instead of dropping them;
- the typed queue is persisted in queue_items_json next to queue_json,
  which is still written for rollback (m_0054).

Peer versions come from self-reports (profile_protocol_version); relayed
profiles only raise them and DeviceProfileSet no longer stores this
server's constant. Invites carry the inviter's version and a
DeviceProfileSet announces v4 once. Handoffs of a podcast queue to a
device below v4 are refused with an update message, and its playback
commands are ignored while the queue has podcast items. Jam guests see
podcast items as private placeholders, which are mapped back on their
commands.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 16:58:29 +02:00
sanapachandClaude Opus 5.5 75c67026ac Update music-dht to 0.6.0
The podcast contract and device-sync protocol v4 live in music-dht 0.6.
Cargo.lock currently resolves it from a local patch of the frid branch
podcasts/contract and must be regenerated against the published crate.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 16:58:21 +02:00
Aleksandr Bogomiakov 9b923851ae Fixed build. Reworked mobile admin UI 2026-11-18 15:17:50 +00:00
Aleksandr Bogomiakov 939fc00e4c Reworked new users login, improved share feature, enabled track downloads 2026-11-18 14:40:16 +00:00
Aleksandr Bogomiakov 2b7117a4f6 Fixed metadata AI assistant 2026-11-16 01:10:59 +00:00
Aleksandr Bogomiakov 3d886d1acd Improved metadata AI Assistant. 2026-11-16 00:32:33 +00:00
Aleksandr Bogomiakov 4141562e33 Added stat page 2026-11-12 11:52:38 +00:00
Aleksandr Bogomiakov bcb5d378c8 Add bulk approval for selected admin reviews 2026-10-23 01:12:54 +01:00
89 changed files with 12594 additions and 8946 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
+27
View File
@@ -1,5 +1,32 @@
# Changelog
## v0.13.0 — 2026-11-19
- Use the shared `music-dht` 0.6 device-sync types and announce device-sync
protocol 4. Podcast operations and snapshot sections from other devices are
kept and relayed; devices below protocol 4 never receive them.
- Keep podcast episodes and other non-library queue items through the web
player, with their explicit source. The player labels and skips them; the
typed queue is stored next to `queue_json` (migrations `m_0054`, `m_0055`).
A handoff through the web player keeps the position of the current episode.
- Refuse a playback transfer of a queue with podcast episodes to a device that
needs an update, and ignore its playback commands while the queue has them.
- Store the protocol version each device reports itself instead of this
server's version; invites carry the inviter's version.
- An episode that the web player selects without knowing its position (Next,
auto-advance, a click) resumes from its synchronized progress on the next
device instead of restarting at 0. Repeat all and shuffle continue past
episodes; Prev and seeking work on them.
- Jam guests see podcast episodes of the host as private items, without their
duration, and cannot add, remove or clear them; the host browser enforces
this on its own queue. Guests do not keep the placeholders after the Jam.
- Metadata Repair can still undo deletions recorded before the typed queue
column was added.
- Rolling back to 0.12 requires removing the relayed podcast operations first;
see "Rolling back to 0.12" in `docs/administration.md`. After a rollback, the
typed queue is used again only if 0.12 left the queue and its current track
unchanged.
## v0.10.6 — 2026-09-02
- Recover federation automatically after sleep, prolonged idle, or a degraded rendezvous transport.
Generated
+4 -6
View File
@@ -1843,8 +1843,7 @@ dependencies = [
[[package]]
name = "federation-net"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "01e5c2e6e5af020dc202d4924125ef57719aa21f8d2567e2d943914386bc8980"
source = "git+https://gt.hexor.cy/Sanapach/frid.git?branch=podcasts%2Fcontract#65d6ca2f14a1324dc129b90694da83ceb55c60dc"
dependencies = [
"blake3",
"data-encoding",
@@ -1988,7 +1987,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
[[package]]
name = "furumusic"
version = "0.12.0"
version = "0.13.0"
dependencies = [
"anyhow",
"async-stream",
@@ -3900,9 +3899,8 @@ dependencies = [
[[package]]
name = "music-dht"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4c3f75d49d3a742a6777a1c4cc53f397399dfc9ddb70034c57aeb44d75d2ee4f"
version = "0.6.0"
source = "git+https://gt.hexor.cy/Sanapach/frid.git?branch=podcasts%2Fcontract#65d6ca2f14a1324dc129b90694da83ceb55c60dc"
dependencies = [
"async-trait",
"blake3",
+12 -2
View File
@@ -1,9 +1,15 @@
[package]
name = "furumusic"
version = "0.12.0"
version = "0.13.0"
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]
@@ -50,4 +56,8 @@ uuid = "1"
librqbit = { version = "8.1.1", features = ["disable-upload"] }
# P2P federation: publishes the library into a shared DHT and serves audio /
# catalogs to furumi peers (TUI clients) over the frid stack.
music-dht = "0.5.0"
music-dht = "0.6.0"
[patch.crates-io]
# Unpublished frid (MR-F1); remove once music-dht 0.6.0 is on crates.io.
music-dht = { git = "https://gt.hexor.cy/Sanapach/frid.git", branch = "podcasts/contract" }
+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.
+156
View File
@@ -0,0 +1,156 @@
# 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.
Queues synchronized from other Furumi players can contain podcast episodes. The
web player keeps them in the queue, in order and with their position, and shows
them as **Podcast · not playable in the web player yet**; local playback skips
them. A device that does not support podcasts yet (device-sync protocol below
4, for example an older terminal player) cannot receive such a queue: selecting
it as the playback device shows that it needs an update, and the episodes stay
in the queue. Jam guests see podcast episodes of the host only as private items.
### Rolling back to 0.12
Release 0.13 relays podcast synchronization operations from other Furumi
players. Release 0.12 cannot read them: device synchronization would fail for
every device that has not received them yet. Before you start a 0.12 release
on a database that 0.13 used, stop the server and remove those operations:
```sql
DELETE FROM furumusic__fed_sync_ops WHERE kind LIKE 'podcast\_%';
```
Devices that support podcasts keep their own podcast state. The relay table
`furumusic__fed_podcast_relay` and the typed queue column can stay: 0.12
ignores them, and after the next upgrade 0.13 returns the relayed podcast state
in its snapshots again and uses the typed queue only while it matches the
queue, current track and position that 0.12 saved.
## 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.
+167
View File
@@ -0,0 +1,167 @@
# 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.
## Connected devices and podcast queue items
Trusted-device sync uses the shared `music_dht::device_sync` types (no local
copies) and announces protocol version 4. The web player has no podcast
features yet, but it keeps every v4 element it receives:
- podcast operations stay in the operation log and are relayed to v4 devices
only; their registers and the podcast snapshot sections are merged with the
shared `music_dht::podcast` rules into `furumusic__fed_podcast_relay`
(opaque contract JSON) and returned in this server's snapshots;
- queue items that are not library tracks become external browser items
(`source` plus the verbatim `wire_track`), so podcast episodes and Jam
placeholders survive peer → server → browser → server → peer unchanged;
- `furumusic__playback_state.queue_items_json` stores the typed queue next to
`queue_json`. `queue_json` (library ids) is still written for rollback; the
typed value is used only while the legacy columns it recorded
(`queue_json`, `current_track_id`, `queue_position`) match the row. Jam
placeholders are never stored in a user's own queue.
- a browser that selects a podcast episode it cannot play does not know the
episode's position. It reports `position_unknown`, and the server sends the
resume position of the relayed progress register instead of 0. Jam
participant commands carry `jam_participant`; the host browser checks them
against its own queue.
Rolling back to 0.12 needs the podcast operations removed from the operation
log first; see "Rolling back to 0.12" in `administration.md`.
Everything sent to a device is gated by the version that device reported itself
(`profile_protocol_version`; relayed profiles only raise it). See the podcast
contract (`PODCASTS.md`) and `PLAYBACK_PROTOCOL.md` in the Frid repository.
```bash
cargo test devices:: queue_items podcast_relay queue_persistence
node --test tests/player_queue_sources.test.cjs
# Migrated disposable PostgreSQL (start the server against it once):
FURU_DEVICE_SYNC_TEST_DATABASE_URL=postgresql://... \
cargo test devices::postgres_tests -- --ignored
FURU_METADATA_FIX_TEST_DATABASE_URL=postgresql://... \
cargo test undo_accepts_playback_archives_written_before_the_typed_queue -- --ignored
```
`wire_compat_tests` compares the shared types with the private copies of
0.12.x byte for byte; `fixtures/v3_hello.golden.json` is the v3 shape. Rewrite
it only for a deliberate change, with `FURUMUSIC_BLESS_GOLDEN=1`.
## 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"));
}
}
+782 -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()??;
+569 -640
View File
File diff suppressed because it is too large. Load diff
@@ -0,0 +1 @@
{"type":"hello","group_id":"grp_1","profile":{"device_id":"tui_a","name":"TUI","client_version":"0.3.4","protocol_version":3,"endpoint_id":"e","endpoint_ticket":"t","revoked":false,"revoke_cutoff_seq":null,"updated_at_ms":5},"devices":[{"device_id":"tui_a","name":"TUI","client_version":"0.3.4","protocol_version":3,"endpoint_id":"e","endpoint_ticket":"t","revoked":false,"revoke_cutoff_seq":null,"updated_at_ms":5},{"device_id":"web_b","name":"TUI","client_version":"0.3.4","protocol_version":3,"endpoint_id":"e","endpoint_ticket":"t","revoked":false,"revoke_cutoff_seq":null,"updated_at_ms":5}],"vector":{"tui_a":12,"web_b":4},"ops":[{"op_id":"tui_a:1","origin_device_id":"tui_a","seq":1,"hlc_ms":1700000000001,"payload":{"kind":"track_like_set","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","liked":true,"fed":{"item_id":"item","owner":"owner","title":"Song","artist_names":["A"],"featured_artist_names":[],"year":2001,"duration_seconds":180,"content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","release_title":"Album","track_number":1,"disc_number":1}}},{"op_id":"tui_a:2","origin_device_id":"tui_a","seq":2,"hlc_ms":1700000000002,"payload":{"kind":"playlist_created","playlist_id":"pl","title":"Mix"}},{"op_id":"tui_a:3","origin_device_id":"tui_a","seq":3,"hlc_ms":1700000000003,"payload":{"kind":"playlist_renamed","playlist_id":"pl","title":"Mix 2"}},{"op_id":"tui_a:4","origin_device_id":"tui_a","seq":4,"hlc_ms":1700000000004,"payload":{"kind":"playlist_track_added","playlist_id":"pl","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","position":0,"fed":null}},{"op_id":"tui_a:5","origin_device_id":"tui_a","seq":5,"hlc_ms":1700000000005,"payload":{"kind":"playlist_track_removed","playlist_id":"pl","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111"}},{"op_id":"tui_a:6","origin_device_id":"tui_a","seq":6,"hlc_ms":1700000000006,"payload":{"kind":"playlist_deleted","playlist_id":"pl"}},{"op_id":"tui_a:7","origin_device_id":"tui_a","seq":7,"hlc_ms":1700000000007,"payload":{"kind":"device_profile_set","name":"TUI","client_version":"0.3.4","endpoint_ticket":"t","endpoint_id":"e"}},{"op_id":"tui_a:8","origin_device_id":"tui_a","seq":8,"hlc_ms":1700000000008,"payload":{"kind":"device_trusted","target_device_id":"web_b"}},{"op_id":"tui_a:9","origin_device_id":"tui_a","seq":9,"hlc_ms":1700000000009,"payload":{"kind":"device_revoked","target_device_id":"old","target_max_seq_seen":3}},{"op_id":"tui_a:10","origin_device_id":"tui_a","seq":10,"hlc_ms":1700000000010,"payload":{"kind":"playback_command","target_device_id":"web_b","command":{"kind":"set_state","state":{"queue":[{"id":7,"title":"Song","track_number":1,"disc_number":null,"duration_seconds":180.5,"artist_names":["A"],"featured_artist_names":["B"],"release_id":3,"release_title":"Album","release_year":2001,"file_path":"","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","audio_format":"flac","audio_bitrate":900,"audio_sample_rate":44100,"audio_bit_depth":16,"file_size_bytes":12345,"play_count":2,"fed":{"item_id":"item","owner":"owner","title":"Song","artist_names":["A"],"featured_artist_names":[],"year":2001,"duration_seconds":180,"content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","release_title":"Album","track_number":1,"disc_number":1}},{"id":0,"title":"Remote","track_number":null,"disc_number":null,"duration_seconds":0.0,"artist_names":[],"featured_artist_names":[],"release_id":0,"release_title":"","release_year":null,"file_path":"","content_id":null,"audio_format":null,"audio_bitrate":null,"audio_sample_rate":null,"audio_bit_depth":null,"file_size_bytes":null,"play_count":0,"fed":null}],"queue_pos":1,"playing":true,"paused":false,"idle_since_ms":null,"position_secs":42.5,"volume":73,"shuffle":true,"repeat":"all"},"seek":true},"authority":{"version":1,"claim":{"counter":3,"issuer":"tui_a","owner":"tui_a"},"sequence":9}}},{"op_id":"tui_a:11","origin_device_id":"tui_a","seq":11,"hlc_ms":1700000000011,"payload":{"kind":"playback_command","target_device_id":"web_b","command":{"kind":"active_changed","active_device_id":"web_b","active_device_name":"WEB","state":{"queue":[{"id":7,"title":"Song","track_number":1,"disc_number":null,"duration_seconds":180.5,"artist_names":["A"],"featured_artist_names":["B"],"release_id":3,"release_title":"Album","release_year":2001,"file_path":"","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","audio_format":"flac","audio_bitrate":900,"audio_sample_rate":44100,"audio_bit_depth":16,"file_size_bytes":12345,"play_count":2,"fed":{"item_id":"item","owner":"owner","title":"Song","artist_names":["A"],"featured_artist_names":[],"year":2001,"duration_seconds":180,"content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","release_title":"Album","track_number":1,"disc_number":1}},{"id":0,"title":"Remote","trackLine truncated
+575
View File
@@ -0,0 +1,575 @@
//! Version gating and lossless queue bridge (device-sync protocol v4).
use super::*;
use crate::player::queue_items::{self, test_episode};
use music_dht::podcast::{
EpisodeId, FeedUrl, ListenSession, PodcastId, PodcastMeta, ProgressStatus,
};
const CONTENT_ID: &str = "b3:2222222222222222222222222222222222222222222222222222222222222222";
fn podcast_id() -> PodcastId {
PodcastId::from_feed_url(&FeedUrl::parse("https://podcasts.example/feed.xml").unwrap())
}
fn episode_id() -> EpisodeId {
EpisodeId::from_guid(&podcast_id(), "ep-1").unwrap()
}
fn music_track(id: i64) -> PlaybackTrack {
let mut track = PlaybackTrack::private_placeholder();
track.source = None;
track.id = id;
track.title = format!("Song {id}");
track
}
fn state(queue: Vec<PlaybackTrack>) -> PlaybackStateWire {
PlaybackStateWire {
queue,
queue_pos: 0,
playing: true,
paused: false,
idle_since_ms: None,
position_secs: 12.5,
volume: 70,
shuffle: false,
repeat: PlaybackRepeat::Off,
playback_rate: None,
}
}
fn podcast_state() -> PlaybackStateWire {
state(vec![
music_track(1),
PlaybackTrack::podcast_episode(test_episode()),
])
}
/// One payload of every operation kind (music-only playback commands).
fn every_payload(playback: PlaybackStateWire) -> Vec<SyncOpPayload> {
let session = ListenSession {
session_id: "s1".into(),
episode_id: episode_id(),
podcast_id: podcast_id(),
device_id: "tui_a".into(),
started_at_ms: 1,
ended_at_ms: 2,
start_position_ms: 0,
end_position_ms: 1,
listened_ms: 1,
completed: false,
};
let meta: PodcastMeta = serde_json::from_value(serde_json::json!({
"feed_url": "https://podcasts.example/feed.xml", "title": "Cast"
}))
.unwrap();
vec![
SyncOpPayload::TrackLikeSet {
content_id: CONTENT_ID.into(),
liked: true,
fed: None,
},
SyncOpPayload::PlaylistCreated {
playlist_id: "p".into(),
title: "t".into(),
},
SyncOpPayload::PlaylistRenamed {
playlist_id: "p".into(),
title: "t".into(),
},
SyncOpPayload::PlaylistDeleted {
playlist_id: "p".into(),
},
SyncOpPayload::PlaylistTrackAdded {
playlist_id: "p".into(),
content_id: CONTENT_ID.into(),
position: 0,
fed: None,
},
SyncOpPayload::PlaylistTrackRemoved {
playlist_id: "p".into(),
content_id: CONTENT_ID.into(),
},
SyncOpPayload::DeviceProfileSet {
name: "n".into(),
client_version: "v".into(),
endpoint_ticket: "t".into(),
endpoint_id: "e".into(),
protocol_version: Some(4),
},
SyncOpPayload::DeviceTrusted {
target_device_id: "d".into(),
},
SyncOpPayload::DeviceRevoked {
target_device_id: "d".into(),
target_max_seq_seen: 1,
},
SyncOpPayload::PlaybackCommand {
target_device_id: "d".into(),
command: PlaybackCommand::SetState {
state: playback,
seek: false,
},
authority: None,
},
SyncOpPayload::ListenRecorded {
event: ListenEvent {
listen_id: "l".into(),
content_id: CONTENT_ID.into(),
started_at_ms: 1,
listened_ms: 1,
track_duration_ms: None,
ended_reason: ListenEndReason::Finished,
track: ListenTrackMetadata {
title: "t".into(),
artist_names: vec!["a".into()],
featured_artist_names: vec![],
release_title: None,
},
},
},
SyncOpPayload::PodcastSubscriptionSet {
podcast_id: podcast_id(),
subscribed: true,
podcast: meta,
feed_aliases: vec![],
generation: 1,
},
SyncOpPayload::PodcastShareSet {
podcast_id: podcast_id(),
shared: false,
generation: 1,
},
SyncOpPayload::PodcastFeedAliasesAdded {
podcast_id: podcast_id(),
feed_aliases: vec![FeedUrl::parse("https://podcasts.example/new.xml").unwrap()],
},
SyncOpPayload::PodcastProgressSet {
episode_id: episode_id(),
podcast_id: podcast_id(),
position_ms: 1,
status: ProgressStatus::InProgress,
generation: 1,
session_id: "s1".into(),
episode: None,
},
SyncOpPayload::PodcastListenRecorded {
session,
episode: None,
},
]
}
#[test]
fn stored_kind_is_the_wire_tag() {
for payload in every_payload(state(vec![])) {
let value = serde_json::to_value(&payload).unwrap();
assert_eq!(payload_kind(&payload), value["kind"].as_str().unwrap());
}
}
#[test]
fn op_gating_matrix_matches_the_shared_helper() {
// The SQL kind filter must hide exactly what `op_allowed_for_peer`
// rejects (playback commands are content-dependent and checked in Rust).
for version in 1..=PROTOCOL_VERSION {
let hidden = op_kinds_hidden_from(version);
for payload in every_payload(state(vec![music_track(1)])) {
let kind = payload_kind(&payload);
assert_eq!(
hidden.contains(&kind),
!op_allowed_for_peer(&payload, version),
"{kind} for v{version}"
);
}
}
assert!(
op_kinds_hidden_from(3)
.iter()
.all(|kind| kind.starts_with("podcast_"))
);
assert_eq!(op_kinds_hidden_from(3).len(), 5);
assert!(op_kinds_hidden_from(4).is_empty());
}
#[test]
fn playback_gating_matrix() {
let music = state(vec![music_track(1), music_track(2)]);
let podcasts = podcast_state();
let private = state(vec![PlaybackTrack::private_placeholder()]);
for version in 1..=PROTOCOL_VERSION {
let v4 = version >= 4;
// Snapshots and handoffs.
assert!(playback_allowed_for_peer(&music, version));
assert_eq!(playback_allowed_for_peer(&podcasts, version), v4);
assert_eq!(playback_allowed_for_peer(&private, version), v4);
// Commands from the peer.
assert!(playback_command_allowed_from_peer(&music, version));
assert_eq!(playback_command_allowed_from_peer(&podcasts, version), v4);
// Stamped playback command operations.
let command = |state: &PlaybackStateWire| SyncOpPayload::PlaybackCommand {
target_device_id: "d".into(),
command: PlaybackCommand::ActiveChanged {
active_device_id: "d".into(),
active_device_name: "D".into(),
state: state.clone(),
},
authority: None,
};
assert!(op_allowed_for_peer(&command(&music), version));
assert_eq!(op_allowed_for_peer(&command(&podcasts), version), v4);
}
}
#[test]
fn browser_state_gating_sees_podcast_items() {
let with_podcast = serde_json::json!({
"tracks": [
{"id": 5, "title": "Library song"},
queue_items::external_track_json(&PlaybackTrack::podcast_episode(test_episode()), 1, None),
],
"index": 0,
});
let shadow = browser_state_shadow(&with_podcast);
assert!(!playback_command_allowed_from_peer(&shadow, 3));
assert!(playback_command_allowed_from_peer(&shadow, 4));
let music_only = serde_json::json!({"tracks": [{"id": 5}], "index": 0});
assert!(playback_command_allowed_from_peer(
&browser_state_shadow(&music_only),
3
));
}
#[test]
fn relayed_versions_never_downgrade_and_self_reports_replace() {
let profile = |id: &str, version: u16| DeviceProfileWire {
device_id: id.into(),
name: "D".into(),
client_version: "x".into(),
protocol_version: version,
endpoint_id: String::new(),
endpoint_ticket: String::new(),
revoked: false,
revoke_cutoff_seq: None,
updated_at_ms: 0,
};
// A v3 relay lists every device with its own constant.
let relayed = VersionReport::for_listed(&profile("tui_b", 3), Some("tui_a"));
assert_eq!(relayed, VersionReport::Relayed(3));
assert_eq!(relayed.resolve(Some(4)), 4);
assert_eq!(relayed.resolve(None), 3);
assert_eq!(VersionReport::Relayed(4).resolve(Some(3)), 4);
// The sender's own entry is a self-report and may lower the version.
let own = VersionReport::for_listed(&profile("tui_a", 3), Some("tui_a"));
assert_eq!(own, VersionReport::SelfReported(Some(3)));
assert_eq!(own.resolve(Some(4)), 3);
// Profiles without a version (pending pairing, pre-v4 DeviceProfileSet)
// keep the stored value, or the unreported version 1.
assert_eq!(VersionReport::SelfReported(None).resolve(Some(4)), 4);
assert_eq!(VersionReport::SelfReported(None).resolve(None), 1);
}
#[test]
fn podcast_snapshot_sections_are_bounded_per_message() {
let mut snapshot = SyncSnapshot::default();
let progress = music_dht::podcast::ProgressRecord {
episode_id: episode_id(),
podcast_id: podcast_id(),
position_ms: 1,
status: ProgressStatus::InProgress,
generation: 1,
session_id: "s".into(),
hlc_ms: 1,
device_id: "tui_a".into(),
op_id: "tui_a:1".into(),
};
snapshot.podcast_progress = vec![progress; 10];
// Large other parts leave (almost) no budget for podcast sections.
let big_title = "x".repeat(music_dht::device_sync::MAX_SYNC_LINE - 16 * 1024);
let mut message = WireMessage::Hello {
group_id: "g".into(),
profile: DeviceProfileWire {
device_id: "web".into(),
name: big_title,
client_version: String::new(),
protocol_version: PROTOCOL_VERSION,
endpoint_id: String::new(),
endpoint_ticket: String::new(),
revoked: false,
revoke_cutoff_seq: None,
updated_at_ms: 0,
},
devices: vec![],
vector: BTreeMap::new(),
ops: vec![],
snapshot: snapshot.clone(),
playback: None,
};
fit_podcast_snapshot(&mut message);
let WireMessage::Hello {
snapshot: fitted, ..
} = &message
else {
unreachable!()
};
assert!(fitted.podcast_progress.is_empty());
let mut small = WireMessage::SyncResponse {
accepted: true,
error: None,
devices: vec![],
vector: BTreeMap::new(),
ops: vec![],
snapshot,
playback: None,
};
fit_podcast_snapshot(&mut small);
let WireMessage::SyncResponse { snapshot, .. } = &small else {
unreachable!()
};
assert_eq!(snapshot.podcast_progress.len(), 10);
}
/// Pool that is never connected: the bridge paths under test resolve
/// podcast items, placeholders and inline content ids without queries.
fn offline_pool() -> sqlx::PgPool {
sqlx::postgres::PgPoolOptions::new()
.connect_lazy("postgres://offline@127.0.0.1:1/offline")
.unwrap()
}
#[tokio::test]
async fn podcast_queue_survives_server_browser_server_round_trip() {
let pool = offline_pool();
let mut other = test_episode();
other.episode_title = "Episode 43".into();
other.episode_id = EpisodeId::from_guid(&other.podcast_id, "episode-43").unwrap();
let mut unresolved = music_track(0);
unresolved.title = "Remote song".into();
let queue = vec![
PlaybackTrack::podcast_episode(test_episode()),
PlaybackTrack::private_placeholder(),
unresolved,
PlaybackTrack::podcast_episode(other),
];
let mut incoming = state(queue.clone());
incoming.queue_pos = 3;
incoming.paused = true;
incoming.position_secs = 1200.0;
// peer -> server -> browser
let payload = web_playback_payload(&pool, &incoming).await.unwrap();
let tracks = payload["tracks"].as_array().unwrap();
assert_eq!(tracks.len(), 4, "no item is dropped");
assert_eq!(payload["index"], 3);
assert_eq!(payload["position_seconds"], 1200.0);
assert_eq!(tracks[0]["source"]["kind"], "podcast_episode");
assert_eq!(tracks[0]["unavailable"], true);
assert_eq!(tracks[1]["source"]["kind"], "private");
// The browser keeps its queue and sends it back (plus a library track
// it added at the end, with its content id inline).
let mut browser: serde_json::Value = serde_json::from_str(&payload.to_string()).unwrap();
browser["tracks"]
.as_array_mut()
.unwrap()
.push(serde_json::json!({
"id": 77, "title": "Library song", "content_id": CONTENT_ID,
"duration_seconds": 100.0, "artists": [{"id": 1, "name": "A"}],
"release_id": 9, "release_title": "Album",
}));
// browser -> server -> peer
let outgoing = playback_state_from_browser_json(&pool, 1, browser)
.await
.unwrap();
assert_eq!(outgoing.queue[..4], queue[..]);
assert_eq!(outgoing.queue_pos, 3);
assert!(outgoing.paused);
// The episode position goes back to the peer (handoff web -> TUI).
assert_eq!(outgoing.position_secs, 1200.0);
let library = &outgoing.queue[4];
assert_eq!(library.id, 77);
assert_eq!(library.content_id.as_deref(), Some(CONTENT_ID));
assert_eq!(library.source, None);
// Library music keeps the v3 shape.
assert!(!serde_json::to_string(library).unwrap().contains("source"));
// Peers below v4 get no playback snapshot with these items.
assert!(!playback_allowed_for_peer(&outgoing, 3));
assert!(playback_allowed_for_peer(&outgoing, 4));
}
#[tokio::test]
async fn malformed_browser_items_keep_the_position_on_its_item() {
let pool = offline_pool();
let browser = serde_json::json!({
"tracks": [
{"title": "no id"},
{"id": 5, "content_id": CONTENT_ID},
{"id": 6, "content_id": CONTENT_ID},
],
"index": 2,
"track": {"id": 6},
});
let wire = playback_state_from_browser_json(&pool, 1, browser)
.await
.unwrap();
assert_eq!(wire.queue.len(), 2);
assert_eq!(wire.queue[wire.queue_pos].id, 6);
}
fn progress_record(position_ms: i64, status: ProgressStatus, generation: u64) -> ProgressRecord {
let episode = test_episode();
ProgressRecord {
episode_id: episode.episode_id,
podcast_id: episode.podcast_id,
position_ms,
status,
generation,
session_id: "session-1".into(),
hlc_ms: 1_700_000_000_000,
device_id: "tui".into(),
op_id: "op-1".into(),
}
}
/// Browser state of `[library song, episode]` with the song current at 200 s.
fn song_then_episode() -> serde_json::Value {
let episode = PlaybackTrack::podcast_episode(test_episode());
let song = serde_json::json!({
"id": 77, "title": "Library song", "content_id": CONTENT_ID,
"duration_seconds": 300.0, "stream_url": "/api/player/stream/77",
});
serde_json::json!({
"tracks": [song.clone(), queue_items::external_track_json(&episode, 1, None)],
"index": 0,
"track": song,
"position_seconds": 200.0,
"paused": false,
"repeat_mode": "off",
})
}
fn position_unknown(state: &serde_json::Value) -> bool {
state[queue_items::POSITION_UNKNOWN_KEY] == true
}
#[test]
fn commands_that_select_an_item_do_not_know_its_position() {
let current = song_then_episode();
// Next and Prev onto another item, and play commands (which the browser
// always sends with position 0), leave the position to the server.
let next =
browser_state_for_command("next", serde_json::json!({}), Some(current.clone())).unwrap();
assert_eq!(next["index"], 1);
assert_eq!(next["position_seconds"], 0.0);
assert!(position_unknown(&next));
let mut play = current.clone();
play["index"] = serde_json::json!(1);
let played = browser_state_for_command("play_from_index", play.clone(), None).unwrap();
assert!(position_unknown(&played));
let prev =
browser_state_for_command("prev", serde_json::json!({}), Some(next.clone())).unwrap();
assert_eq!(prev["index"], 0);
assert!(position_unknown(&prev));
// Restarting the same item and seeking are explicit positions.
let mut late = next.clone();
late["position_seconds"] = serde_json::json!(900.0);
let restart = browser_state_for_command("prev", serde_json::json!({}), Some(late)).unwrap();
assert_eq!(restart["index"], 1);
assert!(!position_unknown(&restart));
let repeat = browser_state_for_command(
"next",
serde_json::json!({"repeat_mode": "one"}),
Some(next.clone()),
)
.unwrap();
assert!(!position_unknown(&repeat));
let seek =
browser_state_for_command("seek", serde_json::json!({"time": 60.0}), Some(next)).unwrap();
assert_eq!(seek["position_seconds"], 60.0);
assert!(!position_unknown(&seek));
// A transfer keeps what the sender knew.
let mut handed_off = play;
handed_off["position_seconds"] = serde_json::json!(1200.0);
let transfer = browser_state_for_command("transfer_state", handed_off.clone(), None).unwrap();
assert_eq!(transfer["position_seconds"], 1200.0);
assert!(!position_unknown(&transfer));
handed_off[queue_items::POSITION_UNKNOWN_KEY] = serde_json::json!(true);
let transfer = browser_state_for_command("transfer_state", handed_off, None).unwrap();
assert!(position_unknown(&transfer));
}
#[tokio::test]
async fn unknown_episode_position_resumes_from_the_progress_register() {
let pool = offline_pool();
let next = browser_state_for_command("next", serde_json::json!({}), Some(song_then_episode()))
.unwrap();
let mut wire = browser_json_to_wire(&pool, next).await.unwrap();
assert_eq!(wire.queue_pos, 1);
assert_eq!(wire.position_secs, 0.0);
// In progress at 1200 s, generation 9 (the queue item has seen 7).
let mut resumed = wire.clone();
apply_resume_position(
&mut resumed,
Some(&progress_record(1_200_000, ProgressStatus::InProgress, 9)),
);
assert_eq!(resumed.position_secs, 1200.0);
let episode = resumed.queue[1].podcast_episode_ref().unwrap();
assert_eq!(episode.progress_generation, Some(9));
// The receiver's explicit write then orders after the register.
assert_eq!(
ProgressRecord::explicit_generation(episode.progress_generation),
10
);
// Completed: ordinary Play starts from the beginning; an older register
// does not lower the generation the item has seen.
let mut completed = wire.clone();
apply_resume_position(
&mut completed,
Some(&progress_record(1_790_000, ProgressStatus::Completed, 3)),
);
assert_eq!(completed.position_secs, 0.0);
assert_eq!(
completed.queue[1]
.podcast_episode_ref()
.unwrap()
.progress_generation,
Some(7)
);
// Music keeps the position it has.
wire.queue_pos = 0;
wire.position_secs = 5.0;
let before = wire.clone();
apply_resume_position(
&mut wire,
Some(&progress_record(1_200_000, ProgressStatus::InProgress, 9)),
);
assert_eq!(wire, before);
}
#[tokio::test]
async fn known_positions_and_music_never_read_the_progress_register() {
// The offline pool fails any query, so these conversions must not query.
let pool = offline_pool();
let mut handed_off = song_then_episode();
handed_off["index"] = serde_json::json!(1);
handed_off["position_seconds"] = serde_json::json!(1200.0);
let wire = playback_state_from_browser_json(&pool, 1, handed_off)
.await
.unwrap();
assert_eq!(wire.position_secs, 1200.0);
let mut music = song_then_episode();
music[queue_items::POSITION_UNKNOWN_KEY] = serde_json::json!(true);
let wire = playback_state_from_browser_json(&pool, 1, music)
.await
.unwrap();
assert_eq!(wire.position_secs, 200.0);
}
+3 -1
View File
@@ -1,5 +1,6 @@
//! Cross-binary protocol contract; the peer is the TUI's production adapter.
use super::*;
use music_dht::device_sync::read_line;
use tokio::io::AsyncWriteExt;
#[tokio::test]
@@ -34,7 +35,8 @@ async fn localhost_tui_peer() {
else {
panic!("expected TUI hello")
};
assert_eq!(profile.protocol_version, PROTOCOL_VERSION);
// TUI 0.3.x reports v3; podcast-capable TUI releases report v4.
assert!((3..=PROTOCOL_VERSION).contains(&profile.protocol_version));
assert_eq!(snapshot.device_id, profile.device_id);
let announcement = snapshot
.coordination
+478
View File
@@ -0,0 +1,478 @@
//! Device-sync v4 storage paths against PostgreSQL.
//!
//! Requires a migrated disposable database (start the server once against
//! it); the test writes rows for a random user id and removes them again.
use super::*;
use crate::player::queue_items::test_episode;
use music_dht::podcast::{
EpisodeId, FeedUrl, PodcastId, PodcastMeta, ProgressRecord, ProgressStatus, ShareRecord,
};
fn profile(device_id: &str, protocol_version: u16) -> DeviceProfileWire {
DeviceProfileWire {
device_id: device_id.into(),
name: device_id.to_uppercase(),
client_version: "test".into(),
protocol_version,
endpoint_id: String::new(),
endpoint_ticket: String::new(),
revoked: false,
revoke_cutoff_seq: None,
updated_at_ms: now_ms(),
}
}
fn op(origin: &str, seq: i64, hlc_ms: i64, payload: SyncOpPayload) -> SyncOpWire {
SyncOpWire {
op_id: format!("{origin}:{seq}"),
origin_device_id: origin.into(),
seq,
hlc_ms,
payload,
}
}
async fn cleanup(pool: &sqlx::PgPool, user_id: i64) {
for table in [
"furumusic__fed_device_identity",
"furumusic__fed_device",
"furumusic__fed_device_invite",
"furumusic__fed_peer_ack",
"furumusic__fed_pending_pairing",
"furumusic__fed_playback_applied",
"furumusic__fed_podcast_relay",
"furumusic__fed_state_like",
"furumusic__fed_state_playlist",
"furumusic__fed_state_playlist_item",
"furumusic__fed_sync_ops",
"furumusic__fed_sync_vector",
"furumusic__playback_state",
] {
sqlx::query(&format!("DELETE FROM {table} WHERE user_id = $1"))
.bind(user_id)
.execute(pool)
.await
.unwrap();
}
}
#[tokio::test]
#[ignore = "requires a migrated disposable database in FURU_DEVICE_SYNC_TEST_DATABASE_URL"]
async fn postgres_podcast_relay_gating_and_peer_versions() {
let pool = sqlx::PgPool::connect(&std::env::var("FURU_DEVICE_SYNC_TEST_DATABASE_URL").unwrap())
.await
.unwrap();
let user_id = 8_000_000_000 + i64::from(rand_suffix());
cleanup(&pool, user_id).await;
let new = format!("tui_new_{user_id}");
let old = format!("tui_old_{user_id}");
let other = format!("tui_other_{user_id}");
let identity = ensure_identity(&pool, user_id, "tester").await.unwrap();
// Peer versions: self-reports replace, relayed profiles only raise.
for (device, version) in [(&new, 4), (&old, 3), (&other, 4)] {
apply_device_profile(
&pool,
user_id,
&profile(device, version),
VersionReport::SelfReported(Some(version)),
true,
)
.await
.unwrap();
}
// A v3 relay lists everyone with its own constant.
apply_device_profiles(
&pool,
user_id,
&[profile(&new, 3), profile(&old, 3)],
Some(old.as_str()),
)
.await
.unwrap();
assert_eq!(
stored_protocol_version(&pool, user_id, &new).await.unwrap(),
4
);
assert_eq!(
stored_protocol_version(&pool, user_id, &old).await.unwrap(),
3
);
// Podcast and music operations from the v4 device.
let feed = FeedUrl::parse("https://podcasts.example/feed.xml").unwrap();
let podcast_id = PodcastId::from_feed_url(&feed);
let episode_id = EpisodeId::from_guid(&podcast_id, "ep-1").unwrap();
let meta: PodcastMeta = serde_json::from_value(serde_json::json!({
"feed_url": feed.as_str(), "title": "Example Cast"
}))
.unwrap();
let progress = |seq, generation, hlc_ms, position_ms| {
op(
&new,
seq,
hlc_ms,
SyncOpPayload::PodcastProgressSet {
episode_id: episode_id.clone(),
podcast_id: podcast_id.clone(),
position_ms,
status: ProgressStatus::InProgress,
generation,
session_id: format!("s{generation}"),
episode: None,
},
)
};
let mut invalid = progress(5, 9, 50, 1);
if let SyncOpPayload::PodcastProgressSet { session_id, .. } = &mut invalid.payload {
session_id.clear();
}
let hub = Arc::new(PlayerDeviceHub::default());
apply_ops(
&pool,
Arc::clone(&hub),
user_id,
vec![
op(
&new,
1,
10,
SyncOpPayload::PodcastSubscriptionSet {
podcast_id: podcast_id.clone(),
subscribed: true,
podcast: meta,
feed_aliases: vec![],
generation: 1,
},
),
// Newer generation first, then a late checkpoint of an older one.
progress(2, 4, 20, 10_000),
progress(3, 3, 90_000, 600_000),
op(
&new,
4,
40,
SyncOpPayload::TrackLikeSet {
content_id: format!("b3:{}", "3".repeat(64)),
liked: false,
fed: None,
},
),
invalid,
],
)
.await
.unwrap();
// The invalid operation is not stored but acknowledged.
assert_eq!(vector(&pool, user_id).await.unwrap().get(&new), Some(&5));
let stored: i64 = sqlx::query_scalar(
"SELECT COUNT(*) FROM furumusic__fed_sync_ops WHERE user_id = $1 AND origin_device_id = $2",
)
.bind(user_id)
.bind(&new)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(stored, 4);
// Relay: the v3 peer gets only music, a v4 peer gets everything.
let kinds = |ops: Vec<SyncOpWire>| {
ops.iter()
.map(|op| payload_kind(&op.payload))
.collect::<Vec<_>>()
};
let to_old = kinds(ops_for_peer(&pool, user_id, &old, 3).await.unwrap());
assert!(to_old.iter().all(|kind| !kind.starts_with("podcast_")));
assert!(to_old.contains(&"track_like_set"));
let to_other = kinds(ops_for_peer(&pool, user_id, &other, 4).await.unwrap());
assert_eq!(
to_other
.iter()
.filter(|kind| kind.starts_with("podcast_"))
.count(),
3
);
// Snapshot recovery: registers merged with the shared rules.
apply_snapshot(
&pool,
user_id,
SyncSnapshot {
podcast_shares: vec![ShareRecord {
podcast_id: podcast_id.clone(),
shared: false,
generation: 2,
hlc_ms: 60,
op_id: format!("{other}:1"),
}],
podcast_progress: vec![ProgressRecord {
episode_id: episode_id.clone(),
podcast_id: podcast_id.clone(),
position_ms: 1,
status: ProgressStatus::InProgress,
generation: 2,
session_id: "old".into(),
hlc_ms: 999_999,
device_id: other.clone(),
op_id: format!("{other}:2"),
}],
..SyncSnapshot::default()
},
)
.await
.unwrap();
let full = snapshot(&pool, user_id).await.unwrap();
assert_eq!(full.podcast_subscriptions.len(), 1);
assert_eq!(full.podcast_shares.len(), 1);
assert_eq!(full.podcast_progress.len(), 1);
assert_eq!(full.podcast_progress[0].position_ms, 10_000);
assert_eq!(full.podcast_progress[0].generation, 4);
assert!(!full.for_peer(3).has_podcast_state());
assert_eq!(full.for_peer(4), full);
// A DeviceProfileSet with a version is a self-report of its origin.
apply_ops(
&pool,
Arc::clone(&hub),
user_id,
vec![op(
&old,
1,
70,
SyncOpPayload::DeviceProfileSet {
name: "OLD".into(),
client_version: "0.4.0".into(),
endpoint_ticket: String::new(),
endpoint_id: String::new(),
protocol_version: Some(4),
},
)],
)
.await
.unwrap();
assert_eq!(
stored_protocol_version(&pool, user_id, &old).await.unwrap(),
4
);
// First start after the upgrade announces the new version once.
sqlx::query(
"UPDATE furumusic__fed_device SET protocol_version = 3
WHERE user_id = $1 AND device_id = $2",
)
.bind(user_id)
.bind(&identity.device_id)
.execute(&pool)
.await
.unwrap();
own_profile(&pool, user_id, "", "").await.unwrap();
own_profile(&pool, user_id, "", "").await.unwrap();
let announced: Vec<serde_json::Value> = sqlx::query_scalar(
"SELECT payload_json FROM furumusic__fed_sync_ops
WHERE user_id = $1 AND origin_device_id = $2 AND kind = 'device_profile_set'",
)
.bind(user_id)
.bind(&identity.device_id)
.fetch_all(&pool)
.await
.unwrap();
assert_eq!(announced.len(), 1);
assert_eq!(announced[0]["protocol_version"], 4);
// Handoff gating: refused for the v3 device, allowed for v4.
let queue = PlaybackStateWire {
queue: vec![PlaybackTrack::podcast_episode(test_episode())],
queue_pos: 0,
playing: true,
paused: false,
idle_since_ms: None,
position_secs: 0.0,
volume: 50,
shuffle: false,
repeat: PlaybackRepeat::Off,
playback_rate: None,
};
sqlx::query(
"UPDATE furumusic__fed_device SET protocol_version = 3
WHERE user_id = $1 AND device_id = $2",
)
.bind(user_id)
.bind(&old)
.execute(&pool)
.await
.unwrap();
let refused = ensure_playback_supported_by(&pool, user_id, &old, &queue)
.await
.unwrap_err();
assert!(refused.to_string().contains("needs an update"));
ensure_playback_supported_by(&pool, user_id, &other, &queue)
.await
.unwrap();
// The typed queue column exists next to queue_json.
sqlx::query("SELECT queue_json, queue_items_json FROM furumusic__playback_state LIMIT 0")
.execute(&pool)
.await
.unwrap();
cleanup(&pool, user_id).await;
}
#[tokio::test]
#[ignore = "requires a migrated disposable database in FURU_DEVICE_SYNC_TEST_DATABASE_URL"]
async fn postgres_unknown_episode_position_and_rollback_cleanup() {
let pool = sqlx::PgPool::connect(&std::env::var("FURU_DEVICE_SYNC_TEST_DATABASE_URL").unwrap())
.await
.unwrap();
let user_id = 8_000_000_000 + i64::from(rand_suffix());
cleanup(&pool, user_id).await;
let tui = format!("tui_{user_id}");
ensure_identity(&pool, user_id, "tester").await.unwrap();
apply_device_profile(
&pool,
user_id,
&profile(&tui, 4),
VersionReport::SelfReported(Some(4)),
true,
)
.await
.unwrap();
// The TUI left the episode at 1200 s (generation 9; queue items saw 7).
let episode = test_episode();
let hub = Arc::new(PlayerDeviceHub::default());
apply_ops(
&pool,
Arc::clone(&hub),
user_id,
vec![op(
&tui,
1,
10,
SyncOpPayload::PodcastProgressSet {
episode_id: episode.episode_id.clone(),
podcast_id: episode.podcast_id.clone(),
position_ms: 1_200_000,
status: ProgressStatus::InProgress,
generation: 9,
session_id: "s9".into(),
episode: None,
},
)],
)
.await
.unwrap();
// The web player reached the episode by Next and does not know where it
// was left; it hands playback to the TUI.
let song = serde_json::json!({
"id": 77, "title": "Library song", "content_id": format!("b3:{}", "4".repeat(64)),
"duration_seconds": 300.0,
});
let item = crate::player::queue_items::external_track_json(
&PlaybackTrack::podcast_episode(episode.clone()),
1,
None,
);
let browser = serde_json::json!({
"tracks": [song.clone(), item.clone()], "index": 1, "track": item.clone(),
"position_seconds": 0.0, "paused": true, "position_unknown": true,
});
record_web_active_transfer(&pool, user_id, &tui, None, browser)
.await
.unwrap();
let sent: serde_json::Value = sqlx::query_scalar(
"SELECT payload_json FROM furumusic__fed_sync_ops
WHERE user_id = $1 AND kind = 'playback_command' ORDER BY seq DESC LIMIT 1",
)
.bind(user_id)
.fetch_one(&pool)
.await
.unwrap();
let SyncOpPayload::PlaybackCommand {
command: PlaybackCommand::ActiveChanged { state, .. },
..
} = serde_json::from_value(sent).unwrap()
else {
panic!("expected ActiveChanged");
};
assert_eq!(state.position_secs, 1200.0, "never 0");
assert_eq!(
state.queue[1]
.podcast_episode_ref()
.unwrap()
.progress_generation,
Some(9)
);
// Remote Next onto the episode while the TUI plays the song.
let current = serde_json::json!({
"tracks": [song, item], "index": 0, "track": song,
"position_seconds": 200.0, "paused": false,
});
let next = record_web_playback_command(
&pool,
user_id,
&tui,
"next",
serde_json::json!({}),
Some(current),
)
.await
.unwrap();
assert_eq!(next["index"], 1);
assert_eq!(next["position_seconds"], 1200.0);
assert!(
next.get(crate::player::queue_items::POSITION_UNKNOWN_KEY)
.is_none()
);
// Rollback to 0.12: its types fail on the relayed podcast operation, and
// parse everything once the documented cleanup ran.
let parse_like_0_12 = |rows: Vec<serde_json::Value>| {
rows.into_iter()
.map(serde_json::from_value::<super::wire_compat_tests::legacy::SyncOpPayload>)
.collect::<Result<Vec<_>, _>>()
};
let rows = || async {
sqlx::query_scalar::<_, serde_json::Value>(
"SELECT payload_json FROM furumusic__fed_sync_ops WHERE user_id = $1",
)
.bind(user_id)
.fetch_all(&pool)
.await
.unwrap()
};
assert!(parse_like_0_12(rows().await).is_err());
sqlx::query(&format!(
"{} AND user_id = $1",
crate::music::db_migrations::DELETE_PODCAST_SYNC_OPS_SQL
))
.bind(user_id)
.execute(&pool)
.await
.unwrap();
let remaining = parse_like_0_12(rows().await).unwrap();
// The playback commands (with the episode's `source`) stay readable.
assert_eq!(
remaining
.iter()
.filter(|payload| matches!(
payload,
super::wire_compat_tests::legacy::SyncOpPayload::PlaybackCommand { .. }
))
.count(),
2
);
cleanup(&pool, user_id).await;
}
fn rand_suffix() -> u32 {
u32::from_le_bytes(
blake3::hash(random_hex(8).as_bytes()).as_bytes()[..4]
.try_into()
.unwrap(),
) % 1_000_000_000
}
+524
View File
@@ -0,0 +1,524 @@
//! Golden wire-compatibility tests: the shared `music_dht::device_sync`
//! types must serialize v3 content byte-for-byte like the private copies that
//! furumi-web 0.12.x used (kept verbatim in `legacy` below), so TUI 0.3.x and
//! older web servers keep interoperating.
use super::*;
/// Private wire types of furumi-web 0.12.4 (`src/federation/devices.rs`),
/// copied verbatim apart from visibility and `PartialEq`.
#[allow(dead_code)]
pub(super) mod legacy {
use music_dht::device_sync::ListenEvent;
use music_dht::playback::CommandStamp;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InviteWire {
pub v: u16,
#[serde(rename = "t")]
pub ticket: String,
#[serde(rename = "d")]
pub device_id: String,
#[serde(rename = "i")]
pub invite_id: String,
#[serde(rename = "s")]
pub secret: String,
#[serde(rename = "e")]
pub expires_at_ms: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DeviceProfileWire {
pub device_id: String,
pub name: String,
pub client_version: String,
pub protocol_version: u16,
pub endpoint_id: String,
pub endpoint_ticket: String,
#[serde(default)]
pub revoked: bool,
#[serde(default)]
pub revoke_cutoff_seq: Option<i64>,
#[serde(default)]
pub updated_at_ms: i64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SyncedFedTrack {
pub item_id: String,
pub owner: String,
pub title: String,
#[serde(default)]
pub artist_names: Vec<String>,
#[serde(default)]
pub featured_artist_names: Vec<String>,
pub year: Option<i32>,
pub duration_seconds: Option<i64>,
pub content_id: String,
pub release_title: Option<String>,
pub track_number: Option<i32>,
pub disc_number: Option<i32>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PlaybackTrack {
pub id: i64,
pub title: String,
pub track_number: Option<i32>,
pub disc_number: Option<i32>,
pub duration_seconds: f64,
#[serde(default)]
pub artist_names: Vec<String>,
#[serde(default)]
pub featured_artist_names: Vec<String>,
pub release_id: i64,
pub release_title: String,
pub release_year: Option<i32>,
#[serde(default)]
pub file_path: String,
pub content_id: Option<String>,
pub audio_format: Option<String>,
pub audio_bitrate: Option<i32>,
pub audio_sample_rate: Option<i32>,
pub audio_bit_depth: Option<i32>,
pub file_size_bytes: Option<i64>,
#[serde(default)]
pub play_count: i64,
#[serde(default)]
pub fed: Option<SyncedFedTrack>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum PlaybackRepeat {
#[default]
Off,
One,
All,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PlaybackStateWire {
#[serde(default)]
pub queue: Vec<PlaybackTrack>,
#[serde(default)]
pub queue_pos: usize,
pub playing: bool,
pub paused: bool,
#[serde(default)]
pub idle_since_ms: Option<i64>,
pub position_secs: f64,
#[serde(default)]
pub volume: u8,
pub shuffle: bool,
pub repeat: PlaybackRepeat,
}
pub type PlaybackSnapshot = music_dht::playback::Snapshot<PlaybackStateWire>;
pub type PlaybackCommand = music_dht::playback::Command<PlaybackStateWire>;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncOpWire {
pub op_id: String,
pub origin_device_id: String,
pub seq: i64,
pub hlc_ms: i64,
pub payload: SyncOpPayload,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum SyncOpPayload {
TrackLikeSet {
content_id: String,
liked: bool,
#[serde(default)]
fed: Option<SyncedFedTrack>,
},
PlaylistCreated {
playlist_id: String,
title: String,
},
PlaylistRenamed {
playlist_id: String,
title: String,
},
PlaylistDeleted {
playlist_id: String,
},
PlaylistTrackAdded {
playlist_id: String,
content_id: String,
position: i64,
#[serde(default)]
fed: Option<SyncedFedTrack>,
},
PlaylistTrackRemoved {
playlist_id: String,
content_id: String,
},
DeviceProfileSet {
name: String,
client_version: String,
endpoint_ticket: String,
endpoint_id: String,
},
DeviceTrusted {
target_device_id: String,
},
DeviceRevoked {
target_device_id: String,
target_max_seq_seen: i64,
},
PlaybackCommand {
target_device_id: String,
command: PlaybackCommand,
#[serde(default)]
authority: Option<CommandStamp>,
},
ListenRecorded {
event: ListenEvent,
},
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SyncSnapshot {
#[serde(default)]
pub likes: Vec<SnapshotLike>,
#[serde(default)]
pub unlikes: Vec<SnapshotLikeTombstone>,
#[serde(default)]
pub playlists: Vec<SnapshotPlaylist>,
#[serde(default)]
pub deleted_playlists: Vec<SnapshotPlaylistTombstone>,
#[serde(default)]
pub removed_playlist_items: Vec<SnapshotPlaylistItemTombstone>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotLike {
pub content_id: String,
pub hlc_ms: i64,
pub op_id: String,
#[serde(default)]
pub fed: Option<SyncedFedTrack>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotLikeTombstone {
pub content_id: String,
pub hlc_ms: i64,
pub op_id: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotPlaylist {
pub playlist_id: String,
pub title: String,
pub hlc_ms: i64,
pub op_id: String,
#[serde(default)]
pub items: Vec<SnapshotPlaylistItem>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotPlaylistTombstone {
pub playlist_id: String,
pub hlc_ms: i64,
pub op_id: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotPlaylistItem {
pub content_id: String,
pub position: i64,
pub hlc_ms: i64,
pub op_id: String,
#[serde(default)]
pub fed: Option<SyncedFedTrack>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotPlaylistItemTombstone {
pub playlist_id: String,
pub content_id: String,
pub hlc_ms: i64,
pub op_id: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum WireMessage {
PairRequest {
invite_id: String,
secret: String,
profile: DeviceProfileWire,
#[serde(default)]
group_id: Option<String>,
#[serde(default)]
group_active_devices: usize,
#[serde(default)]
devices: Vec<DeviceProfileWire>,
vector: BTreeMap<String, i64>,
ops: Vec<SyncOpWire>,
snapshot: SyncSnapshot,
#[serde(default)]
playback: Option<PlaybackSnapshot>,
},
PairResponse {
accepted: bool,
#[serde(default)]
pending: bool,
#[serde(default)]
error: Option<String>,
#[serde(default)]
group_id: Option<String>,
#[serde(default)]
profile: Option<DeviceProfileWire>,
#[serde(default)]
devices: Vec<DeviceProfileWire>,
#[serde(default)]
vector: BTreeMap<String, i64>,
#[serde(default)]
ops: Vec<SyncOpWire>,
#[serde(default)]
snapshot: SyncSnapshot,
#[serde(default)]
playback: Option<PlaybackSnapshot>,
},
Hello {
group_id: String,
profile: DeviceProfileWire,
devices: Vec<DeviceProfileWire>,
vector: BTreeMap<String, i64>,
ops: Vec<SyncOpWire>,
snapshot: SyncSnapshot,
#[serde(default)]
playback: Option<PlaybackSnapshot>,
},
SyncResponse {
accepted: bool,
#[serde(default)]
error: Option<String>,
#[serde(default)]
devices: Vec<DeviceProfileWire>,
#[serde(default)]
vector: BTreeMap<String, i64>,
#[serde(default)]
ops: Vec<SyncOpWire>,
#[serde(default)]
snapshot: SyncSnapshot,
#[serde(default)]
playback: Option<PlaybackSnapshot>,
},
}
}
const CONTENT_ID: &str = "b3:1111111111111111111111111111111111111111111111111111111111111111";
/// A v3 `hello` exercising every v3 operation kind, every snapshot section
/// and a coordinated playback snapshot (input order is irrelevant).
fn v3_hello_input() -> String {
let fed = serde_json::json!({
"item_id": "item", "owner": "owner", "title": "Song", "artist_names": ["A"],
"featured_artist_names": [], "year": 2001, "duration_seconds": 180,
"content_id": CONTENT_ID, "release_title": "Album", "track_number": 1, "disc_number": 1,
});
let track = serde_json::json!({
"id": 7, "title": "Song", "track_number": 1, "disc_number": null,
"duration_seconds": 180.5, "artist_names": ["A"], "featured_artist_names": ["B"],
"release_id": 3, "release_title": "Album", "release_year": 2001, "file_path": "",
"content_id": CONTENT_ID, "audio_format": "flac", "audio_bitrate": 900,
"audio_sample_rate": 44100, "audio_bit_depth": 16, "file_size_bytes": 12345,
"play_count": 2, "fed": fed,
});
let state = serde_json::json!({
"queue": [track, {"id": 0, "title": "Remote", "track_number": null, "disc_number": null,
"duration_seconds": 0.0, "release_id": 0, "release_title": "", "release_year": null,
"content_id": null, "audio_format": null, "audio_bitrate": null,
"audio_sample_rate": null, "audio_bit_depth": null, "file_size_bytes": null}],
"queue_pos": 1, "playing": true, "paused": false, "idle_since_ms": null,
"position_secs": 42.5, "volume": 73, "shuffle": true, "repeat": "all",
});
let claim = serde_json::json!({"counter": 3, "issuer": "tui_a", "owner": "tui_a"});
let stamp = serde_json::json!({"version": 1, "claim": claim, "sequence": 9});
let op = |seq: i64, payload: serde_json::Value| {
serde_json::json!({"op_id": format!("tui_a:{seq}"), "origin_device_id": "tui_a",
"seq": seq, "hlc_ms": 1_700_000_000_000i64 + seq, "payload": payload})
};
let profile = |id: &str| {
serde_json::json!({"device_id": id, "name": "TUI", "client_version": "0.3.4",
"protocol_version": 3, "endpoint_id": "e", "endpoint_ticket": "t",
"revoked": false, "revoke_cutoff_seq": null, "updated_at_ms": 5})
};
serde_json::json!({
"type": "hello",
"group_id": "grp_1",
"profile": profile("tui_a"),
"devices": [profile("tui_a"), profile("web_b")],
"vector": {"tui_a": 12, "web_b": 4},
"ops": [
op(1, serde_json::json!({"kind": "track_like_set", "content_id": CONTENT_ID, "liked": true, "fed": fed})),
op(2, serde_json::json!({"kind": "playlist_created", "playlist_id": "pl", "title": "Mix"})),
op(3, serde_json::json!({"kind": "playlist_renamed", "playlist_id": "pl", "title": "Mix 2"})),
op(4, serde_json::json!({"kind": "playlist_track_added", "playlist_id": "pl", "content_id": CONTENT_ID, "position": 0, "fed": null})),
op(5, serde_json::json!({"kind": "playlist_track_removed", "playlist_id": "pl", "content_id": CONTENT_ID})),
op(6, serde_json::json!({"kind": "playlist_deleted", "playlist_id": "pl"})),
op(7, serde_json::json!({"kind": "device_profile_set", "name": "TUI", "client_version": "0.3.4", "endpoint_ticket": "t", "endpoint_id": "e"})),
op(8, serde_json::json!({"kind": "device_trusted", "target_device_id": "web_b"})),
op(9, serde_json::json!({"kind": "device_revoked", "target_device_id": "old", "target_max_seq_seen": 3})),
op(10, serde_json::json!({"kind": "playback_command", "target_device_id": "web_b",
"command": {"kind": "set_state", "state": state, "seek": true}, "authority": stamp})),
op(11, serde_json::json!({"kind": "playback_command", "target_device_id": "web_b",
"command": {"kind": "active_changed", "active_device_id": "web_b", "active_device_name": "WEB", "state": state}})),
op(12, serde_json::json!({"kind": "listen_recorded", "event": {"listen_id": "l1",
"content_id": CONTENT_ID, "started_at_ms": 1, "listened_ms": 60000, "track_duration_ms": 180000,
"ended_reason": "finished", "track": {"title": "Song", "artist_names": ["A"], "featured_artist_names": [], "release_title": null}}})),
],
"snapshot": {
"likes": [{"content_id": CONTENT_ID, "hlc_ms": 1, "op_id": "tui_a:1", "fed": fed}],
"unlikes": [{"content_id": CONTENT_ID, "hlc_ms": 2, "op_id": "tui_a:2"}],
"playlists": [{"playlist_id": "pl", "title": "Mix", "hlc_ms": 3, "op_id": "tui_a:3",
"items": [{"content_id": CONTENT_ID, "position": 0, "hlc_ms": 4, "op_id": "tui_a:4", "fed": null}]}],
"deleted_playlists": [{"playlist_id": "gone", "hlc_ms": 5, "op_id": "tui_a:5"}],
"removed_playlist_items": [{"playlist_id": "pl", "content_id": CONTENT_ID, "hlc_ms": 6, "op_id": "tui_a:6"}],
},
"playback": {"device_id": "tui_a", "device_name": "TUI", "active": true, "updated_at_ms": 9,
"state": state, "coordination": {"version": 1, "claim": claim, "heartbeat": 4, "available": true, "playing": true}},
})
.to_string()
}
fn v3_other_inputs() -> Vec<String> {
vec![
r#"{"type":"sync_response","accepted":false,"error":"device is not trusted"}"#.into(),
r#"{"type":"pair_response","accepted":false,"pending":true,"error":"pairing pending"}"#
.into(),
serde_json::json!({"type": "pair_request", "invite_id": "i", "secret": "s",
"profile": {"device_id": "tui_a", "name": "TUI", "client_version": "0.3.4",
"protocol_version": 3, "endpoint_id": "e", "endpoint_ticket": "t"},
"vector": {}, "ops": [], "snapshot": {}})
.to_string(),
]
}
/// Parses `input` with the 0.12.x types and the shared types and checks
/// that both serialize to the same bytes, and that each side parses the
/// other's output.
fn assert_identical(input: &str) -> String {
let old: legacy::WireMessage = serde_json::from_str(input).unwrap();
let new: WireMessage = serde_json::from_str(input).unwrap();
let old_json = serde_json::to_string(&old).unwrap();
let new_json = serde_json::to_string(&new).unwrap();
assert_eq!(old_json, new_json);
assert_eq!(
serde_json::from_str::<legacy::WireMessage>(&new_json).unwrap(),
old
);
assert_eq!(serde_json::from_str::<WireMessage>(&old_json).unwrap(), new);
new_json
}
#[test]
fn v3_messages_serialize_like_furumi_web_0_12() {
let hello = assert_identical(&v3_hello_input());
let golden = concat!(
env!("CARGO_MANIFEST_DIR"),
"/src/federation/devices/fixtures/v3_hello.golden.json"
);
if std::env::var_os("FURUMUSIC_BLESS_GOLDEN").is_some() {
// Only for a deliberate change of the v3 shape.
std::fs::write(golden, format!("{hello}\n")).unwrap();
}
assert_eq!(hello, std::fs::read_to_string(golden).unwrap().trim_end());
for input in v3_other_inputs() {
assert_identical(&input);
}
}
#[test]
fn invites_stay_readable_by_older_clients() {
let old = legacy::InviteWire {
v: 1,
ticket: "ticket".into(),
device_id: "web_a".into(),
invite_id: "inv".into(),
secret: "s3cr3t".into(),
expires_at_ms: 10,
};
let old_json = serde_json::to_string(&old).unwrap();
assert_eq!(
old_json,
r#"{"v":1,"t":"ticket","d":"web_a","i":"inv","s":"s3cr3t","e":10}"#
);
let shared: InviteWire = serde_json::from_str(&old_json).unwrap();
assert_eq!(shared.inviter_protocol_version(), 1);
assert_eq!(serde_json::to_string(&shared).unwrap(), old_json);
let link = encode_invite(&InviteWire {
protocol_version: Some(PROTOCOL_VERSION),
..shared
})
.unwrap();
let parsed = parse_invite(&link).unwrap();
assert_eq!(parsed.inviter_protocol_version(), PROTOCOL_VERSION);
// `p` is an unknown field for 0.12.x and is ignored there.
let token = link.strip_prefix("frid://i/").unwrap();
assert!(!token.is_empty());
let json = serde_json::to_string(&parsed).unwrap();
assert!(json.ends_with(r#","p":4}"#));
assert_eq!(
serde_json::from_str::<legacy::InviteWire>(&json).unwrap(),
old
);
}
#[test]
fn v3_peers_cannot_parse_podcast_operations() {
// Why podcast operations must be gated: an unknown `kind` breaks the
// whole message for a 0.12.x/TUI 0.3.x peer, not one operation.
let mut hello: serde_json::Value = serde_json::from_str(&v3_hello_input()).unwrap();
hello["ops"].as_array_mut().unwrap().push(serde_json::json!({
"op_id": "tui_a:13", "origin_device_id": "tui_a", "seq": 13, "hlc_ms": 13,
"payload": {"kind": "podcast_share_set",
"podcast_id": music_dht::podcast::PodcastId::from_feed_url(
&music_dht::podcast::FeedUrl::parse("https://podcasts.example/feed.xml").unwrap()),
"shared": false, "generation": 1},
}));
assert!(serde_json::from_value::<legacy::WireMessage>(hello.clone()).is_err());
assert!(serde_json::from_value::<WireMessage>(hello).is_ok());
}
#[test]
fn v3_peers_would_drop_the_source_of_podcast_items() {
// Why podcast playback must be gated: older types ignore `source` and
// forward the episode as a broken music item.
let episode = PlaybackTrack::podcast_episode(crate::player::queue_items::test_episode());
let json = serde_json::to_string(&episode).unwrap();
assert!(json.contains(r#""source":{"kind":"podcast_episode""#));
let old: legacy::PlaybackTrack = serde_json::from_str(&json).unwrap();
let forwarded: PlaybackTrack =
serde_json::from_str(&serde_json::to_string(&old).unwrap()).unwrap();
assert_eq!(forwarded.source, None);
assert_eq!(forwarded.id, 0);
}
#[test]
fn v4_profile_announcements_stay_readable_by_older_clients() {
let announcement = SyncOpPayload::DeviceProfileSet {
name: "WEB".into(),
client_version: "0.13.0".into(),
endpoint_ticket: "t".into(),
endpoint_id: "e".into(),
protocol_version: Some(PROTOCOL_VERSION),
};
let json = serde_json::to_string(&announcement).unwrap();
assert!(json.ends_with(r#","protocol_version":4}"#));
// 0.12.x and TUI 0.3.x ignore the new field.
let old: legacy::SyncOpPayload = serde_json::from_str(&json).unwrap();
assert!(matches!(
old,
legacy::SyncOpPayload::DeviceProfileSet { .. }
));
}
+13
View File
@@ -17,6 +17,7 @@
mod capabilities;
pub mod client;
pub mod devices;
mod podcast_relay;
mod receive;
mod serve;
mod similarity;
@@ -1192,6 +1193,18 @@ impl Federation {
.await
}
/// Refuses a transfer that the target device cannot receive (podcast
/// items for a device below protocol v4) before ownership changes.
pub async fn fed_device_web_transfer_check(
&self,
user_id: i64,
target_device_id: &str,
state: serde_json::Value,
) -> Result<()> {
let pool = self.pool().await?;
devices::check_web_transfer(&pool, user_id, target_device_id, state).await
}
pub async fn fed_device_web_active_takeover(
&self,
user_id: i64,
+575
View File
@@ -0,0 +1,575 @@
//! Lossless relay of podcast sync state (device-sync protocol v4).
//!
//! The web server does not implement podcasts yet, but it announces protocol
//! v4 and therefore must not lose podcast state that trusted devices send
//! through it:
//!
//! * podcast operations are stored verbatim in the generic operation log
//! (`furumusic__fed_sync_ops`) and forwarded to v4 peers only;
//! * the podcast registers carried by those operations and by snapshot
//! sections are kept here as opaque JSON documents, merged with the shared
//! `music_dht::podcast` rules, and returned in this device's snapshots.
//! Snapshots are the only recovery path for a peer that skipped podcast
//! operations while it ran an older version.
//!
//! The rows hold the shared contract types (`SubscriptionRecord`,
//! `ShareRecord`, `ProgressRecord`, `ListenSession`) as JSON and nothing
//! web-specific; a later podcast store can import them.
use anyhow::Result;
use music_dht::device_sync::{SyncOpWire, SyncSnapshot};
use music_dht::podcast::{
FeedUrl, ListenSession, PodcastId, ProgressRecord, ShareRecord, SubscriptionRecord,
merge_feed_aliases, merge_listen_session, merge_progress, merge_share, merge_subscription,
};
use serde::Serialize;
use serde::de::DeserializeOwned;
use serde_json::Value;
use sqlx::Row;
const SECTION_SUBSCRIPTION: &str = "subscription";
const SECTION_SHARE: &str = "share";
const SECTION_ALIASES: &str = "aliases";
const SECTION_PROGRESS: &str = "progress";
const SECTION_SESSION: &str = "session";
/// One podcast register update, keyed by its entity.
#[derive(Debug, Clone, PartialEq)]
pub(crate) enum RelayRecord {
/// Subscription register of a podcast.
Subscription(SubscriptionRecord),
/// Share register of a podcast.
Share(ShareRecord),
/// Feed aliases learned before (or without) the subscription register.
Aliases(PodcastId, Vec<FeedUrl>),
/// Progress register of an episode.
Progress(ProgressRecord),
/// Listening session.
Session(ListenSession),
}
impl RelayRecord {
fn section(&self) -> &'static str {
match self {
RelayRecord::Subscription(_) => SECTION_SUBSCRIPTION,
RelayRecord::Share(_) => SECTION_SHARE,
RelayRecord::Aliases(..) => SECTION_ALIASES,
RelayRecord::Progress(_) => SECTION_PROGRESS,
RelayRecord::Session(_) => SECTION_SESSION,
}
}
fn key(&self) -> &str {
match self {
RelayRecord::Subscription(record) => record.podcast_id.as_str(),
RelayRecord::Share(record) => record.podcast_id.as_str(),
RelayRecord::Aliases(podcast_id, _) => podcast_id.as_str(),
RelayRecord::Progress(record) => record.episode_id.as_str(),
RelayRecord::Session(session) => session.session_id.as_str(),
}
}
/// Register updates carried by a podcast operation.
///
/// Operations that fail `validate_podcast` must be dropped before this.
pub(crate) fn from_op(op: &SyncOpWire) -> Option<Self> {
if let Some(record) = op.podcast_subscription() {
return Some(RelayRecord::Subscription(record));
}
if let Some(record) = op.podcast_share() {
return Some(RelayRecord::Share(record));
}
if let Some((podcast_id, aliases)) = op.podcast_feed_aliases() {
return Some(RelayRecord::Aliases(podcast_id.clone(), aliases.to_vec()));
}
if let Some(record) = op.podcast_progress() {
return Some(RelayRecord::Progress(record));
}
op.podcast_listen_session()
.map(|session| RelayRecord::Session(session.clone()))
}
/// Valid register records of a snapshot. Podcast sections that exceed
/// the contract counts are ignored as a whole; invalid records are
/// skipped one by one.
pub(crate) fn from_snapshot(snapshot: &SyncSnapshot) -> Vec<Self> {
if !snapshot.podcast_state_within_limits() {
tracing::debug!("ignored podcast snapshot sections above the contract limits");
return Vec::new();
}
let subscriptions = snapshot
.podcast_subscriptions
.iter()
.filter(|record| record.validate().is_ok())
.cloned()
.map(RelayRecord::Subscription);
let shares = snapshot
.podcast_shares
.iter()
.filter(|record| record.validate().is_ok())
.cloned()
.map(RelayRecord::Share);
let progress = snapshot
.podcast_progress
.iter()
.filter(|record| record.validate().is_ok())
.cloned()
.map(RelayRecord::Progress);
let sessions = snapshot
.podcast_listen_sessions
.iter()
.filter(|session| session.validate().is_ok())
.cloned()
.map(RelayRecord::Session);
subscriptions
.chain(shares)
.chain(progress)
.chain(sessions)
.collect()
}
}
/// Document address: `(section, record_key)`.
type DocKey = (&'static str, String);
/// Documents a record's merge reads.
fn read_keys(record: &RelayRecord) -> Vec<DocKey> {
let own = (record.section(), record.key().to_string());
match record {
RelayRecord::Aliases(podcast_id, _) => {
vec![(SECTION_SUBSCRIPTION, podcast_id.as_str().to_string()), own]
}
RelayRecord::Subscription(_) => {
vec![(SECTION_ALIASES, record.key().to_string()), own]
}
_ => vec![own],
}
}
/// Merges `incoming` into the stored documents with the shared rules.
///
/// Returns the writes: `Some(value)` upserts, `None` deletes. Aliases
/// learned before the subscription register are kept in their own document
/// and folded into the register when it arrives.
fn plan_merge(
docs: &std::collections::BTreeMap<DocKey, Value>,
incoming: &RelayRecord,
) -> Vec<(DocKey, Option<Value>)> {
let own = (incoming.section(), incoming.key().to_string());
let current = docs.get(&own);
let changed = |merged: Option<Value>| {
merged
.filter(|merged| current != Some(merged))
.map(|merged| (own.clone(), Some(merged)))
};
match incoming {
RelayRecord::Subscription(record) => {
let alias_key = (SECTION_ALIASES, incoming.key().to_string());
let pending = docs.get(&alias_key).and_then(parse::<Vec<FeedUrl>>);
let merged = match current.and_then(parse::<SubscriptionRecord>) {
Some(current) => merge_subscription(&current, record).ok(),
None => {
let mut record = record.clone();
record.normalize();
Some(record)
}
}
.map(|mut record| {
if let Some(aliases) = &pending {
record.add_feed_aliases(aliases);
}
record
});
let mut writes: Vec<_> = changed(merged.as_ref().and_then(to_value))
.into_iter()
.collect();
if docs.contains_key(&alias_key) && merged.is_some() {
writes.push((alias_key, None));
}
writes
}
RelayRecord::Aliases(podcast_id, aliases) => {
let sub_key = (SECTION_SUBSCRIPTION, podcast_id.as_str().to_string());
if let Some(subscription) = docs.get(&sub_key) {
let Some(mut record) = parse::<SubscriptionRecord>(subscription) else {
return Vec::new();
};
record.add_feed_aliases(aliases);
return to_value(&record)
.filter(|merged| merged != subscription)
.map(|merged| vec![(sub_key, Some(merged))])
.unwrap_or_default();
}
let current = current.and_then(parse::<Vec<FeedUrl>>).unwrap_or_default();
changed(to_value(&merge_feed_aliases(podcast_id, &current, aliases)))
.into_iter()
.collect()
}
RelayRecord::Share(record) => changed(match current.and_then(parse::<ShareRecord>) {
Some(current) => merge_share(&current, record)
.ok()
.as_ref()
.and_then(to_value),
None => to_value(record),
})
.into_iter()
.collect(),
RelayRecord::Progress(record) => changed(match current.and_then(parse::<ProgressRecord>) {
Some(current) => merge_progress(&current, record)
.ok()
.as_ref()
.and_then(to_value),
None => to_value(record),
})
.into_iter()
.collect(),
RelayRecord::Session(session) => changed(match current.and_then(parse::<ListenSession>) {
Some(current) => merge_listen_session(&current, session)
.ok()
.as_ref()
.and_then(to_value),
None => to_value(session),
})
.into_iter()
.collect(),
}
}
fn parse<T: DeserializeOwned>(value: &Value) -> Option<T> {
serde_json::from_value(value.clone()).ok()
}
fn to_value<T: Serialize>(value: &T) -> Option<Value> {
serde_json::to_value(value).ok()
}
/// Merges register updates into the user's relay state.
pub(crate) async fn merge_records(
pool: &sqlx::PgPool,
user_id: i64,
records: &[RelayRecord],
) -> Result<()> {
if records.is_empty() {
return Ok(());
}
let mut tx = pool.begin().await?;
// One writer per account: a merge reads, combines and writes documents.
sqlx::query(
"SELECT pg_advisory_xact_lock(hashtextextended('furumusic:podcast-relay:' || $1::text, 0))",
)
.bind(user_id)
.execute(&mut *tx)
.await?;
let mut docs = std::collections::BTreeMap::new();
for record in records {
for key in read_keys(record) {
if !docs.contains_key(&key)
&& let Some(value) = load(&mut tx, user_id, key.0, &key.1).await?
{
docs.insert(key, value);
}
}
for (key, value) in plan_merge(&docs, record) {
match &value {
Some(value) => store(&mut tx, user_id, key.0, &key.1, value).await?,
None => {
sqlx::query(
"DELETE FROM furumusic__fed_podcast_relay
WHERE user_id = $1 AND section = $2 AND record_key = $3",
)
.bind(user_id)
.bind(key.0)
.bind(&key.1)
.execute(&mut *tx)
.await?;
}
}
match value {
Some(value) => docs.insert(key, value),
None => docs.remove(&key),
};
}
}
tx.commit().await?;
Ok(())
}
async fn load(
tx: &mut sqlx::Transaction<'_, sqlx::Postgres>,
user_id: i64,
section: &str,
key: &str,
) -> Result<Option<Value>> {
Ok(sqlx::query_scalar(
"SELECT record_json FROM furumusic__fed_podcast_relay
WHERE user_id = $1 AND section = $2 AND record_key = $3",
)
.bind(user_id)
.bind(section)
.bind(key)
.fetch_optional(&mut **tx)
.await?)
}
async fn store(
tx: &mut sqlx::Transaction<'_, sqlx::Postgres>,
user_id: i64,
section: &str,
key: &str,
value: &Value,
) -> Result<()> {
sqlx::query(
"INSERT INTO furumusic__fed_podcast_relay
(user_id, section, record_key, record_json, updated_at_ms)
VALUES ($1, $2, $3, $4, $5)
ON CONFLICT (user_id, section, record_key) DO UPDATE SET
record_json = EXCLUDED.record_json,
updated_at_ms = EXCLUDED.updated_at_ms",
)
.bind(user_id)
.bind(section)
.bind(key)
.bind(value)
.bind(chrono::Utc::now().timestamp_millis())
.execute(&mut **tx)
.await?;
Ok(())
}
/// Relayed progress register of an episode, if any.
pub(crate) async fn progress_record(
pool: &sqlx::PgPool,
user_id: i64,
episode_id: &str,
) -> Result<Option<ProgressRecord>> {
let value: Option<Value> = sqlx::query_scalar(
"SELECT record_json FROM furumusic__fed_podcast_relay
WHERE user_id = $1 AND section = $2 AND record_key = $3",
)
.bind(user_id)
.bind(SECTION_PROGRESS)
.bind(episode_id)
.fetch_optional(pool)
.await?;
Ok(value.as_ref().and_then(parse))
}
/// Adds the relayed podcast registers to `snapshot`.
///
/// The sections are bounded later, per message, with the contract budget
/// (`SyncSnapshot::bound_podcast_state_to`) and stripped for peers below v4
/// (`SyncSnapshot::for_peer`).
pub(crate) async fn fill_snapshot(
pool: &sqlx::PgPool,
user_id: i64,
snapshot: &mut SyncSnapshot,
) -> Result<()> {
let rows = sqlx::query(
"SELECT section, record_json FROM furumusic__fed_podcast_relay
WHERE user_id = $1 AND section <> $2
ORDER BY section, record_key",
)
.bind(user_id)
.bind(SECTION_ALIASES)
.fetch_all(pool)
.await?;
for row in rows {
let section: String = row.get("section");
let value: Value = row.get("record_json");
fill_section(snapshot, &section, &value);
}
Ok(())
}
fn fill_section(snapshot: &mut SyncSnapshot, section: &str, value: &Value) {
match section {
SECTION_SUBSCRIPTION => snapshot.podcast_subscriptions.extend(parse(value)),
SECTION_SHARE => snapshot.podcast_shares.extend(parse(value)),
SECTION_PROGRESS => snapshot.podcast_progress.extend(parse(value)),
SECTION_SESSION => snapshot.podcast_listen_sessions.extend(parse(value)),
_ => {}
}
}
#[cfg(test)]
mod tests {
use super::*;
use music_dht::device_sync::{SyncOpPayload, SyncOpWire};
use music_dht::podcast::{EpisodeId, PodcastMeta, ProgressStatus};
use std::collections::BTreeMap;
fn feed(path: &str) -> FeedUrl {
FeedUrl::parse(&format!("https://podcasts.example/{path}")).unwrap()
}
fn meta() -> PodcastMeta {
serde_json::from_value(serde_json::json!({
"feed_url": feed("feed.xml").as_str(),
"title": "Example Cast",
"description": "Long channel description",
}))
.unwrap()
}
fn podcast() -> PodcastId {
PodcastId::from_feed_url(&feed("feed.xml"))
}
fn op(seq: i64, hlc_ms: i64, payload: SyncOpPayload) -> SyncOpWire {
SyncOpWire {
op_id: format!("tui_a:{seq}"),
origin_device_id: "tui_a".into(),
seq,
hlc_ms,
payload,
}
}
fn progress(seq: i64, generation: u64, hlc_ms: i64, position_ms: i64) -> SyncOpWire {
let podcast_id = podcast();
op(
seq,
hlc_ms,
SyncOpPayload::PodcastProgressSet {
episode_id: EpisodeId::from_guid(&podcast_id, "ep-1").unwrap(),
podcast_id,
position_ms,
status: ProgressStatus::InProgress,
generation,
session_id: format!("s{generation}"),
episode: None,
},
)
}
/// Applies records to an in-memory table with the production plan.
fn apply(state: &mut BTreeMap<DocKey, Value>, records: &[RelayRecord]) {
for record in records {
for (key, value) in plan_merge(state, record) {
match value {
Some(value) => state.insert(key, value),
None => state.remove(&key),
};
}
}
}
fn snapshot_of(state: &BTreeMap<DocKey, Value>) -> SyncSnapshot {
let mut snapshot = SyncSnapshot::default();
for ((section, _), value) in state {
fill_section(&mut snapshot, section, value);
}
snapshot
}
#[test]
fn progress_registers_follow_the_contract_in_any_order() {
// A late checkpoint of an older generation never wins, whatever its clock.
let ops = [
progress(1, 3, 9_000, 600_000),
progress(2, 4, 1_000, 10_000),
];
for order in [[0, 1], [1, 0]] {
let mut state = BTreeMap::new();
for index in order {
apply(&mut state, &[RelayRecord::from_op(&ops[index]).unwrap()]);
}
let snapshot = snapshot_of(&state);
assert_eq!(snapshot.podcast_progress.len(), 1);
assert_eq!(snapshot.podcast_progress[0].position_ms, 10_000);
assert_eq!(snapshot.podcast_progress[0].generation, 4);
}
}
#[test]
fn snapshot_sections_survive_the_relay() {
let subscribe = op(
1,
10,
SyncOpPayload::PodcastSubscriptionSet {
podcast_id: podcast(),
subscribed: true,
podcast: meta(),
feed_aliases: vec![],
generation: 1,
},
);
let share = op(
2,
11,
SyncOpPayload::PodcastShareSet {
podcast_id: podcast(),
shared: false,
generation: 1,
},
);
let mut source = BTreeMap::new();
for op in [&subscribe, &share, &progress(3, 2, 12, 5_000)] {
op.validate_podcast().unwrap();
apply(&mut source, &[RelayRecord::from_op(op).unwrap()]);
}
let mut sent = snapshot_of(&source);
sent.bound_podcast_state();
// A second relay that only saw the snapshot re-emits the same state.
let mut relay = BTreeMap::new();
apply(&mut relay, &RelayRecord::from_snapshot(&sent));
let mut relayed = snapshot_of(&relay);
relayed.bound_podcast_state();
assert_eq!(relayed, sent);
assert!(!relayed.podcast_shares[0].shared);
assert!(relayed.podcast_subscriptions[0].subscribed);
// Peers below v4 never receive the sections.
assert!(!relayed.for_peer(3).has_podcast_state());
assert!(relayed.for_peer(4).has_podcast_state());
}
#[test]
fn aliases_learned_before_the_subscription_are_merged_into_it() {
let aliases = op(
1,
10,
SyncOpPayload::PodcastFeedAliasesAdded {
podcast_id: podcast(),
feed_aliases: vec![feed("moved.xml")],
},
);
let subscribe = op(
2,
11,
SyncOpPayload::PodcastSubscriptionSet {
podcast_id: podcast(),
subscribed: true,
podcast: meta(),
feed_aliases: vec![],
generation: 1,
},
);
let mut state = BTreeMap::new();
apply(&mut state, &[RelayRecord::from_op(&aliases).unwrap()]);
apply(&mut state, &[RelayRecord::from_op(&subscribe).unwrap()]);
let snapshot = snapshot_of(&state);
assert_eq!(
snapshot.podcast_subscriptions[0].feed_urls(),
vec![feed("feed.xml"), feed("moved.xml")]
);
assert!(!state.keys().any(|(section, _)| *section == SECTION_ALIASES));
}
#[test]
fn oversized_snapshot_sections_are_ignored() {
let mut snapshot = SyncSnapshot::default();
let record = RelayRecord::from_op(&progress(1, 1, 1, 1)).unwrap();
let RelayRecord::Progress(record) = record else {
unreachable!()
};
snapshot.podcast_progress = vec![record; music_dht::podcast::MAX_SNAPSHOT_PROGRESS + 1];
assert!(RelayRecord::from_snapshot(&snapshot).is_empty());
snapshot
.podcast_progress
.truncate(music_dht::podcast::MAX_SNAPSHOT_PROGRESS);
assert_eq!(
RelayRecord::from_snapshot(&snapshot).len(),
music_dht::podcast::MAX_SNAPSHOT_PROGRESS
);
}
}
+11 -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" , "Добавить в очередь";
@@ -378,6 +382,8 @@ translations! {
player_clear: "Clear" , "Очистить";
player_remove: "Remove" , "Удалить";
player_queue_empty: "Queue is empty" , "Очередь пуста";
player_queue_podcast_unplayable: "Podcast · not playable in the web player yet", "Подкаст · пока не воспроизводится в веб-плеере";
player_queue_private_item: "Private item · hidden by its owner", "Приватный элемент · скрыт владельцем";
player_shuffle: "Shuffle" , "Перемешать";
player_repeat: "Repeat" , "Повтор";
player_volume: "Volume" , "Громкость";
@@ -408,6 +414,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
{
+24 -2
View File
@@ -20,6 +20,7 @@ struct PlaybackStateRow {
current_track_id: Option<i64>,
position_ms: i32,
queue_json: String,
queue_items_json: Option<serde_json::Value>,
queue_position: i32,
}
@@ -738,7 +739,7 @@ async fn cleanup_playback_states(
) -> anyhow::Result<()> {
let deleted: HashSet<i64> = track_ids.iter().copied().collect();
let states: Vec<PlaybackStateRow> = sqlx::query_as(
"SELECT id, current_track_id, position_ms, queue_json, queue_position FROM furumusic__playback_state FOR UPDATE",
"SELECT id, current_track_id, position_ms, queue_json, queue_items_json, queue_position FROM furumusic__playback_state FOR UPDATE",
)
.fetch_all(&mut **transaction)
.await?;
@@ -746,6 +747,14 @@ async fn cleanup_playback_states(
for state in states {
let mut queue: Vec<i64> = serde_json::from_str(&state.queue_json).unwrap_or_default();
let original_queue = queue.clone();
let mut typed = crate::player::queue_items::StoredQueue::from_columns(
state.queue_items_json.as_ref(),
&crate::player::queue_items::LegacyColumns {
queue: original_queue.clone(),
current_track_id: state.current_track_id,
queue_position: state.queue_position,
},
);
queue.retain(|track_id| !deleted.contains(track_id));
let current_track_id = state.current_track_id.filter(|id| !deleted.contains(id));
if queue == original_queue && current_track_id == state.current_track_id {
@@ -763,16 +772,28 @@ async fn cleanup_playback_states(
.clamp(0, i32::try_from(queue.len() - 1).unwrap_or(i32::MAX))
}
});
if let Some(typed) = &mut typed {
typed.retain_library(
|track_id| !deleted.contains(&track_id),
crate::player::queue_items::LegacyColumns {
queue: queue.clone(),
current_track_id,
queue_position,
},
);
}
let position_ms = if current_track_id.is_some() {
state.position_ms
} else {
0
};
let queue_json = serde_json::to_string(&queue)?;
// The typed queue keeps its other items; a stale one is cleared.
let queue_items_json = typed.map(serde_json::to_value).transpose()?;
sqlx::query(
r#"UPDATE furumusic__playback_state
SET current_track_id = $2, position_ms = $3,
queue_json = $4, queue_position = $5
queue_json = $4, queue_position = $5, queue_items_json = $6
WHERE id = $1"#,
)
.bind(state.id)
@@ -780,6 +801,7 @@ async fn cleanup_playback_states(
.bind(position_ms)
.bind(queue_json)
.bind(queue_position)
.bind(queue_items_json)
.execute(&mut **transaction)
.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"),
+155 -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,157 @@ 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()];
}
// -- M0054: typed playback queue next to the legacy id list ------------
// (`m_0053` is taken by `src/user.rs` in the same app.)
// `queue_json` keeps the library track ids and is still written, so an
// older release can run against the same database. The typed value adds
// the items that are not library tracks (podcast episodes, unresolved
// federated music, Jam placeholders) with their explicit source.
#[cot::db::migrations::migration_op]
async fn add_typed_playback_queue(
ctx: migrations::MigrationContext<'_>,
) -> cot::db::Result<()> {
ctx.db
.raw(
"ALTER TABLE furumusic__playback_state
ADD COLUMN IF NOT EXISTS queue_items_json JSONB",
)
.await?;
Ok(())
}
#[cot::db::migrations::migration_op]
async fn drop_typed_playback_queue(
ctx: migrations::MigrationContext<'_>,
) -> cot::db::Result<()> {
ctx.db
.raw("ALTER TABLE furumusic__playback_state DROP COLUMN IF EXISTS queue_items_json")
.await?;
Ok(())
}
#[derive(Debug, Copy, Clone)]
pub struct M0054AddTypedPlaybackQueue;
impl migrations::Migration for M0054AddTypedPlaybackQueue {
const APP_NAME: &'static str = "furumusic";
const MIGRATION_NAME: &'static str = "m_0054_add_typed_playback_queue";
const DEPENDENCIES: &'static [migrations::MigrationDependency] =
&[migrations::MigrationDependency::migration(
"furumusic",
"m_0052_add_import_playlist_destinations",
)];
const OPERATIONS: &'static [Operation] = &[Operation::custom(add_typed_playback_queue)
.backwards(drop_typed_playback_queue)
.build()];
}
// -- M0055: opaque podcast sync relay state (device-sync protocol v4) ---
// Podcast registers received from trusted devices, kept as the shared
// contract JSON so this server can return them in its snapshots. This is
// not the podcast store: the web player has no podcast features yet.
#[cot::db::migrations::migration_op]
async fn create_fed_podcast_relay(
ctx: migrations::MigrationContext<'_>,
) -> cot::db::Result<()> {
ctx.db
.raw(
"CREATE TABLE IF NOT EXISTS furumusic__fed_podcast_relay (
user_id BIGINT NOT NULL,
section VARCHAR(16) NOT NULL,
record_key TEXT NOT NULL,
record_json JSONB NOT NULL,
updated_at_ms BIGINT NOT NULL,
PRIMARY KEY (user_id, section, record_key)
)",
)
.await?;
Ok(())
}
/// Removes the operations a 0.12.x release cannot parse: the podcast
/// kinds relayed since device-sync protocol 4. Ends with its `WHERE`
/// clause, so tests can narrow it to one user.
pub(crate) const DELETE_PODCAST_SYNC_OPS_SQL: &str =
"DELETE FROM furumusic__fed_sync_ops WHERE kind LIKE 'podcast\\_%'";
// Release 0.12.x parses every unacknowledged operation it sends to a
// peer and fails the whole batch on an unknown kind, so the podcast
// operations relayed by 0.13 must go before it runs again (see
// docs/administration.md, "Rolling back to 0.12").
#[cot::db::migrations::migration_op]
async fn drop_fed_podcast_relay(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
ctx.db.raw(DELETE_PODCAST_SYNC_OPS_SQL).await?;
ctx.db
.raw("DROP TABLE IF EXISTS furumusic__fed_podcast_relay")
.await?;
Ok(())
}
#[derive(Debug, Copy, Clone)]
pub struct M0055CreateFedPodcastRelay;
impl migrations::Migration for M0055CreateFedPodcastRelay {
const APP_NAME: &'static str = "furumusic";
const MIGRATION_NAME: &'static str = "m_0055_create_fed_podcast_relay";
const DEPENDENCIES: &'static [migrations::MigrationDependency] =
&[migrations::MigrationDependency::migration(
"furumusic",
"m_0054_add_typed_playback_queue",
)];
const OPERATIONS: &'static [Operation] = &[Operation::custom(create_fed_podcast_relay)
.backwards(drop_fed_podcast_relay)
.build()];
}
pub const MIGRATIONS: &[&SyncDynMigration] = &[
&M0006CreateMediaFile,
&M0007CreateArtist,
@@ -2916,5 +2983,9 @@ pub mod db_migrations {
&M0048AddPlaybackCoordinationColumns,
&M0049AddLastfmLookupState,
&M0050CreateMetadataFixHistory,
&M0051AddListenStatisticsIndexes,
&M0052AddImportPlaylistDestinations,
&M0054AddTypedPlaybackQueue,
&M0055CreateFedPodcastRelay,
];
}
+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());
}
}
+16 -1
View File
@@ -147,6 +147,17 @@ pub(super) struct PlaybackStateDto {
pub(super) shuffle: bool,
pub(super) repeat_mode: String,
pub(super) volume: f64,
/// Typed queue (podcast episodes and other non-library items included).
///
/// Requests send `{"kind": "library", "track_id"}` and
/// `{"kind": "external", "track": <device-sync PlaybackTrack>}` items;
/// responses return external items as browser track JSON. Clients that
/// omit it keep using `queue`, which is always written.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(super) queue_items: Option<serde_json::Value>,
/// Index of the current item in `queue_items`.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(super) queue_items_position: Option<usize>,
}
#[derive(Debug, Deserialize, JsonSchema)]
@@ -263,6 +274,10 @@ pub(super) struct PlayerDevicePlaybackStateDto {
pub(super) volume: f64,
#[serde(default)]
pub(super) updated_at_ms: i64,
/// The browser does not know the position of its current item, a podcast
/// episode it cannot play (`queue_items::POSITION_UNKNOWN_KEY`).
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub(super) position_unknown: bool,
}
#[derive(Debug, Serialize, JsonSchema)]
@@ -324,7 +339,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>,
+663 -570
View File
File diff suppressed because it is too large. Load diff
+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,
+701
View File
@@ -0,0 +1,701 @@
//! Lossless queue items shared by the browser player, device sync and the
//! persisted playback state.
//!
//! The browser queue holds plain track JSON objects. Library tracks of this
//! server keep their usual shape. Every other item received from a trusted
//! device (unresolved federated music, podcast episodes, Jam private
//! placeholders) becomes an *external* item: display fields for the queue UI
//! plus the verbatim device-sync DTO under [`WIRE_TRACK_KEY`] and its explicit
//! [`PlaybackSource`] under [`SOURCE_KEY`]. Converting back to the wire uses
//! the verbatim DTO, so such items survive browser -> server -> peers ->
//! server -> browser unchanged even though this web player cannot play them.
//!
//! Gating and Jam decisions are delegated to `music_dht::device_sync`; this
//! module only maps browser JSON onto the shared DTOs.
use music_dht::device_sync::{
PRIVATE_ITEM_TITLE, PlaybackCommand, PlaybackSource, PlaybackStateWire, PlaybackTrack,
jam_command_allowed, redact_for_jam, restore_jam_private_items,
};
use serde::{Deserialize, Serialize};
use serde_json::Value;
/// Browser track key holding the verbatim [`PlaybackTrack`] of an external item.
pub(crate) const WIRE_TRACK_KEY: &str = "wire_track";
/// Browser track key holding the explicit [`PlaybackSource`] of an external item.
pub(crate) const SOURCE_KEY: &str = "source";
/// Browser playback state key: `true` when the browser does not know the
/// position of its current item. That happens when it selects a podcast
/// episode it cannot play (Next, auto-advance, a click or a play command):
/// it is never told where the episode was left, and inventing 0 would
/// restart the episode for every device. The server then takes the
/// position from the episode's progress register.
pub(crate) const POSITION_UNKNOWN_KEY: &str = "position_unknown";
/// Reason shown for federated music that is not in this library.
pub(crate) const FED_UNAVAILABLE_REASON: &str = "Not available on this web player yet";
/// Reason shown for podcast episodes, which this web player cannot play yet.
pub(crate) const PODCAST_UNAVAILABLE_REASON: &str =
"Podcast episodes cannot be played on the web player yet";
/// Reason shown for Jam placeholders of someone else's private item.
pub(crate) const PRIVATE_UNAVAILABLE_REASON: &str = "Private item of the Jam host";
/// Version of the typed queue stored in `furumusic__playback_state.queue_items_json`.
pub(crate) const STORED_QUEUE_VERSION: u16 = 1;
/// Upper bound of persisted queue items; larger queues keep only `queue_json`.
pub(crate) const MAX_STORED_QUEUE_ITEMS: usize = 10_000;
/// Browser JSON for a queue item that is not a library track of this server.
///
/// `content_id` is the normalized content id of a music item, when known.
/// The `id` is a negative placeholder that is stable for the item and its
/// queue position, so the browser can tell items apart; it never refers to a
/// library track.
pub(crate) fn external_track_json(
track: &PlaybackTrack,
index: usize,
content_id: Option<&str>,
) -> Value {
let mut json = match &track.source {
Some(PlaybackSource::PodcastEpisode(episode)) => serde_json::json!({
"id": placeholder_track_id(Some(episode.episode_id.as_str()), index),
"title": episode.episode_title,
"track_number": serde_json::Value::Null,
"disc_number": serde_json::Value::Null,
"duration_seconds": episode.duration_ms.unwrap_or(0).max(0) as f64 / 1_000.0,
"artists": artist_names_to_json(std::slice::from_ref(&episode.podcast_title)),
"featured_artists": [],
"release_id": 0,
"release_title": episode.podcast_title,
"release_year": serde_json::Value::Null,
"cover_url": serde_json::Value::Null,
"stream_url": "",
"uploader_name": "Podcast",
"audio_format": episode.mime,
"content_id": serde_json::Value::Null,
"unavailable": true,
"unavailable_reason": PODCAST_UNAVAILABLE_REASON,
}),
Some(PlaybackSource::Private) => serde_json::json!({
"id": placeholder_track_id(Some("private"), index),
"title": PRIVATE_ITEM_TITLE,
"track_number": serde_json::Value::Null,
"disc_number": serde_json::Value::Null,
"duration_seconds": 0.0,
"artists": [],
"featured_artists": [],
"release_id": 0,
"release_title": "",
"release_year": serde_json::Value::Null,
"cover_url": serde_json::Value::Null,
"stream_url": "",
"uploader_name": "",
"content_id": serde_json::Value::Null,
"unavailable": true,
"unavailable_reason": PRIVATE_UNAVAILABLE_REASON,
}),
Some(PlaybackSource::Music) | None => music_placeholder_json(track, index, content_id),
};
if let Some(object) = json.as_object_mut() {
if let Some(source) = &track.source
&& let Ok(source) = serde_json::to_value(source)
{
object.insert(SOURCE_KEY.to_string(), source);
}
if let Ok(wire) = serde_json::to_value(track) {
object.insert(WIRE_TRACK_KEY.to_string(), wire);
}
}
json
}
/// Display fields of unresolved federated music (unchanged from earlier
/// releases, which had no verbatim wire item).
fn music_placeholder_json(track: &PlaybackTrack, index: usize, content_id: Option<&str>) -> Value {
let artists = if !track.artist_names.is_empty() {
track.artist_names.clone()
} else if let Some(fed) = &track.fed {
fed.artist_names.clone()
} else {
Vec::new()
};
let featured = if !track.featured_artist_names.is_empty() {
track.featured_artist_names.clone()
} else if let Some(fed) = &track.fed {
fed.featured_artist_names.clone()
} else {
Vec::new()
};
let title = track
.fed
.as_ref()
.map(|fed| fed.title.as_str())
.filter(|title| !title.trim().is_empty())
.unwrap_or(&track.title);
let release_title = track
.fed
.as_ref()
.and_then(|fed| fed.release_title.as_deref())
.filter(|title| !title.trim().is_empty())
.unwrap_or(&track.release_title);
let content_id = content_id
.map(ToString::to_string)
.or_else(|| track.content_id.clone())
.or_else(|| track.fed.as_ref().map(|fed| fed.content_id.clone()));
serde_json::json!({
"id": placeholder_track_id(content_id.as_deref(), index),
"title": title,
"track_number": track.track_number,
"disc_number": track.disc_number,
"duration_seconds": track.duration_seconds,
"artists": artist_names_to_json(&artists),
"featured_artists": artist_names_to_json(&featured),
"release_id": 0,
"release_title": release_title,
"release_year": track.release_year,
"cover_url": serde_json::Value::Null,
"stream_url": "",
"uploader_name": "Federation",
"audio_format": track.audio_format.clone(),
"audio_bitrate": track.audio_bitrate,
"audio_sample_rate": track.audio_sample_rate,
"audio_bit_depth": track.audio_bit_depth,
"file_size_bytes": track.file_size_bytes,
"content_id": content_id,
"unavailable": true,
"unavailable_reason": FED_UNAVAILABLE_REASON,
})
}
fn artist_names_to_json(names: &[String]) -> Vec<Value> {
names
.iter()
.enumerate()
.filter(|(_, name)| !name.trim().is_empty())
.map(|(index, name)| serde_json::json!({"id": -((index as i64) + 1), "name": name}))
.collect()
}
fn placeholder_track_id(seed: Option<&str>, index: usize) -> i64 {
let mut bytes = [0u8; 8];
let hash = blake3::hash(seed.unwrap_or("").as_bytes());
bytes.copy_from_slice(&hash.as_bytes()[..8]);
let value = i64::from_le_bytes(bytes).unsigned_abs() % 9_000_000_000_000;
-((value as i64) + index as i64 + 1)
}
/// The device-sync item carried by an external browser track.
///
/// Returns the verbatim [`WIRE_TRACK_KEY`] DTO when present. Otherwise a
/// browser item that only names a podcast or private [`SOURCE_KEY`] is
/// rebuilt with the shared constructors. Library tracks (and malformed
/// items) return `None` and keep the library mapping.
pub(crate) fn wire_track_from_browser_json(track: &Value) -> Option<PlaybackTrack> {
if let Some(wire) = track.get(WIRE_TRACK_KEY).filter(|wire| wire.is_object())
&& let Ok(wire) = serde_json::from_value::<PlaybackTrack>(wire.clone())
{
return Some(wire);
}
match serde_json::from_value::<PlaybackSource>(track.get(SOURCE_KEY)?.clone()).ok()? {
PlaybackSource::PodcastEpisode(episode) => Some(PlaybackTrack::podcast_episode(*episode)),
PlaybackSource::Private => Some(PlaybackTrack::private_placeholder()),
PlaybackSource::Music => None,
}
}
/// Whether a browser item is a podcast episode or a Jam placeholder.
pub(crate) fn browser_track_requires_podcast_support(track: &Value) -> bool {
wire_track_from_browser_json(track).is_some_and(|track| track.requires_podcast_support())
}
/// Wire-shaped view of browser tracks for the shared gating and Jam helpers.
///
/// External items are their verbatim DTOs. Library tracks become minimal
/// music items: the helpers only look at item sources and positions, so
/// this conversion needs no database lookups.
pub(crate) fn shadow_wire_state(tracks: &[Value], index: usize) -> PlaybackStateWire {
PlaybackStateWire {
queue: tracks
.iter()
.map(|track| wire_track_from_browser_json(track).unwrap_or_else(|| music_stub(track)))
.collect(),
queue_pos: index,
playing: false,
paused: true,
idle_since_ms: None,
position_secs: 0.0,
volume: 0,
shuffle: false,
repeat: Default::default(),
playback_rate: None,
}
}
fn music_stub(track: &Value) -> PlaybackTrack {
PlaybackTrack {
id: track.get("id").and_then(Value::as_i64).unwrap_or(0),
title: String::new(),
track_number: None,
disc_number: None,
duration_seconds: 0.0,
artist_names: Vec::new(),
featured_artist_names: Vec::new(),
release_id: 0,
release_title: String::new(),
release_year: None,
file_path: String::new(),
content_id: None,
audio_format: None,
audio_bitrate: None,
audio_sample_rate: None,
audio_bit_depth: None,
file_size_bytes: None,
play_count: 0,
fed: None,
source: None,
}
}
/// Browser tracks as shown to Jam participants.
///
/// Uses [`redact_for_jam`]: every podcast episode (and existing placeholder)
/// becomes the opaque private placeholder; music, order and position stay.
pub(crate) fn redact_tracks_for_jam(tracks: &[Value]) -> Vec<Value> {
let redacted = redact_for_jam(shadow_wire_state(tracks, 0));
tracks
.iter()
.zip(redacted.queue.iter())
.enumerate()
.map(|(index, (original, redacted))| {
if redacted.is_private_placeholder() {
external_track_json(redacted, index, None)
} else {
original.clone()
}
})
.collect()
}
/// Maps the private placeholders of a Jam participant's full queue back to
/// the host's items ([`restore_jam_private_items`]).
///
/// Returns `None` when the participant queue contains real podcast episodes
/// or drops, duplicates or injects private items; the command is then
/// rejected.
pub(crate) fn restore_jam_tracks(host: &[Value], participant: &[Value]) -> Option<Vec<Value>> {
let host_state = shadow_wire_state(host, 0);
let restored = restore_jam_private_items(&host_state, shadow_wire_state(participant, 0))?;
let mut host_private = host
.iter()
.zip(host_state.queue.iter())
.filter(|(_, wire)| wire.requires_podcast_support())
.map(|(json, _)| json);
let participant_state = shadow_wire_state(participant, 0);
let mut out = Vec::with_capacity(participant.len());
for ((json, before), after) in participant
.iter()
.zip(participant_state.queue.iter())
.zip(restored.queue.iter())
{
if before.is_private_placeholder() {
out.push(host_private.next()?.clone());
} else {
debug_assert_eq!(before, after);
out.push(json.clone());
}
}
Some(out)
}
/// Whether tracks sent by a Jam participant may enter the host queue at all
/// ([`jam_command_allowed`]): participants cannot add podcast episodes.
pub(crate) fn jam_tracks_allowed(tracks: &[Value]) -> bool {
jam_command_allowed(&PlaybackCommand::SetState {
state: shadow_wire_state(tracks, 0),
seek: false,
})
}
/// Typed playback queue persisted next to the legacy `queue_json`.
///
/// `queue_json` (a list of library track ids) is still written for rollback
/// to older releases. `legacy_queue`, `legacy_current_track_id` and
/// `legacy_queue_position` record the legacy columns written alongside this
/// value: when they no longer match the row (an older release or a
/// legacy-only writer changed the queue or moved to another track since),
/// readers ignore the typed value and fall back to the legacy columns.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub(crate) struct StoredQueue {
/// Shape version, [`STORED_QUEUE_VERSION`].
pub(crate) version: u16,
/// Index of the current item in `items`.
#[serde(default)]
pub(crate) position: usize,
/// Queue items in order.
#[serde(default)]
pub(crate) items: Vec<StoredQueueItem>,
/// `queue_json` ids written together with this value.
#[serde(default)]
pub(crate) legacy_queue: Vec<i64>,
/// `current_track_id` written together with this value.
#[serde(default)]
pub(crate) legacy_current_track_id: Option<i64>,
/// `queue_position` written together with this value (`None`: unknown,
/// the value is not used).
#[serde(default)]
pub(crate) legacy_queue_position: Option<i32>,
}
/// Legacy queue columns of a `furumusic__playback_state` row.
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub(crate) struct LegacyColumns {
/// `queue_json`: library track ids.
pub(crate) queue: Vec<i64>,
/// `current_track_id`.
pub(crate) current_track_id: Option<i64>,
/// `queue_position`.
pub(crate) queue_position: i32,
}
/// One persisted queue item.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub(crate) enum StoredQueueItem {
/// Library track of this server.
Library {
/// Local track id.
track_id: i64,
},
/// Any other item, kept verbatim with its explicit `source`.
External {
/// Device-sync queue item.
track: Box<PlaybackTrack>,
},
}
impl StoredQueue {
/// Builds the persisted value; `None` when the queue exceeds the bound.
///
/// Jam private placeholders are dropped: they stand for the Jam host's
/// items, never for items of this user's own queue.
pub(crate) fn new(
items: Vec<StoredQueueItem>,
position: usize,
legacy: LegacyColumns,
) -> Option<Self> {
if items.len() > MAX_STORED_QUEUE_ITEMS {
return None;
}
let mut stored = Self {
version: STORED_QUEUE_VERSION,
position,
items,
legacy_queue: Vec::new(),
legacy_current_track_id: None,
legacy_queue_position: None,
};
stored.retain_items(|item| match item {
StoredQueueItem::Library { .. } => true,
StoredQueueItem::External { track } => !track.is_private_placeholder(),
});
stored.set_legacy(legacy);
Some(stored)
}
/// Reads the typed column, preferring it over the legacy columns only
/// when it has a known version and was written together with exactly
/// these legacy values.
pub(crate) fn from_columns(typed: Option<&Value>, legacy: &LegacyColumns) -> Option<Self> {
let stored = serde_json::from_value::<Self>(typed?.clone()).ok()?;
(stored.version == STORED_QUEUE_VERSION
&& stored.legacy_queue == legacy.queue
&& stored.legacy_current_track_id == legacy.current_track_id
&& stored.legacy_queue_position == Some(legacy.queue_position)
&& stored.items.len() <= MAX_STORED_QUEUE_ITEMS)
.then_some(stored)
}
/// Removes library tracks rejected by `keep` and records the new legacy
/// columns. The current position follows its item, or the item after it
/// when the current item was removed.
pub(crate) fn retain_library(&mut self, keep: impl Fn(i64) -> bool, legacy: LegacyColumns) {
self.retain_items(|item| match item {
StoredQueueItem::Library { track_id } => keep(*track_id),
StoredQueueItem::External { .. } => true,
});
self.set_legacy(legacy);
}
fn retain_items(&mut self, keep: impl Fn(&StoredQueueItem) -> bool) {
let original_position = self.position;
let mut position = self.position;
let mut index = 0;
self.items.retain(|item| {
let retained = keep(item);
if !retained && index < original_position {
position = position.saturating_sub(1);
}
index += 1;
retained
});
self.position = position.min(self.items.len().saturating_sub(1));
}
fn set_legacy(&mut self, legacy: LegacyColumns) {
self.legacy_queue = legacy.queue;
self.legacy_current_track_id = legacy.current_track_id;
self.legacy_queue_position = Some(legacy.queue_position);
}
}
/// A valid podcast episode reference for tests.
#[cfg(test)]
pub(crate) fn test_episode() -> music_dht::podcast::PodcastEpisodeRef {
use music_dht::podcast::{EpisodeId, FeedUrl, PodcastEpisodeRef, PodcastId};
let feed_url = FeedUrl::parse("https://podcasts.example/feed.xml?token=Ab").unwrap();
let podcast_id = PodcastId::from_feed_url(&feed_url);
let episode_id = EpisodeId::from_guid(&podcast_id, "episode-42").unwrap();
PodcastEpisodeRef {
podcast_id,
episode_id,
feed_url,
podcast_title: "Example Cast".into(),
episode_title: "Episode 42".into(),
audio_url: "https://cdn.example/ep42.mp3".into(),
mime: Some("audio/mpeg".into()),
duration_ms: Some(1_800_000),
published_at_ms: Some(1_700_000_000_000),
season: Some(2),
episode_number: Some(42),
image_url: None,
progress_generation: Some(7),
}
}
#[cfg(test)]
mod tests {
use super::*;
use music_dht::podcast::EpisodeId;
fn episode() -> music_dht::podcast::PodcastEpisodeRef {
test_episode()
}
fn library(id: i64) -> Value {
serde_json::json!({"id": id, "title": format!("Track {id}"), "stream_url": format!("/api/player/stream/{id}")})
}
#[test]
fn podcast_item_round_trips_through_browser_json() {
let mut wire = PlaybackTrack::podcast_episode(episode());
wire.play_count = 3;
let json = external_track_json(&wire, 4, None);
assert_eq!(json["unavailable"], true);
assert_eq!(json["unavailable_reason"], PODCAST_UNAVAILABLE_REASON);
assert_eq!(json["title"], "Episode 42");
assert_eq!(json[SOURCE_KEY]["kind"], "podcast_episode");
assert!(json["id"].as_i64().unwrap() < 0);
// The browser stores and echoes the object; the item is unchanged.
let echoed: Value = serde_json::from_str(&json.to_string()).unwrap();
assert_eq!(wire_track_from_browser_json(&echoed), Some(wire));
}
#[test]
fn private_and_unresolved_music_keep_their_wire_item() {
let private = PlaybackTrack::private_placeholder();
let json = external_track_json(&private, 0, None);
assert_eq!(json["title"], PRIVATE_ITEM_TITLE);
assert_eq!(json[SOURCE_KEY]["kind"], "private");
assert_eq!(wire_track_from_browser_json(&json), Some(private));
let mut music = PlaybackTrack::private_placeholder();
music.source = None;
music.title = "Remote song".into();
music.content_id = Some(format!("b3:{}", "a".repeat(64)));
let json = external_track_json(&music, 1, music.content_id.as_deref());
assert!(json.get(SOURCE_KEY).is_none());
assert_eq!(json["unavailable_reason"], FED_UNAVAILABLE_REASON);
assert_eq!(wire_track_from_browser_json(&json), Some(music));
}
#[test]
fn library_tracks_are_not_external() {
assert_eq!(wire_track_from_browser_json(&library(5)), None);
let mut music_source = library(6);
music_source[SOURCE_KEY] = serde_json::json!({"kind": "music"});
assert_eq!(wire_track_from_browser_json(&music_source), None);
}
#[test]
fn source_only_items_use_shared_constructors() {
let json = serde_json::json!({
"id": -1,
SOURCE_KEY: serde_json::to_value(PlaybackSource::PodcastEpisode(Box::new(episode()))).unwrap(),
});
assert_eq!(
wire_track_from_browser_json(&json),
Some(PlaybackTrack::podcast_episode(episode()))
);
// A malformed verbatim item falls back to the explicit source.
let mut tampered = json.clone();
tampered[WIRE_TRACK_KEY] = serde_json::json!({"id": "x"});
assert_eq!(
wire_track_from_browser_json(&tampered),
Some(PlaybackTrack::podcast_episode(episode()))
);
}
#[test]
fn jam_redaction_hides_episodes_and_restores_them_in_order() {
let first = external_track_json(&PlaybackTrack::podcast_episode(episode()), 1, None);
let mut other = episode();
other.episode_title = "Episode 43".into();
other.episode_id = EpisodeId::from_guid(&other.podcast_id, "episode-43").unwrap();
let second = external_track_json(&PlaybackTrack::podcast_episode(other), 3, None);
let host = vec![library(1), first.clone(), library(2), second.clone()];
let redacted = redact_tracks_for_jam(&host);
assert_eq!(redacted[0], host[0]);
assert_eq!(redacted[1]["title"], PRIVATE_ITEM_TITLE);
let leaked = serde_json::to_string(&redacted).unwrap();
assert!(!leaked.contains("Episode 4") && !leaked.contains("podcasts.example"));
assert!(!leaked.contains("cdn.example") && !leaked.contains("Example Cast"));
// The participant reorders music and moves a placeholder.
let participant = vec![
redacted[3].clone(),
library(2),
redacted[1].clone(),
library(1),
];
let restored = restore_jam_tracks(&host, &participant).unwrap();
assert_eq!(
restored,
vec![first.clone(), library(2), second, library(1)]
);
// Dropping, duplicating or injecting private items is rejected.
assert!(restore_jam_tracks(&host, &[library(1), redacted[1].clone()]).is_none());
assert!(restore_jam_tracks(&host, &[first.clone(), redacted[1].clone()]).is_none());
assert!(!jam_tracks_allowed(std::slice::from_ref(&first)));
assert!(jam_tracks_allowed(&[library(9)]));
}
fn legacy(queue: &[i64], current_track_id: Option<i64>, queue_position: i32) -> LegacyColumns {
LegacyColumns {
queue: queue.to_vec(),
current_track_id,
queue_position,
}
}
#[test]
fn stored_queue_prefers_typed_value_only_while_legacy_ids_match() {
let items = vec![
StoredQueueItem::Library { track_id: 3 },
StoredQueueItem::External {
track: Box::new(PlaybackTrack::podcast_episode(episode())),
},
StoredQueueItem::Library { track_id: 4 },
];
// The episode is current: the browser wrote its placeholder id.
let written = legacy(&[3, -11, 4], Some(-11), 1);
let stored = StoredQueue::new(items, 1, written.clone()).unwrap();
let value = serde_json::to_value(&stored).unwrap();
assert_eq!(value["version"], 1);
assert_eq!(value["items"][1]["kind"], "external");
assert_eq!(
value["items"][1]["track"]["source"]["kind"],
"podcast_episode"
);
assert_eq!(
StoredQueue::from_columns(Some(&value), &written),
Some(stored.clone())
);
// A rollback release rewrote queue_json: fall back to it.
assert_eq!(
StoredQueue::from_columns(Some(&value), &legacy(&[3, 4], Some(4), 1)),
None
);
// A rollback release kept the ids but moved to another track (Next
// or a click): the typed position is stale, fall back as well.
assert_eq!(
StoredQueue::from_columns(Some(&value), &legacy(&[3, -11, 4], Some(4), 2)),
None
);
assert_eq!(
StoredQueue::from_columns(Some(&value), &legacy(&[3, -11, 4], Some(-11), 0)),
None
);
// Values without the recorded current item are not trusted.
let mut unknown = value.clone();
unknown
.as_object_mut()
.unwrap()
.remove("legacy_queue_position");
assert_eq!(StoredQueue::from_columns(Some(&unknown), &written), None);
let mut future = value.clone();
future["version"] = serde_json::json!(2);
assert_eq!(StoredQueue::from_columns(Some(&future), &written), None);
assert_eq!(StoredQueue::from_columns(None, &written), None);
}
#[test]
fn stored_queue_never_keeps_jam_placeholders() {
let items = vec![
StoredQueueItem::Library { track_id: 3 },
StoredQueueItem::External {
track: Box::new(PlaybackTrack::private_placeholder()),
},
StoredQueueItem::External {
track: Box::new(PlaybackTrack::podcast_episode(episode())),
},
StoredQueueItem::Library { track_id: 4 },
];
let stored = StoredQueue::new(items.clone(), 3, legacy(&[3, 4], Some(4), 1)).unwrap();
assert_eq!(
stored.items,
vec![items[0].clone(), items[2].clone(), items[3].clone()]
);
assert_eq!(stored.position, 2);
// A current placeholder hands the position to the next item.
let stored = StoredQueue::new(items.clone(), 1, legacy(&[3, 4], None, 0)).unwrap();
assert_eq!(stored.position, 1);
assert_eq!(stored.items[1], items[2]);
}
#[test]
fn stored_queue_cleanup_keeps_external_items_and_position() {
let items = vec![
StoredQueueItem::Library { track_id: 3 },
StoredQueueItem::External {
track: Box::new(PlaybackTrack::podcast_episode(episode())),
},
StoredQueueItem::Library { track_id: 4 },
];
let mut stored = StoredQueue::new(items.clone(), 1, legacy(&[3, 4], None, 0)).unwrap();
stored.retain_library(|id| id != 3, legacy(&[4], None, 0));
assert_eq!(stored.items, items[1..].to_vec());
assert_eq!(stored.position, 0);
assert_eq!(stored.legacy_queue, vec![4]);
// The cleanup's new legacy columns are what readers compare with.
let value = serde_json::to_value(&stored).unwrap();
assert_eq!(
StoredQueue::from_columns(Some(&value), &legacy(&[4], None, 0)),
Some(stored)
);
let mut current_removed =
StoredQueue::new(items.clone(), 2, legacy(&[3, 4], Some(4), 1)).unwrap();
current_removed.retain_library(|id| id != 4, legacy(&[3], None, 0));
assert_eq!(current_removed.position, 1);
assert!(
StoredQueue::new(
vec![items[0].clone(); MAX_STORED_QUEUE_ITEMS + 1],
0,
LegacyColumns::default()
)
.is_none()
);
}
}
+2 -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,
}
@@ -65,6 +65,7 @@ pub(super) struct PlaybackStateRow {
pub(super) current_track_id: Option<i64>,
pub(super) position_ms: i32,
pub(super) queue_json: String,
pub(super) queue_items_json: Option<serde_json::Value>,
pub(super) queue_position: i32,
pub(super) shuffle: bool,
pub(super) repeat_mode: 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"
File diff suppressed because it is too large. Load diff
+63 -46
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>
@@ -1512,7 +1521,8 @@
<template x-for="item in $store.queue.displayItems()" :key="item.key">
<div class="queue-track"
:data-queue-index="item.index"
:class="{ active: item.state === 'current', current: item.state === 'current', played: item.state === 'played', dragging: $store.queue._dragIdx === item.index, synthetic: item.synthetic, 'foreign-jam-track': $store.queue.isForeignJamTrack(item.track) }"
:class="{ active: item.state === 'current', current: item.state === 'current', played: item.state === 'played', dragging: $store.queue._dragIdx === item.index, synthetic: item.synthetic, 'foreign-jam-track': $store.queue.isForeignJamTrack(item.track), unplayable: $store.player._isUnplayableQueueItem(item.track) }"
:title="$store.player._unplayableQueueLabel(item.track) || null"
:style="$store.queue.isForeignJamTrack(item.track) ? $store.queue.contributorStyle(item.track) : ''"
@click="item.index >= 0 ? $store.queue.playFromIndex(item.index) : $store.player.play(item.track)"
:draggable="!item.synthetic"
@@ -1565,6 +1575,10 @@
</div>
<div class="queue-track-info">
<div class="queue-track-title" x-text="item.track.title"></div>
<div class="queue-track-unplayable"
x-show="$store.player._isUnplayableQueueItem(item.track)"
x-cloak
x-text="$store.player._unplayableQueueLabel(item.track)"></div>
<div class="queue-track-artist">
<template x-for="(artist, artistIdx) in $store.library.trackArtistLinks(item.track)" :key="artist.label + '-' + artist.id + '-' + artistIdx">
<span>
@@ -1620,14 +1634,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 +1741,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 +1750,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 +1771,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">
@@ -1791,8 +1805,11 @@
<span>Trusted federation devices</span>
</div>
</template>
<template x-if="$store.devices.selectError">
<div class="fed-device-error device-select-error" role="alert" x-text="$store.devices.selectError"></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 +1835,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 +1858,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 +1882,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 +1895,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>
+34 -1
View File
@@ -1440,6 +1440,17 @@ button.user-stat:hover {
.queue-track.current .queue-track-title { color: var(--accent); }
.queue-track.played .queue-track-title { color: var(--text-subdued); }
.queue-track.unplayable .queue-track-title,
.queue-track.unplayable .queue-track-cover { opacity: 0.55; }
.queue-track-unplayable {
font-size: 11px;
color: var(--text-subdued);
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
.queue-track-artist {
font-size: 11px;
color: var(--text-subdued);
@@ -2065,6 +2076,10 @@ button.user-stat:hover {
color: #ffb2b2;
}
.device-select-error {
padding: 6px 12px;
}
.fed-device-row {
min-height: 32px;
display: grid;
@@ -6666,7 +6681,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 +7017,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, []);
});
+377
View File
@@ -0,0 +1,377 @@
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');
// Queue items received from trusted devices that this player cannot play.
const podcast = {
id: -11, title: 'Episode 42', unavailable: true, stream_url: '',
source: {kind: 'podcast_episode', episode_id: 'ep1:x'},
wire_track: {id: 0, title: 'Episode 42', source: {kind: 'podcast_episode', episode_id: 'ep1:x'}},
};
const privateItem = {
id: -12, title: 'Private item', unavailable: true, stream_url: '',
source: {kind: 'private'}, wire_track: {id: 0, title: 'Private item', source: {kind: 'private'}},
};
const remoteMusic = {id: -13, title: 'Remote', unavailable: true, stream_url: '', wire_track: {id: 4, title: 'Remote'}};
const song = id => ({id, title: `Song ${id}`, stream_url: `/api/player/stream/${id}`});
function player(queue) {
// Exercise the production methods with audio and store stubs.
const methods = template.slice(
template.indexOf(' _queueItemSourceKind(track)'),
template.indexOf(' _saveState()'),
);
const audio = {paused: false, src: 'old', pause() { this.paused = true; }, removeAttribute(name) { if (name === 'src') this.src = ''; }, load() {}};
const stores = {queue: Object.assign({syncCurrentIndexToTrack() {}}, queue)};
const context = vm.createContext({
audio, T: {queuePodcastUnplayable: 'Podcast · not playable', queuePrivateItem: 'Private item · hidden'},
Alpine: {store: name => stores[name]},
});
vm.runInContext('this.methods = {' + methods + '};', context);
return Object.assign(context.methods, {audio, currentTrack: null, currentTime: 0, volume: 0.5, shuffle: false, repeatMode: 'off'});
}
test('podcast and private items are labelled and never played locally', () => {
const p = player({tracks: [], currentIndex: 0});
assert.equal(p._isUnplayableQueueItem(podcast), true);
assert.equal(p._isUnplayableQueueItem(privateItem), true);
assert.equal(p._isUnplayableQueueItem(remoteMusic), false);
assert.equal(p._isUnplayableQueueItem(song(1)), false);
assert.equal(p._unplayableQueueLabel(podcast), 'Podcast · not playable');
assert.equal(p._unplayableQueueLabel(privateItem), 'Private item · hidden');
assert.equal(p._unplayableQueueLabel(song(1)), '');
// A browser item that only carries the verbatim wire item is recognised too.
assert.equal(p._isUnplayableQueueItem({id: -1, wire_track: podcast.wire_track}), true);
});
test('skipping finds the next playable item in the direction of travel', () => {
const p = player({tracks: [], currentIndex: 0});
const tracks = [song(1), podcast, privateItem, song(2)];
assert.equal(p._playableQueueIndex(tracks, 1, 1), 3);
assert.equal(p._playableQueueIndex(tracks, 2, -1), 0);
assert.equal(p._playableQueueIndex([podcast], 0, 1), -1);
});
test('showing an unplayable item stops and unloads the previous audio', () => {
const p = player({tracks: [podcast], currentIndex: 0});
p.isPlaying = true;
p._showUnplayableQueueItem(podcast);
assert.equal(p.audio.paused, true);
assert.equal(p.audio.src, '');
assert.equal(p.isPlaying, false);
assert.equal(p.currentTrack, podcast);
assert.equal(p._historyTrack, null);
});
test('persisted queue keeps external items verbatim and in order', () => {
const tracks = [song(1), podcast, remoteMusic, {id: 'pending', federation_pending: true}, song(2)];
const p = player({tracks, currentIndex: 4});
p.currentTrack = tracks[4];
p.currentTime = 12.3;
const state = p._buildStatePayload();
assert.deepEqual(JSON.parse(JSON.stringify(state.queue_items)), [
{kind: 'library', track_id: 1},
{kind: 'external', track: podcast.wire_track},
{kind: 'external', track: remoteMusic.wire_track},
{kind: 'library', track_id: 2},
]);
// The pending federation entry is not persisted, as before.
assert.equal(state.queue_items_position, 3);
// The legacy id list is unchanged for rollback.
assert.deepEqual(JSON.parse(JSON.stringify(state.queue)), [1, -11, -13, 2]);
assert.equal(state.current_track_id, 2);
});
test('restoring merges library tracks and external items', () => {
const p = player({tracks: [], currentIndex: 0});
const restored = p._restoredQueueTracks([
{kind: 'library', track_id: 1},
{kind: 'external', track: podcast},
{kind: 'library', track_id: 99},
{kind: 'library', track_id: 2},
], [song(2), song(1)]);
assert.deepEqual(Array.from(restored.tracks, track => track.id), [1, -11, 2]);
assert.equal(restored.positions[3], 2);
assert.equal(restored.positions[2], undefined);
});
// Production methods by name, for flows that span several of them.
function method(name) {
const start = template.indexOf(`\n ${name}(`);
assert.ok(start >= 0, `method ${name} not found`);
const end = template.indexOf('\n },\n', start);
return template.slice(start + 1, end + 11);
}
function activePlayer(queueTracks, currentIndex, audioState = {}, options = {}) {
// The browser as the active (local) playback device.
const names = [
'_executeRemoteCommand', '_applyRemotePlaybackState', '_tickRemoteProgress',
'_devicePlaybackStatePayload', '_remotePlaybackPayload', '_trackDuration',
'_pauseLocal', '_playLocal', 'resume', 'next', 'prev', 'playQueueIndex', 'seek',
'_skipUnplayableCurrentItem', '_knownPosition', '_currentItemHasLocalAudio',
'_showUnplayableQueueItem', '_syncLocalPlaybackState',
'_queueItemSourceKind', '_isUnplayableQueueItem', '_playableQueueIndex',
'_jamParticipantCommandAllowed', '_dropJamPlaceholders',
];
const audio = Object.assign({
paused: true, currentTime: 0, duration: NaN, src: '',
played: [],
pause() { this.paused = true; },
play() { this.paused = false; this.played.push(this.src); return Promise.resolve(); },
removeAttribute(name) { if (name === 'src') this.src = ''; },
load() { this.currentTime = 0; },
addEventListener() {}, removeEventListener() {},
}, audioState);
const queue = {
tracks: queueTracks, currentIndex,
_tracksWithJamDefaults: tracks => tracks,
syncCurrentIndexToTrack(track) {
const index = this.tracks.indexOf(track);
if (index >= 0) this.currentIndex = index;
},
// Simplified local queue edits, as the host applies remote commands.
_removeLocal(index) { if (index >= 0 && index < this.tracks.length) this.tracks.splice(index, 1); },
_moveTrackLocal(from, to) { this.tracks.splice(to, 0, this.tracks.splice(from, 1)[0]); },
_clearLocal() { this.tracks = []; },
_addToEndLocal(tracks) { this.tracks.push(...tracks); },
};
const stores = {queue, devices: {heartbeat() {}}};
const context = vm.createContext({audio, Alpine: {store: name => stores[name]}});
if (options.random != null) vm.runInContext(`Math.random = () => ${options.random};`, context);
vm.runInContext('this.methods = {' + names.map(method).join('\n') + '};', context);
return Object.assign(context.methods, {
audio, queue,
currentTrack: queueTracks[currentIndex] || null, currentTime: 0, duration: 0, progress: 0,
isPlaying: false, shuffle: false, repeatMode: 'off', volume: 0.5,
_remoteStateBaseTime: 0, _remoteStateReceivedAt: 0,
_isLocalPlaybackDevice: () => true, _shouldSendRemote: () => false,
_shouldMirrorRemoteLocally: () => false,
_setVolumeLocal(v) { this.volume = v; }, _updateMediaSession() {}, _saveState() {},
_recordHistory() {}, _resetPlaybackTracking() {}, _mirrorRemoteTrack() {},
});
}
const episode = Object.assign({}, podcast, {duration_seconds: 1800});
test('handoff of a podcast episode keeps its position for the next handoff', () => {
for (const audioTime of [95, 0]) {
// <audio> still holds a music track (95 s) or the page is fresh (0 s).
const p = activePlayer([song(1)], 0, {currentTime: audioTime, src: '/api/player/stream/1'});
p._executeRemoteCommand({command: 'transfer_state', payload: {
tracks: [song(1), episode], index: 1, track: episode,
position_seconds: 1200, duration_seconds: 1800, paused: false,
}});
assert.equal(p.currentTrack, episode);
assert.equal(p.currentTime, 1200);
assert.equal(p.isPlaying, false);
assert.equal(p.audio.src, '', 'the previous track is unloaded');
const reported = p._devicePlaybackStatePayload();
assert.equal(reported.position_seconds, 1200);
assert.equal(reported.position_unknown, undefined, 'a handed-off position is known');
assert.equal(reported.index, 1);
assert.equal(reported.paused, true);
}
});
test('library tracks still report the audio position', () => {
const p = activePlayer([song(1)], 0, {currentTime: 42, src: '/api/player/stream/1'});
p.currentTime = 40;
assert.equal(p._devicePlaybackStatePayload().position_seconds, 42);
});
test('resume on an unplayable item skips it, also with repeat one', () => {
for (const repeatMode of ['one', 'off', 'all']) {
const p = activePlayer([podcast], 0);
p.repeatMode = repeatMode;
p.currentTime = 30;
p.resume();
p.next();
assert.equal(p.currentTrack, podcast);
assert.equal(p.isPlaying, false);
assert.equal(p.currentTime, 30, 'the item keeps its position');
assert.deepEqual(p.audio.played, []);
}
const p = activePlayer([song(1), podcast, song(2)], 1);
p.repeatMode = 'one';
p.resume();
assert.equal(p.currentTrack.id, 2);
assert.deepEqual(p.audio.played, ['/api/player/stream/2']);
// Repeat all wraps around to the first playable item.
const wrap = activePlayer([song(1), podcast], 1);
wrap.repeatMode = 'all';
wrap.resume();
assert.equal(wrap.currentTrack.id, 1);
});
test('an episode reached without its position reports it as unknown, never as 0', () => {
// Next from the last music track lands on a trailing episode.
const p = activePlayer([song(1), episode], 0, {currentTime: 200, src: '/api/player/stream/1'});
p.isPlaying = true;
p.currentTime = 200;
p.next();
assert.equal(p.currentTrack, episode);
assert.equal(p.isPlaying, false);
let reported = p._devicePlaybackStatePayload();
assert.equal(reported.index, 1);
assert.equal(reported.position_unknown, true);
// Still unknown after Play finds nothing to skip to.
p.resume();
assert.equal(p._devicePlaybackStatePayload().position_unknown, true);
// A seek is an explicit position.
p.seek(600);
reported = p._devicePlaybackStatePayload();
assert.equal(reported.position_seconds, 600);
assert.equal(reported.position_unknown, undefined);
// Music never reports the flag.
p.playQueueIndex(0);
assert.equal(p.currentTrack.id, 1);
assert.equal(p._devicePlaybackStatePayload().position_unknown, undefined);
// Another browser or a Jam guest plays the episode row (position 0 sent).
const remote = activePlayer([song(1), episode], 0, {currentTime: 30, src: '/api/player/stream/1'});
remote._executeRemoteCommand({command: 'play_from_index', payload: {
tracks: [song(1), episode], index: 1, track: episode, position_seconds: 0, paused: false,
}});
assert.equal(remote.currentTrack, episode);
assert.equal(remote._devicePlaybackStatePayload().position_unknown, true);
// A transfer passes on what the previous device did not know.
const relay = activePlayer([song(1)], 0);
relay._executeRemoteCommand({command: 'transfer_state', payload: {
tracks: [song(1), episode], index: 1, track: episode, position_seconds: 0,
position_unknown: true, paused: true,
}});
assert.equal(relay._devicePlaybackStatePayload().position_unknown, true);
// A mirrored state with a known position keeps it.
const mirror = activePlayer([song(1), episode], 0);
mirror._syncLocalPlaybackState({tracks: [song(1), episode], index: 1, track: episode, position_seconds: 900, paused: true});
assert.equal(mirror._devicePlaybackStatePayload().position_seconds, 900);
assert.equal(mirror._devicePlaybackStatePayload().position_unknown, undefined);
});
test('repeat all and shuffle continue past a trailing unplayable item', () => {
const wrap = activePlayer([song(1), episode], 0, {currentTime: 200, src: '/api/player/stream/1'});
wrap.repeatMode = 'all';
wrap.isPlaying = true;
wrap.next();
assert.equal(wrap.currentTrack.id, 1);
assert.equal(wrap.queue.currentIndex, 0);
assert.deepEqual(wrap.audio.played, ['/api/player/stream/1']);
// Shuffle picks the episode (index 1 of 3) and continues with music
// (searching towards the pick from the current item).
const shuffled = activePlayer([song(1), episode, song(2)], 2, {src: '/api/player/stream/2'}, {random: 0.5});
shuffled.shuffle = true;
shuffled.next();
assert.equal(shuffled.currentTrack.id, 1);
assert.equal(shuffled.isPlaying, false, 'the stub audio does not fire play events');
assert.deepEqual(shuffled.audio.played, ['/api/player/stream/1']);
// A trailing episode picked by shuffle wraps to the first playable item.
const trailing = activePlayer([song(1), song(2), episode], 1, {src: '/api/player/stream/2'}, {random: 0.9});
trailing.shuffle = true;
trailing.next();
assert.equal(trailing.currentTrack.id, 1);
// Without repeat the queue ends on the episode, as before.
const stop = activePlayer([song(1), episode], 0, {src: '/api/player/stream/1'});
stop.next();
assert.equal(stop.currentTrack, episode);
assert.equal(stop.isPlaying, false);
});
test('prev and seek work on a handed-off episode', () => {
const p = activePlayer([song(1), song(3)], 0, {currentTime: 95, src: '/api/player/stream/1'});
p._executeRemoteCommand({command: 'transfer_state', payload: {
tracks: [song(1), episode], index: 1, track: episode,
position_seconds: 1200, duration_seconds: 1800, paused: false,
}});
// Seeking moves the episode's own position (nothing is loaded in <audio>).
p.seek(1500);
assert.equal(p.currentTime, 1500);
assert.equal(p._devicePlaybackStatePayload().position_seconds, 1500);
// Prev goes to the previous item instead of restarting the episode.
p.prev();
assert.equal(p.currentTrack.id, 1);
assert.deepEqual(p.audio.played, ['/api/player/stream/1']);
// At the start of the queue Prev leaves the episode and its position alone.
const first = activePlayer([episode, song(1)], 0);
first._executeRemoteCommand({command: 'transfer_state', payload: {
tracks: [episode, song(1)], index: 0, track: episode, position_seconds: 1200, paused: true,
}});
first.prev();
assert.equal(first.currentTrack, episode);
assert.equal(first.currentTime, 1200);
});
test('the Jam host keeps its private items against stale participant commands', () => {
const a = song(1);
const b = song(2);
const p = activePlayer([a, episode, b], 0, {src: '/api/player/stream/1'});
// One poll batch: the server checked index 2 against the old order [A, P, B].
for (const command of [
{command: 'queue_move', payload: {from_index: 1, to_index: 2, jam_participant: true}},
{command: 'queue_remove', payload: {index: 2, jam_participant: true}},
]) p._executeRemoteCommand(command);
assert.deepEqual(p.queue.tracks, [a, b, episode]);
p._executeRemoteCommand({command: 'queue_clear', payload: {jam_participant: true}});
assert.equal(p.queue.tracks.length, 3);
p._executeRemoteCommand({command: 'queue_add_end', payload: {tracks: [privateItem], jam_participant: true}});
assert.equal(p.queue.tracks.length, 3);
// A full queue from a stale view brings back nothing the host removed.
p._executeRemoteCommand({command: 'play_from_index', payload: {
tracks: [a, episode, episode, b], index: 0, track: a, jam_participant: true,
}});
assert.deepEqual(p.queue.tracks, [a, b, episode]);
p._executeRemoteCommand({command: 'play_from_index', payload: {
tracks: [a, b], index: 0, track: a, jam_participant: true,
}});
assert.deepEqual(p.queue.tracks, [a, b, episode]);
// Music is still theirs to change, and the host's own commands are not limited.
p._executeRemoteCommand({command: 'queue_remove', payload: {index: 0, jam_participant: true}});
assert.deepEqual(p.queue.tracks, [b, episode]);
p._executeRemoteCommand({command: 'play_from_index', payload: {
tracks: [episode, b], index: 1, track: b, jam_participant: true,
}});
assert.deepEqual(p.queue.tracks, [episode, b]);
p._executeRemoteCommand({command: 'queue_remove', payload: {index: 0}});
assert.deepEqual(p.queue.tracks, [b]);
});
test('leaving a Jam drops the host placeholders from the guest queue', () => {
const placeholder = Object.assign({}, privateItem);
const p = activePlayer([song(1), placeholder, song(2)], 1);
p.currentTrack = placeholder;
p._dropJamPlaceholders();
assert.deepEqual(Array.from(p.queue.tracks, track => track.id), [1, 2]);
// The current placeholder hands over to the next item, paused.
assert.equal(p.queue.currentIndex, 1);
assert.equal(p.currentTrack.id, 2);
assert.equal(p.isPlaying, false);
assert.deepEqual(p.audio.played, []);
const music = activePlayer([song(1), placeholder, song(2)], 2);
music._dropJamPlaceholders();
assert.equal(music.queue.currentIndex, 1);
assert.equal(music.currentTrack.id, 2);
const only = activePlayer([placeholder], 0);
only._dropJamPlaceholders();
assert.deepEqual(only.queue.tracks, []);
assert.equal(only.currentTrack, null);
// The guest's own podcast episodes stay.
const own = activePlayer([episode, song(1)], 0);
own._dropJamPlaceholders();
assert.equal(own.queue.tracks.length, 2);
});
test('the devices store drops placeholders when the guest stops controlling a Jam', () => {
const start = template.indexOf('\n _apply(data) {');
const apply = template.slice(start, template.indexOf('\n },\n', start));
assert.match(apply, /const wasControllingJam = this\.isControllingRemoteJam\(\);/);
assert.match(apply, /if \(wasControllingJam && !this\.isControllingRemoteJam\(\)\) \{\s*Alpine\.store\('player'\)\?\._dropJamPlaceholders\(\);/);
const clear = template.slice(template.indexOf('\n clearJamSelection() {'));
assert.match(clear.slice(0, clear.indexOf('\n },\n')), /if \(wasControllingJam\) Alpine\.store\('player'\)\?\._dropJamPlaceholders\(\);/);
});
+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"]}');